@vpmedia/simplify 1.74.0 → 1.76.0

package/src/util/event_emitter.js

@@ -1,196 +0,0 @@
-/**
- * @callback EventListener
- * A function invoked when an event is emitted.
- * @param {...any} args - Arguments passed from the emitter.
- * @returns {void}
- */
-
-/**
- * Internal listener wrapper that stores metadata
- * about a registered event listener.
- */
-class Listener {
-  /**
-   * @param {EventListener} fn - The listener callback function.
-   * @param {any} context - The `this` value used when invoking the listener.
-   * @param {boolean} [once] - Whether the listener should be invoked only once.
-   */
-  constructor(fn, context, once = false) {
-    /** @type {EventListener} The listener callback */
-    this.fn = fn;
-
-    /** @type {any} Execution context for the callback */
-    this.context = context;
-
-    /** @type {boolean} Whether this listener is one-time */
-    this.once = once;
-  }
-}
-
-/**
- * Event emitter implementation inspired by Node.js/EventEmitter3.
- * Allows registering, emitting, and removing event listeners.
- */
-export class EventEmitter {
-  #events;
-
-  constructor() {
-    /**
-     * Map of event name - array of listener wrappers.
-     * @type {Map<string | symbol, Listener[]>}
-     */
-    this.#events = new Map();
-  }
-
-  /**
-   * Get all registered event names.
-   * @returns {(string | symbol)[]} Array of event identifiers.
-   */
-  eventNames() {
-    return [...this.#events.keys()];
-  }
-
-  /**
-   * Get all listener functions registered for an event.
-   * @param {string | symbol} event - Event name.
-   * @returns {EventListener[]} List of listener callbacks.
-   */
-  listeners(event) {
-    const listeners = this.#events.get(event);
-    return listeners ? listeners.map((l) => l.fn) : [];
-  }
-
-  /**
-   * Get the number of listeners registered for an event.
-   * @param {string | symbol} event - Event name.
-   * @returns {number} Number of listeners.
-   */
-  listenerCount(event) {
-    const listeners = this.#events.get(event);
-    return listeners ? listeners.length : 0;
-  }
-
-  /**
-   * Emit an event, invoking all registered listeners
-   * with the provided arguments.
-   * @param {string | symbol} event - Event name.
-   * @param {...any} args - Arguments passed to listeners.
-   * @returns {boolean} True if the event had listeners, otherwise false.
-   */
-  emit(event, ...args) {
-    const listeners = this.#events.get(event);
-    if (!listeners || listeners.length === 0) {
-      return false;
-    }
-
-    // Clone to prevent mutation during iteration
-    for (const listener of [...listeners]) {
-      listener.fn.apply(listener.context, args);
-      if (listener.once) {
-        this.off(event, listener.fn, listener.context);
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Internal helper for registering a listener.
-   * @param {string | symbol} event - Event name.
-   * @param {EventListener} fn - Listener callback.
-   * @param {any} context - Execution context for the callback.
-   * @param {boolean} once - Whether the listener is one-time.
-   * @returns {EventEmitter} The emitter instance.
-   */
-  #addListener(event, fn, context, once) {
-    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.
-   * @param {string | symbol} event - Event name.
-   * @param {EventListener} fn - Listener callback.
-   * @param {any} [context] - Optional execution context.
-   * @returns {EventEmitter} The emitter instance.
-   */
-  on(event, fn, context) {
-    return this.#addListener(event, fn, context, false);
-  }
-
-  /**
-   * Register a one-time listener for an event.
-   * The listener is removed after its first invocation.
-   * @param {string | symbol} event - Event name.
-   * @param {EventListener} fn - Listener callback.
-   * @param {any} [context] - Optional execution context.
-   * @returns {EventEmitter} The emitter instance.
-   */
-  once(event, fn, context) {
-    return this.#addListener(event, fn, context, true);
-  }
-
-  /**
-   * Remove a specific listener, or all listeners for an event.
-   * @param {string | symbol} event - Event name.
-   * @param {EventListener} [fn] - Listener callback to remove.
-   * @param {any} [context] - Context to match when removing.
-   * @returns {EventEmitter} The emitter instance.
-   */
-  off(event, fn, context) {
-    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.
-   * @param {string | symbol} [event] - Optional event name.
-   * @returns {EventEmitter} The emitter instance.
-   */
-  removeAllListeners(event) {
-    if (event === undefined) {
-      this.#events.clear();
-    } else {
-      this.#events.delete(event);
-    }
-
-    return this;
-  }
-}

package/src/util/number.js

@@ -1,118 +0,0 @@
-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.
- * @param {number} degrees - Angle in degrees.
- * @returns {number} Angle in radians.
- * @throws {TypeCheckError}
- */
-export const deg2rad = (degrees) => {
-  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.
- * @param {number} radians - Angle in radians.
- * @returns {number} Angle in degrees.
- * @throws {TypeCheckError}
- */
-export const rad2deg = (radians) => {
-  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.
- * @param {number} min - Min value.
- * @param {number} max - Max value.
- * @returns {number} Random integer in given range.
- * @throws {TypeError}
- */
-export const getRandomInt = (min, max) => {
-  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).
- * @param {number | string} value - Input value.
- * @returns {number} Fixed float precision value.
- */
-export const fixFloatPrecision = (value) => {
-  const parsedValue = typeof value === 'string' ? Number(value) : value;
-  if (!Number.isFinite(parsedValue)) {
-    return Number.NaN;
-  }
-  return Math.abs(parsedValue) < EPSILON ? 0 : Number(parsedValue.toPrecision(PRECISION));
-};
-
-/**
- * Value greater than check.
- * @param {number} value - Input value.
- * @param {number} min - Limit that `value` must be greater than.
- * @returns {boolean} `true` is check success.
- * @private
- */
-export const isGreater = (value, min) => value > min;
-
-/**
- * Value greater than check.
- * @param {number} value - Input value.
- * @param {number} min - Limit that `value` must be greater or equal than.
- * @returns {boolean} `true` is check success.
- * @private
- */
-export const isGreaterOrEqual = (value, min) => value >= min;
-
-/**
- * Value less than check.
- * @param {number} value - Input value.
- * @param {number} min - Limit that `value` must be greater than.
- * @returns {boolean} `true` is check success.
- * @private
- */
-export const isLess = (value, min) => value < min;
-
-/**
- * Value less than check.
- * @param {number} value - Input value.
- * @param {number} min - Limit that `value` must be greater than.
- * @returns {boolean} `true` is check success.
- * @private
- */
-export const isLessOrEqual = (value, min) => value <= min;
-
-/**
- * Value greater than check.
- * @param {number} value - Input value.
- * @param {number} min - Limit `value` must be greater or equal than.
- * @param {number} max - Limit `value` must be less or equal than.
- * @returns {boolean} `true` is check success.
- * @private
- */
-export const isInRange = (value, min, max) => value >= min && value <= max;
-
-/**
- * Value equal check.
- * @param {number} value - Input value.
- * @param {number} expected - `expected` that `value` must equal.
- * @returns {boolean} `true` is check success.
- * @private
- */
-export const isEqual = (value, expected) => value === expected;

package/src/util/query.js

@@ -1,32 +0,0 @@
-const urlSearchParams = new URLSearchParams(globalThis.location?.search);
-
-/**
- * Sanitizes URL parameters allowing only alpha-numeric characters and dash.
- * @param {string} input - The input string to be sanitized.
- * @returns {string} The sanitized output string.
- */
-export const sanitizeURLParam = (input) => {
-  if (!input) {
-    return input;
-  }
-  return input.replaceAll(/[^\w-]/giu, '');
-};
-
-/**
- * Get a URL parameter value.
- * @template T
- * @param {string} key - The name of the URL parameter to retrieve.
- * @param {T} defaultValue - The default value to return if the parameter is not found.
- * @param {boolean} isSanitize - Whether to sanitize the parameter value.
- * @returns {string | T} The URL parameter value or the default value if not found.
- */
-export const getURLParam = (key, defaultValue = null, isSanitize = true) => {
-  const paramValue = urlSearchParams.get(key);
-  if (paramValue === null || paramValue === undefined) {
-    return defaultValue;
-  }
-  if (isSanitize) {
-    return sanitizeURLParam(paramValue);
-  }
-  return paramValue;
-};

package/src/util/string.js

@@ -1,76 +0,0 @@
-/**
- * Add leading zeros to a value to ensure it has a minimum width.
- * @param {number | string | null | undefined} value - The value to pad with leading zeros.
- * @param {number} size - The minimum width of the resulting string.
- * @returns {string | null} The value padded with leading zeros or null if the input is null/undefined.
- */
-export const addLeadingZero = (value, size = 2) => {
-  if (value === null || value === undefined) {
-    return null;
-  }
-  value = value.toString();
-  while (value.length < size) {
-    value = `0${value}`;
-  }
-  return value;
-};
-
-/**
- * Capitalize a string.
- * @param {string | null | undefined} value - The input string to capitalize.
- * @returns {string | null} The capitalized string or null if the input is null/undefined.
- */
-export const capitalize = (value) => {
-  if (value === null || value === undefined) {
-    return null;
-  }
-  if (!value || value?.length === 0) {
-    return value;
-  }
-  const normValue = value.toLowerCase();
-  return normValue.charAt(0).toUpperCase() + normValue.slice(1);
-};
-
-/**
- * Converts underscore case string to camel case.
- * @param {string} value - The input string in underscore case.
- * @returns {string} The output string in camel case.
- */
-export const underscoreToCamelCase = (value) => value.replaceAll(/(_\w)/gu, (m) => m[1].toUpperCase());
-
-/**
- * Saves text file.
- * @param {string} filename - File name.
- * @param {string} text - File content.
- */
-export const saveAsFile = (filename, text) => {
-  const element = document.createElement('a');
-  element.setAttribute('href', `data:text/plain;charset=utf-8,${encodeURIComponent(text)}`);
-  element.setAttribute('download', filename);
-  element.style.display = 'none';
-  document.body.append(element);
-  element.click();
-  element.remove();
-};
-
-/**
- * Get type from value in human readable format.
- * @param {unknown} value - The value to check.
- * @returns {string} Type in human readable format.
- */
-export const getTypeFromValue = (value) => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
-
-/**
- * Get value in human readable format.
- * @param {unknown} value - The value to check.
- * @returns {string} Value in human readable format.
- */
-export const getDisplayValue = (value) => {
-  if (typeof value === 'string') {
-    return `"${value}"`;
-  }
-  if (typeof value === 'object') {
-    return JSON.stringify(value);
-  }
-  return String(value);
-};

package/src/util/uuid.js

@@ -1,35 +0,0 @@
-/**
- * Convert a byte (0–255) to a 2‑character hex string.
- * @param {number} byte - Byte value.
- * @returns {string} Hex value.
- */
-export const byteToHex = (byte) => (byte >>> 4).toString(16) + (byte & 0b1111).toString(16);
-
-/**
- * UUIDv4 fallback generator (RFC 4122 compliant).
- * @returns {string} UUIDv4 string.
- */
-export const randomUUIDFallback = () => {
-  const bytes = crypto.getRandomValues
-    ? crypto.getRandomValues(new Uint8Array(16))
-    : Array.from({ length: 16 }, () => Math.floor(Math.random() * 256));
-
-  // RFC 4122 version & variant bits
-  bytes[6] = (bytes[6] & 0x0f) | 0x40;
-  bytes[8] = (bytes[8] & 0x3f) | 0x80;
-
-  let uuid = '';
-  for (const [index, byte] of bytes.entries()) {
-    if (index === 4 || index === 6 || index === 8 || index === 10) {
-      uuid += '-';
-    }
-    uuid += byteToHex(byte);
-  }
-  return uuid;
-};
-
-/**
- * Crypto UUIDv4 wrapper with fallback.
- * @returns {string} UUIDv4 string.
- */
-export const uuidv4 = () => (typeof crypto.randomUUID === 'function' ? crypto.randomUUID() : randomUUIDFallback());

package/src/util/validate.js

@@ -1,247 +0,0 @@
-import { isEqual, isGreater, isGreaterOrEqual, isInRange, isLess, isLessOrEqual } from './number.js';
-
-/**
- * Validates `value` as `boolean`.
- * @param {unknown} value - Input value.
- * @returns {value is boolean} `true` if `value` is `boolean` type.
- */
-export const isBoolean = (value) => typeof value === 'boolean';
-
-/**
- * Validates `value` as `number`.
- * @param {unknown} value - Input value.
- * @returns {value is number} `true` if `value` is `number` type.
- */
-export const isNumber = (value) => typeof value === 'number' && Number.isFinite(value);
-
-/**
- * Validates `value` as positive `number`.
- * @param {unknown} value - Input value.
- * @returns {value is number} `true` if `value` is `number` type with positive value.
- */
-export const isPositiveNumber = (value) => isNumber(value) && value > 0;
-
-/**
- * Validates `value` as non-negative `number`.
- * @param {unknown} value - Input value.
- * @returns {value is number} `true` if `value` is `number` type with non-negative value.
- */
-export const isNonNegativeNumber = (value) => isNumber(value) && value >= 0;
-
-/**
- * Validates `value` as `integer`.
- * @param {unknown} value - Input value.
- * @returns {value is number} `true` if `value` is `integer` type.
- */
-export const isInteger = (value) => isNumber(value) && Number.isInteger(value);
-
-/**
- * Validates `value` as positive `integer`.
- * @param {unknown} value - Input value.
- * @returns {value is number} `true` if `value` is `integer` type with positive value.
- */
-export const isPositiveInteger = (value) => isInteger(value) && value > 0;
-
-/**
- * Validates `value` as non-negative `integer`.
- * @param {unknown} value - Input value.
- * @returns {value is number} `true` if `value` is `integer` type with non-negative value.
- */
-export const isNonNegativeInteger = (value) => isInteger(value) && value >= 0;
-
-/**
- * Validates `value` as `string`.
- * @param {unknown} value - Input value.
- * @returns {value is string} `true` if `value` is `string` type.
- */
-export const isString = (value) => typeof value === 'string';
-
-/**
- * Validates `value` as `array`.
- * @template T
- * @param {unknown} value - Input value.
- * @returns {value is T[]} `true` if `value` is `array` type.
- */
-export const isArray = (value) => Array.isArray(value);
-
-/**
- * Validates `value` as `null`
- * @param {unknown} value - Input value.
- * @returns {value is null} `true` if `value` is `null` type.
- */
-export const isNull = (value) => value === null;
-
-/**
- * Validates `value` as `undefined`
- * @param {unknown} value - Input value.
- * @returns {value is undefined} `true` if `value` is `undefined` type.
- */
-export const isUndefined = (value) => value === undefined;
-
-/**
- * Validates `value` as `null` or `undefined`
- * @param {unknown} value - Input value.
- * @returns {value is null | undefined} `true` if `value` is `null` or `undefined` type.
- */
-export const isNullOrUndefined = (value) => isNull(value) || isUndefined(value);
-
-/**
- * Validates `value` as plain `object`.
- * @param {unknown} value - Input value.
- * @returns {value is Record<string, unknown>} `true` if `value` is `object` type.
- */
-export const isPlainObject = (value) => Object.prototype.toString.call(value) === '[object Object]';
-
-/**
- * Validates `value` as `function`.
- * @param {unknown} value - Input value.
- * @returns {value is (...args: any[]) => any} `true` if `value` is `function` type.
- */
-export const isFunction = (value) => typeof value === 'function';
-
-/**
- * Validates `value` as `type`
- * @template T
- * @param {unknown} value - The value to test.
- * @param {new (...args: any[]) => T} type - A class or constructor function.
- * @returns {value is T} `true` if `value` is an instance of `type`.
- */
-export const isInstance = (value, type) => isFunction(type) && value instanceof type;
-
-/**
- * Validates `value` as `enum`.
- * @param {unknown} value - Input value.
- * @param {(string | number)[] | Set<string | number> | Record<string | number, string | number>} choices - Enum list.
- * @returns {boolean} `true` if `value` is `enum` type.
- */
-export const isEnum = (value, choices) => {
-  if (!isString(value) && !isNumber(value)) {
-    return false;
-  }
-  return (
-    (isArray(choices) && choices.includes(value)) ||
-    (isPlainObject(choices) && Object.values(choices).includes(value)) ||
-    (isInstance(choices, Set) && choices.has(value))
-  );
-};
-
-/**
- * Type check an array of values using a validator.
- * @template T
- * @param {unknown[]} values - The value to check.
- * @param {(value: unknown) => value is T} validator - The validator to check with.
- * @returns {values is T[]} `true` if `values` has only `validator` checked types.
- */
-export const isArrayOf = (values, validator) => {
-  if (!isArray(values)) {
-    return false;
-  }
-  for (const value of values) {
-    if (!validator(value)) {
-      return false;
-    }
-  }
-  return true;
-};
-
-/**
- * Type check a plain object of values using a validator.
- * @template T
- * @param {Record<string | number, unknown>} record - The value to check.
- * @param {(value: unknown) => value is T} validator - The validator to check with.
- * @returns {record is Record<string | number, T>} `true` if `values` has only `validator` checked types.
- */
-export const isPlainObjectOf = (record, validator) => {
-  if (!isPlainObject(record)) {
-    return false;
-  }
-  for (const value of Object.values(record)) {
-    if (!validator(value)) {
-      return false;
-    }
-  }
-  return true;
-};
-
-/**
- * Refine a base validator with an extra condition.
- * @template T
- * @param {(value: unknown) => value is T} base - The base validator.
- * @param {(value: T) => boolean} predicate - Extra condition validator.
- * @param {string | null} name - Refined validator name.
- * @returns {(value: unknown) => value is T} The refined validator.
- */
-export const refineValidator = (base, predicate, name = null) => {
-  const refinedValidator = (value) => base(value) && predicate(value);
-  Object.defineProperty(refinedValidator, 'name', {
-    value: isString(name) ? name : `${base.name}Refined`,
-  });
-  // @ts-expect-error
-  return refinedValidator;
-};
-
-//
-// Refined validators
-//
-
-/**
- * Logical OR of two validators.
- * @template A, B
- * @param {(value: unknown) => value is A} a - Validator A.
- * @param {(value: unknown) => value is B} b - Validator B.
- * @returns {(value: unknown) => value is A | B} `true` if `value` is any of the checked types.
- */
-export const isAnyOf = (a, b) => (value) => a(value) || b(value);
-
-export const isNumberGreater = (min) => refineValidator(isNumber, (value) => isGreater(value, min));
-
-export const isNumberGreaterOrEqual = (min) => refineValidator(isNumber, (value) => isGreaterOrEqual(value, min));
-
-export const isNumberLess = (min) => refineValidator(isNumber, (value) => isLess(value, min));
-
-export const isNumberLessOrEqual = (min) => refineValidator(isNumber, (value) => isLessOrEqual(value, min));
-
-export const isNumberInRange = (min, max) => refineValidator(isNumber, (value) => isInRange(value, min, max));
-
-export const isNumberEqual = (expected) => refineValidator(isNumber, (value) => isEqual(value, expected));
-
-export const isIntegerGreater = (min) => refineValidator(isInteger, (value) => isGreater(value, min));
-
-export const isIntegerGreaterOrEqual = (min) => refineValidator(isInteger, (value) => isGreaterOrEqual(value, min));
-
-export const isIntegerLess = (min) => refineValidator(isInteger, (value) => isLess(value, min));
-
-export const isIntegerLessOrEqual = (min) => refineValidator(isInteger, (value) => isLessOrEqual(value, min));
-
-export const isIntegerInRange = (min, max) => refineValidator(isInteger, (value) => isInRange(value, min, max));
-
-export const isIntegerEqual = (expected) => refineValidator(isInteger, (value) => isEqual(value, expected));
-
-export const isStringLengthGreater = (min) => refineValidator(isString, (value) => isGreater(value.length, min));
-
-export const isStringLengthGreaterOrEqual = (min) =>
-  refineValidator(isString, (value) => isGreaterOrEqual(value.length, min));
-
-export const isStringLengthLess = (min) => refineValidator(isString, (value) => isLess(value.length, min));
-
-export const isStringLengthLessOrEqual = (min) =>
-  refineValidator(isString, (value) => isLessOrEqual(value.length, min));
-
-export const isStringLengthInRange = (min, max) =>
-  refineValidator(isString, (value) => isInRange(value.length, min, max));
-
-export const isStringLengthEqual = (expected) => refineValidator(isString, (value) => isEqual(value.length, expected));
-
-export const isArrayLengthGreater = (min) => refineValidator(isArray, (value) => isGreater(value.length, min));
-
-export const isArrayLengthGreaterOrEqual = (min) =>
-  refineValidator(isArray, (value) => isGreaterOrEqual(value.length, min));
-
-export const isArrayLengthLess = (min) => refineValidator(isArray, (value) => isLess(value.length, min));
-
-export const isArrayLengthLessOrEqual = (min) => refineValidator(isArray, (value) => isLessOrEqual(value.length, min));
-
-export const isArrayLengthInRange = (min, max) =>
-  refineValidator(isArray, (value) => isInRange(value.length, min, max));
-
-export const isArrayLengthEqual = (expected) => refineValidator(isArray, (value) => isEqual(value.length, expected));