core

import { ArrayUtils } from '@dooboostore/core/array/ArrayUtils';

// Shuffle array
const shuffled = ArrayUtils.shuffle([1, 2, 3, 4, 5]);

// Create 2D array
const matrix = ArrayUtils.create2DArray(3, 3, 0);

// Set operations
const union = ArrayUtils.union([1, 2], [2, 3]); // [1, 2, 3]
const intersection = ArrayUtils.intersection([1, 2], [2, 3]); // [2]

import { StringUtils } from '@dooboostore/core/string/StringUtils';

// Korean postposition
const text = StringUtils.withPostposition('사과', '을/를'); // '사과를'

// Padding
const padded = StringUtils.padLeft('42', 5, '0'); // '00042'

// Emoji handling
const length = StringUtils.lengthWithEmoji('Hello 😀'); // 7

import { ObjectUtils } from '@dooboostore/core/object/ObjectUtils';

// Deep copy
const original = { a: { b: 1 } };
const copied = ObjectUtils.deepCopy(original);

// Path operations
const value = ObjectUtils.getByPath(obj, 'user.address.city');
ObjectUtils.setByPath(obj, 'user.name', 'John');

// Script evaluation
const result = ObjectUtils.evalScript('a + b', { a: 1, b: 2 }); // 3

import { ConvertUtils } from '@dooboostore/core/convert/ConvertUtils';

// Base64 encoding/decoding
const encoded = ConvertUtils.toBase64('Hello');
const decoded = ConvertUtils.fromBase64(encoded);

// JSON operations
const json = ConvertUtils.toJSON({ name: 'John' });
const obj = ConvertUtils.fromJSON(json);

// Type conversions
const num = ConvertUtils.toNumber('42'); // 42
const bool = ConvertUtils.toBoolean('true'); // true

import { FunctionUtils } from '@dooboostore/core/function/FunctionUtils';

// Debounce
const debounced = FunctionUtils.debounce(() => console.log('Called'), 300);

// Throttle
const throttled = FunctionUtils.throttle(() => console.log('Called'), 1000);

// Memoize
const memoized = FunctionUtils.memoize((n: number) => n * 2);

// Once
const once = FunctionUtils.once(() => console.log('Only once'));

import { MathUtil } from '@dooboostore/core/math/MathUtil';

// Clamp value
const clamped = MathUtil.clamp(15, 0, 10); // 10

// Linear interpolation
const lerp = MathUtil.lerp(0, 100, 0.5); // 50

// Random integer
const random = MathUtil.randomInt(1, 100);

// Round to decimal places
const rounded = MathUtil.round(3.14159, 2); // 3.14

import { DateUtils } from '@dooboostore/core/date/DateUtils';

// Format date
const formatted = DateUtils.format(new Date(), 'YYYY-MM-DD');

// Add days
const tomorrow = DateUtils.addDays(new Date(), 1);

// Difference in days
const diff = DateUtils.diffInDays(date1, date2);

// Is same day
const same = DateUtils.isSameDay(new Date(), new Date());

import { URLUtils } from '@dooboostore/core/url/URLUtils';

// Parse query string
const params = URLUtils.parseQuery('?name=John&age=30');

// Build query string
const query = URLUtils.buildQuery({ name: 'John', age: 30 });

// Join URL parts
const url = URLUtils.join('https://api.com', 'users', '123');

// Get domain
const domain = URLUtils.getDomain('https://example.com/path');

import { ValidUtils } from '@dooboostore/core/valid/ValidUtils';

// Email validation
const isEmail = ValidUtils.isEmail('test@example.com');

// URL validation
const isUrl = ValidUtils.isURL('https://example.com');

// Type checks
const isNum = ValidUtils.isNumber(42);
const isStr = ValidUtils.isString('hello');
const isEmpty = ValidUtils.isEmpty(null);

import { RandomUtils } from '@dooboostore/core/random/RandomUtils';

// Random integer
const num = RandomUtils.int(1, 100);

// Random float
const float = RandomUtils.float(0, 1);

// Random string
const str = RandomUtils.string(10);

// Random UUID
const uuid = RandomUtils.uuid();

// Random element
const item = RandomUtils.pick([1, 2, 3, 4, 5]);

import { ImageUtils } from '@dooboostore/core/image/ImageUtils';

// Load image
const img = await ImageUtils.load('image.jpg');

// Resize image
const resized = await ImageUtils.resize(img, 800, 600);

// Convert to base64
const base64 = await ImageUtils.toBase64(img);

// Crop image
const cropped = await ImageUtils.crop(img, 0, 0, 200, 200);

import { ReflectUtils } from '@dooboostore/core/reflect/ReflectUtils';

// Get metadata
const metadata = ReflectUtils.getMetadata('design:type', target, key);

// Set metadata
ReflectUtils.defineMetadata('custom', value, target, key);

// Check metadata
const has = ReflectUtils.hasMetadata('design:type', target, key);

// Get property names
const props = ReflectUtils.getOwnPropertyNames(obj);

import { Expression } from '@dooboostore/core/expression/Expression';

// Evaluate expression
const expr = new Expression('a + b * c');
const result = expr.evaluate({ a: 1, b: 2, c: 3 }); // 7

// Template binding
const template = new Expression('Hello, ${name}!');
const text = template.evaluate({ name: 'John' }); // 'Hello, John!'

import { Advice } from '@dooboostore/core/advice/Advice';

class ErrorHandler implements Advice<Error, string> {
  before(error: Error): void {
    console.log('Error occurred:', error.message);
  }

  after(result: string): void {
    console.log('Handled result:', result);
  }

  execute(error: Error): string {
    return `Error: ${error.message}`;
  }
}

import { Optional } from '@dooboostore/core/optional/Optional';

const value = Optional.of('Hello')
  .map(v => v.toUpperCase())
  .orElse('Default');

const empty = Optional.empty<string>()
  .orElseThrow(() => new Error('No value'));

const nullable = Optional.ofNullable(maybeNull)
  .ifPresent(v => console.log(v));

import { Point2D, Point3D, Rect, Vector } from '@dooboostore/core/entity';

// 2D Point operations
const p1 = new Point2D(10, 20);
const p2 = new Point2D(30, 40);
const distance = p1.distanceTo(p2);

// Rectangle operations
const rect = new Rect(0, 0, 100, 50);
const contains = rect.contains(new Point2D(50, 25));

// Vector operations
const v1 = new Vector(1, 2, 3);
const v2 = new Vector(4, 5, 6);
const dot = v1.dot(v2);

import { IOS3166_1 } from '@dooboostore/core/code/IOS3166_1';

// Get country by alpha2 code
const korea = IOS3166_1.getByAlpha2('KR');
// { alpha2: 'KR', alpha3: 'KOR', numeric: '410', name: 'Korea, Republic of' }

// Get country by alpha3 code
const usa = IOS3166_1.getByAlpha3('USA');

// Get all countries
const allCountries = IOS3166_1.getAll();

import { AsyncBlockingQueue } from '@dooboostore/core/queues/AsyncBlockingQueue';

const queue = new AsyncBlockingQueue<number>(10);

// Producer
await queue.enqueue(42);

// Consumer
const value = await queue.dequeue(); // Waits if empty

// Check size
const size = queue.size();

import { Range } from '@dooboostore/core/iterators/Range';

// Create range
for (const i of Range.create(0, 10)) {
  console.log(i); // 0, 1, 2, ..., 9
}

// Range with step
for (const i of Range.create(0, 10, 2)) {
  console.log(i); // 0, 2, 4, 6, 8
}

// To array
const arr = Range.toArray(0, 5); // [0, 1, 2, 3, 4]

import { TransactionManager } from '@dooboostore/core/transaction/TransactionManager';

const tm = new TransactionManager();

await tm.execute(async (tx) => {
  // Database operations
  await db.insert(data);
  await db.update(moreData);

  // Auto commit on success, rollback on error
});

import { Schedule } from '@dooboostore/core/schedule/Schedule';

// Run every 5 seconds
const task1 = Schedule.interval(() => {
  console.log('Periodic task');
}, 5000);

// Run once after delay
const task2 = Schedule.timeout(() => {
  console.log('Delayed task');
}, 3000);

// Cron-like scheduling
const task3 = Schedule.cron('0 0 * * *', () => {
  console.log('Daily task');
});

// Cancel task
task1.cancel();

import { Logger } from '@dooboostore/core/logger/Logger';

const logger = new Logger('MyApp');

logger.debug('Debug message');
logger.info('Info message');
logger.warn('Warning message');
logger.error('Error message', error);

// Set log level
logger.setLevel('warn');

// Custom formatter
logger.setFormatter((level, message) => {
  return `[${level}] ${message}`;
});

import { MemoryStorage } from '@dooboostore/core/storage/MemoryStorage';

const storage = new MemoryStorage();

// Set value
storage.set('key', 'value');

// Get value
const value = storage.get('key');

// Check existence
const has = storage.has('key');

// Remove value
storage.remove('key');

// Clear all
storage.clear();

import { HttpJsonFetcher } from '@dooboostore/core/fetch/HttpJsonFetcher';

const fetcher = new HttpJsonFetcher('https://api.example.com');

// GET request
const data = await fetcher.get('/users');

// POST request
const result = await fetcher.post('/users', { name: 'John' });

// PUT request
await fetcher.put('/users/1', { name: 'Jane' });

// DELETE request
await fetcher.delete('/users/1');

import { PromiseUtils, Result } from '@dooboostore/core/promise';

// Sleep utility
await PromiseUtils.sleep(1000);

// Settle all promises
const results = await PromiseUtils.settle([p1, p2, p3]);

// Retry with backoff
const data = await PromiseUtils.retry(
  () => fetch(url),
  { retries: 3, delay: 1000 }
);

// Result pattern
const result = Result.ok(42);
if (result.isOk()) {
  console.log(result.value);
}

const error = Result.err(new Error('Failed'));
const value = error.unwrapOr(0);

import { Subject, BehaviorSubject, ReplaySubject } from '@dooboostore/core/message';

// Subject
const subject = new Subject<number>();
subject.subscribe(value => console.log(value));
subject.next(42);

// BehaviorSubject (with initial value)
const behavior = new BehaviorSubject(0);
behavior.subscribe(value => console.log(value)); // Logs 0 immediately

// ReplaySubject (replays last N values)
const replay = new ReplaySubject<number>(3);
replay.next(1);
replay.next(2);
replay.subscribe(value => console.log(value)); // Logs 1, 2