@vpmedia/simplify 1.74.0 → 1.75.0

package/src/util/event_emitter.ts

@@ -0,0 +1,147 @@
+export type EventListener = (...args: any[]) => void;
+
+/**
+ * Internal listener wrapper that stores metadata
+ * about a registered event listener.
+ */
+class Listener {
+  fn: EventListener;
+  context: unknown;
+  once: boolean;
+
+  constructor(fn: EventListener, context: unknown, once = false) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once;
+  }
+}
+
+/**
+ * Event emitter implementation inspired by Node.js/EventEmitter3.
+ */
+export class EventEmitter {
+  #events: Map<string | symbol, Listener[]>;
+
+  constructor() {
+    this.#events = new Map();
+  }
+
+  /**
+   * Get all registered event names.
+   */
+  eventNames(): (string | symbol)[] {
+    return [...this.#events.keys()];
+  }
+
+  /**
+   * Get all listener functions registered for an event.
+   */
+  listeners(event: string | symbol): EventListener[] {
+    const listeners = this.#events.get(event);
+    return listeners ? listeners.map((l) => l.fn) : [];
+  }
+
+  /**
+   * Get the number of listeners registered for an event.
+   */
+  listenerCount(event: string | symbol): number {
+    const listeners = this.#events.get(event);
+    return listeners ? listeners.length : 0;
+  }
+
+  /**
+   * Emit an event, invoking all registered listeners.
+   */
+  emit(event: string | symbol, ...args: unknown[]): boolean {
+    const listeners = this.#events.get(event);
+    if (!listeners || listeners.length === 0) {
+      return false;
+    }
+
+    for (const listener of [...listeners]) {
+      listener.fn.apply(listener.context, args);
+      if (listener.once) {
+        this.off(event, listener.fn, listener.context);
+      }
+    }
+
+    return true;
+  }
+
+  #addListener(event: string | symbol, fn: EventListener, context: unknown, once: boolean): this {
+    if (typeof fn !== 'function') {
+      throw new TypeError('Listener must be a function');
+    }
+
+    const listener = new Listener(fn, context ?? this, once);
+    const listeners = this.#events.get(event);
+
+    if (listeners) {
+      listeners.push(listener);
+    } else {
+      this.#events.set(event, [listener]);
+    }
+
+    return this;
+  }
+
+  /**
+   * Register a persistent listener for an event.
+   */
+  on(event: string | symbol, fn: EventListener, context?: unknown): this {
+    return this.#addListener(event, fn, context, false);
+  }
+
+  /**
+   * Register a one-time listener for an event.
+   */
+  once(event: string | symbol, fn: EventListener, context?: unknown): this {
+    return this.#addListener(event, fn, context, true);
+  }
+
+  /**
+   * Remove a specific listener, or all listeners for an event.
+   */
+  off(event: string | symbol, fn?: EventListener, context?: unknown): this {
+    if (!this.#events.has(event)) {
+      return this;
+    }
+
+    if (!fn) {
+      this.#events.delete(event);
+      return this;
+    }
+
+    const filtered = this.#events.get(event)!.filter((listener) => {
+      if (listener.fn !== fn) {
+        return true;
+      }
+      if (context !== undefined && listener.context !== context) {
+        return true;
+      }
+      return false;
+    });
+
+    if (filtered.length > 0) {
+      this.#events.set(event, filtered);
+    } else {
+      this.#events.delete(event);
+    }
+
+    return this;
+  }
+
+  /**
+   * Remove all listeners from the emitter,
+   * or all listeners for a specific event.
+   */
+  removeAllListeners(event?: string | symbol): this {
+    if (event === undefined) {
+      this.#events.clear();
+    } else {
+      this.#events.delete(event);
+    }
+
+    return this;
+  }
+}

package/src/util/fetch.test.ts

@@ -0,0 +1,62 @@
+import { HTTP_404_NOT_FOUND } from '../const/http_status.js';
+import { fetchRetry, FetchError } from './fetch.js';
+
+describe('FetchError', () => {
+  test('constructor', () => {
+    const error = new FetchError('message', 'url', { method: 'GET' }, null);
+    expect(error.message).toEqual('message');
+    expect(error.resource).toEqual('url');
+    expect(error.fetchOptions).toMatchObject({ method: 'GET' });
+    expect(error.response).toBe(null);
+  });
+});
+
+describe('fetchRetry', () => {
+  test('fetch OK', async () => {
+    const response = await fetchRetry('/test.json', {
+      cache: 'no-cache',
+      keepalive: false,
+      method: 'GET',
+      redirect: 'error',
+    });
+    const json = await response.json();
+    const expectedJSON = {
+      success: true,
+      method: 'GET',
+    };
+    expect(json).toEqual(expectedJSON);
+  });
+  test('fetch unknown scheme', async () => {
+    try {
+      await fetchRetry('htps://', {});
+    } catch (error) {
+      const typedError = error instanceof Error ? error : new Error(String(error));
+      expect(typedError.message).toEqual('fetch failed');
+      const typedErrorCause =
+        typedError.cause instanceof Error ? typedError.cause : new Error(String(typedError.cause));
+      expect(typedErrorCause.message).toEqual('unknown scheme');
+    }
+  });
+  test('fetch 404 error with retry', async () => {
+    try {
+      await fetchRetry(
+        '/test_error.json',
+        {
+          cache: 'no-cache',
+          keepalive: false,
+          method: 'POST',
+          redirect: 'error',
+        },
+        { numTries: 2, statusExcludes: [], delay: 1 }
+      );
+    } catch (error) {
+      const typedError = error instanceof Error ? error : new Error(String(error));
+      expect(typedError).toBeInstanceOf(FetchError);
+      if (typedError instanceof FetchError) {
+        expect(typedError.message).toBe('Fetch error 404');
+        expect(typedError.response?.status).toBe(HTTP_404_NOT_FOUND);
+        expect(typedError.cause).toBe(HTTP_404_NOT_FOUND);
+      }
+    }
+  });
+});

package/src/util/{fetch.js → fetch.ts}

@@ -12,15 +12,23 @@ const logger = new Logger('fetch');
 
 export const HTTP_0_ANY = 0;
 
+export interface FetchRetryOptions {
+  delay?: number;
+  numTries?: number;
+  statusExcludes?: number[];
+  timeout?: number;
+}
+
 export class FetchError extends Error {
+  resource: string | URL | Request;
+  fetchOptions: RequestInit;
+  response: Response | null;
+  override cause: number | null;
+
   /**
    * Creates a new FetchError instance.
-   * @param {string} message - Error message.
-   * @param {string | URL | Request} resource - Fetch URL.
-   * @param {RequestInit} fetchOptions - Fetch options.
-   * @param {Response} response - Fetch response.
    */
-  constructor(message, resource, fetchOptions, response) {
+  constructor(message: string, resource: string | URL | Request, fetchOptions: RequestInit, response: Response | null) {
     super(message);
     this.name = 'FetchError';
     this.resource = resource;
@@ -32,31 +40,32 @@ export class FetchError extends Error {
 
 /**
  * Fetch with retry.
- * @param {string | URL | Request} resource - Fetch URL.
- * @param {RequestInit} fetchOptions - Fetch options.
- * @param {{delay?: number, numTries?: number, statusExcludes?: number[], timeout?: number}} [retryOptions] - Retry options.
- * @returns {Promise<Response>} Fetch result.
  */
-export const fetchRetry = async (resource, fetchOptions, retryOptions) => {
-  retryOptions ??= {};
-  retryOptions.timeout = Math.max(retryOptions.timeout ?? 30000, 1);
-  retryOptions.delay = Math.max(retryOptions.delay ?? 1000, 1);
-  retryOptions.numTries = Math.max(retryOptions.numTries ?? 1, 1);
-  retryOptions.statusExcludes ??= [
-    HTTP_401_UNAUTHORIZED,
-    HTTP_403_FORBIDDEN,
-    HTTP_405_METHOD_NOT_ALLOWED,
-    HTTP_422_UNPROCESSABLE_CONTENT,
-  ];
-  while (retryOptions.numTries > 0) {
+export const fetchRetry = async (
+  resource: string | URL | Request,
+  fetchOptions: RequestInit,
+  retryOptions?: FetchRetryOptions
+): Promise<Response> => {
+  const opts: Required<FetchRetryOptions> = {
+    timeout: Math.max(retryOptions?.timeout ?? 30_000, 1),
+    delay: Math.max(retryOptions?.delay ?? 1000, 1),
+    numTries: Math.max(retryOptions?.numTries ?? 1, 1),
+    statusExcludes: retryOptions?.statusExcludes ?? [
+      HTTP_401_UNAUTHORIZED,
+      HTTP_403_FORBIDDEN,
+      HTTP_405_METHOD_NOT_ALLOWED,
+      HTTP_422_UNPROCESSABLE_CONTENT,
+    ],
+  };
+  while (opts.numTries > 0) {
     const isOnline = globalThis.navigator?.onLine;
-    logger.info('request', { resource, fetchOptions, retryOptions, isOnline });
+    logger.info('request', { resource: String(resource), fetchOptions, retryOptions: { ...opts }, isOnline });
     const controller = new AbortController();
     const timeoutId = setTimeout(
       () => controller.abort(new DOMException('Fetch timed out', 'AbortError')),
-      retryOptions.timeout
+      opts.timeout
     );
-    const options = {
+    const options: RequestInit = {
       ...fetchOptions,
       signal: controller.signal,
     };
@@ -65,22 +74,22 @@ export const fetchRetry = async (resource, fetchOptions, retryOptions) => {
       if (!response.ok) {
         throw new FetchError(`Fetch error ${response.status}`, resource, options, response);
       }
-      logger.info('response', response);
+      logger.info('response', { status: response.status });
       return response;
     } catch (error) {
       const typedError = error instanceof Error ? error : new Error(String(error));
       logger.debug('error', getErrorDetails(typedError));
-      retryOptions.numTries -= 1;
+      opts.numTries -= 1;
       if (
-        retryOptions.numTries === 0 ||
+        opts.numTries === 0 ||
         (typedError instanceof FetchError &&
-          (retryOptions.statusExcludes.includes(typedError.response.status) ||
-            retryOptions.statusExcludes.includes(HTTP_0_ANY)))
+          (opts.statusExcludes.includes(typedError.response?.status ?? -1) ||
+            opts.statusExcludes.includes(HTTP_0_ANY)))
       ) {
         throw error;
       }
-      await delayPromise(retryOptions.delay);
-      retryOptions.delay *= 2;
+      await delayPromise(opts.delay);
+      opts.delay *= 2;
     } finally {
       clearTimeout(timeoutId);
     }

package/src/util/number.test.ts

@@ -0,0 +1,124 @@
+import { TypeCheckError } from '../typecheck/TypeCheckError.js';
+import {
+  fixFloatPrecision,
+  getRandomInt,
+  isEqual,
+  isGreater,
+  isGreaterOrEqual,
+  isInRange,
+  isLess,
+  isLessOrEqual,
+  deg2rad,
+  rad2deg,
+} from './number.js';
+
+test('Converts angle in degrees to radians', () => {
+  expect(deg2rad(90)).toBe(1.5707963267948966);
+  // @ts-expect-error
+  expect(() => deg2rad('')).toThrowError(TypeCheckError);
+});
+
+test('Converts angle in radians to degrees', () => {
+  expect(rad2deg(1.5707963267948966)).toBe(90);
+  // @ts-expect-error
+  expect(() => rad2deg('')).toThrowError(TypeCheckError);
+});
+
+describe('fixFloatPrecision', () => {
+  test('Fixes float precision issues', () => {
+    expect(fixFloatPrecision(0.20000000000000004)).toBe(0.2);
+  });
+
+  test('Handles zero', () => {
+    expect(fixFloatPrecision(0)).toBe(0);
+  });
+
+  test('Handles negative numbers', () => {
+    expect(fixFloatPrecision(-0.20000000000000004)).toBe(-0.2);
+  });
+
+  test('Handles very small numbers', () => {
+    expect(fixFloatPrecision(0.0000000000001)).toBe(0);
+    expect(fixFloatPrecision(-0.0000000000001)).toBe(0);
+  });
+
+  test('Handles integer numbers', () => {
+    expect(fixFloatPrecision(5)).toBe(5);
+  });
+
+  test('Handles string number input', () => {
+    expect(fixFloatPrecision('5.123456789')).toBe(5.123456789);
+  });
+
+  test('Throws error for invalid input', () => {
+    expect(fixFloatPrecision('abc')).toBe(Number.NaN);
+    expect(fixFloatPrecision(null)).toBe(Number.NaN);
+    expect(fixFloatPrecision(undefined)).toBe(Number.NaN);
+  });
+});
+
+describe('getRandomInt', () => {
+  test('Throws error if min or max is not finite number', () => {
+    // @ts-expect-error
+    expect(() => getRandomInt('', 1)).toThrowError(TypeCheckError);
+    // @ts-expect-error
+    expect(() => getRandomInt(1, '')).toThrowError(TypeCheckError);
+  });
+
+  test('Returns random integer within range when min equals max', () => {
+    expect(getRandomInt(1, 1)).toBe(1);
+  });
+
+  test('Returns random integer within range when min is less than max', () => {
+    const result = getRandomInt(1, 10);
+    expect(result).toBeGreaterThanOrEqual(1);
+    expect(result).toBeLessThanOrEqual(10);
+  });
+
+  test('Works with negative numbers', () => {
+    const result = getRandomInt(-5, -1);
+    expect(result).toBeGreaterThanOrEqual(-5);
+    expect(result).toBeLessThanOrEqual(-1);
+  });
+
+  test('Works with zero range', () => {
+    const result = getRandomInt(0, 0);
+    expect(result).toBe(0);
+  });
+});
+
+describe('number', () => {
+  test('isEq', () => {
+    expect(isEqual(1, 0)).toBe(false);
+    expect(isEqual(1, 1)).toBe(true);
+  });
+
+  test('isGt', () => {
+    expect(isGreater(1, 0)).toBe(true);
+    expect(isGreater(1, 1)).toBe(false);
+  });
+
+  test('isGtOrEq', () => {
+    expect(isGreaterOrEqual(1, 0)).toBe(true);
+    expect(isGreaterOrEqual(1, 1)).toBe(true);
+    expect(isGreaterOrEqual(1, 2)).toBe(false);
+  });
+
+  test('isGtOrEq', () => {
+    expect(isInRange(1, 0, 2)).toBe(true);
+    expect(isInRange(1, 0, 1)).toBe(true);
+    expect(isInRange(2, 0, 1)).toBe(false);
+  });
+
+  test('isLe', () => {
+    expect(isLess(1, 0)).toBe(false);
+    expect(isLess(0, 0)).toBe(false);
+    expect(isLess(0, 1)).toBe(true);
+  });
+
+  test('isLeOrEq', () => {
+    expect(isLessOrEqual(1, 0)).toBe(false);
+    expect(isLessOrEqual(0, 0)).toBe(true);
+    expect(isLessOrEqual(0, 1)).toBe(true);
+  });
+});

package/src/util/number.ts

@@ -0,0 +1,58 @@
+import { TypeCheckError } from '../typecheck/TypeCheckError.js';
+
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+
+const PRECISION = 12;
+const EPSILON = 1e-11;
+
+/**
+ * Converts degrees to radians.
+ */
+export const deg2rad = (degrees: number): number => {
+  if (!Number.isFinite(degrees)) {
+    throw new TypeCheckError('Argument degrees must be a finite number', { value: degrees });
+  }
+  return degrees * DEG_TO_RAD;
+};
+
+/**
+ * Converts radians to degrees.
+ */
+export const rad2deg = (radians: number): number => {
+  if (!Number.isFinite(radians)) {
+    throw new TypeCheckError('Argument radians must be a finite number', { value: radians });
+  }
+  return radians * RAD_TO_DEG;
+};
+
+/**
+ * Returns random integer in range.
+ */
+export const getRandomInt = (min: number, max: number): number => {
+  if (!Number.isFinite(min)) {
+    throw new TypeCheckError('Argument min must be finite number', { value: min });
+  }
+  if (!Number.isFinite(max)) {
+    throw new TypeCheckError('Argument max must be finite number', { value: max });
+  }
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+/**
+ * Normalizes floating point precision (e.g. 0.20000000000000004 → 0.2).
+ */
+export const fixFloatPrecision = (value: number | string | null | undefined): number => {
+  const parsedValue = typeof value === 'string' ? Number(value) : value;
+  if (parsedValue === null || parsedValue === undefined || !Number.isFinite(parsedValue)) {
+    return Number.NaN;
+  }
+  return Math.abs(parsedValue) < EPSILON ? 0 : Number(parsedValue.toPrecision(PRECISION));
+};
+
+export const isGreater = (value: number, min: number): boolean => value > min;
+export const isGreaterOrEqual = (value: number, min: number): boolean => value >= min;
+export const isLess = (value: number, min: number): boolean => value < min;
+export const isLessOrEqual = (value: number, min: number): boolean => value <= min;
+export const isInRange = (value: number, min: number, max: number): boolean => value >= min && value <= max;
+export const isEqual = (value: number, expected: number): boolean => value === expected;