@vpmedia/simplify 1.74.0 → 1.75.0

package/src/logging/Logger.js

@@ -1,115 +0,0 @@
-import { getURLParam } from '../util/query.js';
-import {
-  LOG_LEVEL_DEBUG,
-  LOG_LEVEL_ERROR,
-  LOG_LEVEL_FATAL,
-  LOG_LEVEL_INFO,
-  LOG_LEVEL_SILENT,
-  LOG_LEVEL_WARNING,
-} from './const.js';
-import { getAppEnvironment } from './util.js';
-
-const ROOT_LOGGER_NAME = 'root';
-
-export class Logger {
-  /**
-   * @type {import('./AbstractLogHandler.js').AbstractLogHandler[]}
-   */
-  static handlers = [];
-
-  /**
-   * Creates a new Logger instance.
-   * @param {string} [name] - The logger name.
-   */
-  constructor(name = ROOT_LOGGER_NAME) {
-    this.name = name ?? ROOT_LOGGER_NAME;
-    const appEnvironment = getAppEnvironment();
-    const isProduction = appEnvironment === 'production' || appEnvironment === 'release';
-    const defaultLevel = isProduction ? LOG_LEVEL_SILENT : LOG_LEVEL_DEBUG;
-    const parameterName = `log_${this.name.toLowerCase()}`;
-    const paramLevel =
-      getURLParam(parameterName, getURLParam('log_all', defaultLevel.toString())) ?? defaultLevel.toString();
-    /** @type {number} */
-    this.level = Number.parseInt(paramLevel, 10);
-  }
-
-  /**
-   * Add log handler.
-   * @param {import('./AbstractLogHandler.js').AbstractLogHandler} handler - Log handler.
-   */
-  static addHandler = (handler) => {
-    Logger.handlers.push(handler);
-  };
-
-  /**
-   * Emit log record.
-   * @param {Logger} logger - Logger instance.
-   * @param {number} level - Log level.
-   * @param {string} message - Log message.
-   * @param {object} extra - Log extra data.
-   * @param {Error | null | undefined} [error] - Log exception.
-   */
-  static emit = (logger, level, message, extra, error) => {
-    const timestamp = Date.now();
-    for (const handler of Logger.handlers) {
-      if (handler.level >= level) {
-        handler.emit(logger, timestamp, level, message, extra, error);
-      }
-    }
-  };
-
-  /**
-   * Emit debug log.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} [extra] - Log extra data.
-   */
-  debug(message, extra) {
-    Logger.emit(this, LOG_LEVEL_DEBUG, message, extra);
-  }
-
-  /**
-   * Emit info log.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} [extra] - Log extra data.
-   */
-  info(message, extra) {
-    Logger.emit(this, LOG_LEVEL_INFO, message, extra);
-  }
-
-  /**
-   * Emit warning log.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} [extra] - Log extra data.
-   */
-  warn(message, extra) {
-    Logger.emit(this, LOG_LEVEL_WARNING, message, extra);
-  }
-
-  /**
-   * Emit warning log.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} [extra] - Log extra data.
-   */
-  warning(message, extra) {
-    Logger.emit(this, LOG_LEVEL_WARNING, message, extra);
-  }
-
-  /**
-   * Emit error log.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} [extra] - Log extra data.
-   */
-  error(message, extra) {
-    Logger.emit(this, LOG_LEVEL_ERROR, message, extra);
-  }
-
-  /**
-   * Emit exception log.
-   * @param {string} message - Log message.
-   * @param {Error} error - Log error.
-   * @param {object | null | undefined} [extra] - Log extra data.
-   */
-  exception(message, error, extra) {
-    Logger.emit(this, LOG_LEVEL_FATAL, message, extra, error);
-  }
-}

package/src/logging/OpenTelemetryLogHandler.js

@@ -1,30 +0,0 @@
-import { AbstractLogHandler } from './AbstractLogHandler.js';
-
-export class OpenTelemetryLogHandler extends AbstractLogHandler {
-  /**
-   * Open Telemetry log handler.
-   * @param {number} level - Log handler level.
-   * @param {(logger: import('./Logger.js').Logger, timestamp: number, level: number, message: string, extra: object | null | undefined, error: Error | null | undefined) => void} emitter - Log handler emitter.
-   */
-  constructor(level, emitter) {
-    super(level);
-    this.emitter = emitter;
-  }
-
-  /**
-   * Emit log record.
-   * @param {import('./Logger.js').Logger} logger - Logger instance.
-   * @param {number} timestamp - Log timestamp.
-   * @param {number} level - Log level.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} extra - Log extra data.
-   * @param {Error | null | undefined} error - Log error.
-   * @throws {Error}
-   */
-  emit(logger, timestamp, level, message, extra, error) {
-    if (!this.emitter) {
-      return;
-    }
-    this.emitter(logger, timestamp, level, message, extra, error);
-  }
-}

package/src/logging/SentryLogHandler.js

@@ -1,46 +0,0 @@
-import { addBreadcrumb, captureException, captureMessage } from '@sentry/browser';
-import { AbstractLogHandler } from './AbstractLogHandler.js';
-import { LOG_LEVEL_DEBUG, LOG_LEVEL_WARNING } from './const.js';
-import { getLogLevelName } from './util.js';
-
-export class SentryLogHandler extends AbstractLogHandler {
-  /**
-   * Console log handler.
-   * @param {number} level - Log handler level.
-   */
-  constructor(level = LOG_LEVEL_DEBUG) {
-    super(level);
-  }
-
-  /**
-   * Emit log record.
-   * @param {import('./Logger.js').Logger} logger - Logger instance.
-   * @param {number} timestamp - Log timestamp.
-   * @param {number} level - Log level.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} extra - Log extra data.
-   * @param {Error | null | undefined} error - Log error.
-   * @throws {Error}
-   */
-  emit(logger, timestamp, level, message, extra, error) {
-    /** @type {import('@sentry/browser').SeverityLevel} */
-    // @ts-expect-error
-    const levelName = getLogLevelName(level);
-    const logMessage = `[${logger.name}] ${message}`;
-    const breadcrumb = {
-      type: 'default',
-      category: 'console',
-      message: logMessage,
-      level: levelName,
-      data: extra,
-    };
-    addBreadcrumb(breadcrumb);
-    if (error) {
-      extra?.tags ? captureException(error, { tags: extra.tags }) : captureException(error);
-    } else if (level === LOG_LEVEL_WARNING) {
-      extra?.tags
-        ? captureMessage(logMessage, { level: 'warning', tags: extra.tags })
-        : captureMessage(logMessage, { level: 'warning' });
-    }
-  }
-}

package/src/logging/util.js

@@ -1,41 +0,0 @@
-import { LOG_LEVEL_NAMES } from './const.js';
-
-/**
- * Format log message.
- * @param {import('./Logger.js').Logger} logger - Logger target name.
- * @param {number} timestamp - Log timestamp.
- * @param {number} level - Log level.
- * @param {string} message - Log message.
- * @returns {string} Formatted log message.
- */
-export const formatLogMessage = (logger, timestamp, level, message) => `${timestamp} [${logger.name}] ${message}`;
-
-/**
- * Get log level name.
- * @param {number} level - Log level.
- * @returns {string} Log level name.
- */
-export const getLogLevelName = (level) => LOG_LEVEL_NAMES[level];
-
-/**
- * Returns the application environment identifier.
- * @returns {string} App environment type.
- */
-export const getAppEnvironment = () => {
-  let appEnvironment = 'local';
-  try {
-    if (import.meta['env'].VITE_APP_ENVIRONMENT) {
-      appEnvironment = import.meta['env'].VITE_APP_ENVIRONMENT;
-    }
-  } catch {
-    // pass
-  }
-  try {
-    if (process.env.APP_ENVIRONMENT) {
-      appEnvironment = process.env.APP_ENVIRONMENT;
-    }
-  } catch {
-    // pass
-  }
-  return appEnvironment;
-};

package/src/pagelifecycle/typedef.js

@@ -1,9 +0,0 @@
-export const TYPEDEF = true;
-
-/**
- * @typedef {import('./const.js').PAGE_LIFECYCLE_STATE_HIDDEN | import('./const.js').PAGE_LIFECYCLE_STATE_ACTIVE | import('./const.js').PAGE_LIFECYCLE_STATE_PASSIVE | import('./const.js').PAGE_LIFECYCLE_STATE_FROZEN | import('./const.js').PAGE_LIFECYCLE_STATE_TERMINATED} PageLifecycleState
- */
-
-/**
- * @typedef {import('./const.js').DOCUMENT_STATE_LOADING | import('./const.js').DOCUMENT_STATE_INTERACTIVE | import('./const.js').DOCUMENT_STATE_COMPLETE | import('./const.js').DOCUMENT_STATE_DOM_LOADED | import('./const.js').DOCUMENT_STATE_FULLY_LOADED} DocumentState
- */

package/src/typecheck/util.js

@@ -1,60 +0,0 @@
-import { getDisplayValue, getTypeFromValue } from '../util/string.js';
-import { isArrayOf, isEnum } from '../util/validate.js';
-import { TypeCheckError } from './TypeCheckError.js';
-
-/**
- * Get error message for validator exceptions.
- * @param {string} validatorName - Validator name.
- * @param {unknown} value - Input value.
- */
-const getErrorMessage = (validatorName, value) => {
-  const displayValue = getDisplayValue(value);
-  const displayType = getTypeFromValue(value);
-  throw new TypeCheckError(`Validation failed: ${validatorName || '<anonymous>'} - ${displayValue} (${displayType})`);
-};
-/**
- * Type check a value using a validator.
- * @template T
- * @param {unknown} value - The value to check.
- * @param {(value: unknown) => value is T} validator - The validator to check with.
- * @returns {T} The type checked value.
- * @throws {TypeCheckError}
- */
-export const typeCheck = (value, validator) => {
-  if (!validator(value)) {
-    const errorMessage = getErrorMessage(validator.name, value);
-    throw new TypeCheckError(errorMessage);
-  }
-  return value;
-};
-
-/**
- * Type check a value using a validator.
- * @template T
- * @param {unknown[]} value - The value to check.
- * @param {(value: unknown) => value is T} validator - The validator to check the array with.
- * @returns {T[]} The type checked value.
- * @throws {TypeCheckError}
- */
-export const typeCheckArray = (value, validator) => {
-  if (!isArrayOf(value, validator)) {
-    const errorMessage = getErrorMessage(validator.name, value);
-    throw new TypeCheckError(errorMessage);
-  }
-  return value;
-};
-
-/**
- * Type check an enum.
- * @param {string | number} value - The value to check.
- * @param {(string | number)[] | Set<string | number> | Record<string | number, string | number>} choices - Enum list.
- * @returns {string | number} The type checked value.
- * @throws {TypeCheckError}
- */
-export const typeCheckEnum = (value, choices) => {
-  if (!isEnum(value, choices)) {
-    const errorMessage = getErrorMessage('isEnum', value);
-    throw new TypeCheckError(errorMessage);
-  }
-  return value;
-};

package/src/util/error.js

@@ -1,33 +0,0 @@
-const DEFAULT_EXCLUDES = new Set(['stack']);
-
-/**
- * Retrieves detailed information from an error object.
- * @param {Error} error - The error to extract details from.
- * @param {null | undefined | string[]} [excludes] - An array of property names to exclude from the result.
- * @returns {object} - An object containing the error details.
- */
-export const getErrorDetails = (error, excludes) => {
-  const errorDetails = {
-    name: error.name,
-    type: error.constructor?.name ?? typeof error,
-  };
-  if (error.message) {
-    errorDetails.message = error.message;
-  }
-  if (error.cause) {
-    errorDetails.cause = error.cause;
-  }
-  for (const key of Object.getOwnPropertyNames(error)) {
-    if (!excludes?.includes(key) && !DEFAULT_EXCLUDES.has(key)) {
-      errorDetails[key] = error[key];
-    }
-  }
-  return errorDetails;
-};
-
-/**
- * Get typed error from an unknown type.
- * @param {unknown} error - The error to cast.
- * @returns {Error} The typed error object.
- */
-export const getTypedError = (error) => (error instanceof Error ? error : new Error(String(error)));

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;
-};