@vpmedia/simplify 1.74.0 → 1.76.0

package/src/util/validate.ts

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

package/.vscode/extensions.json

@@ -1,6 +0,0 @@
-{
-	"recommendations": [
-		"oxc.oxc-vscode",
-		"vitest.explorer"
-	]
-}

package/.vscode/settings.json

@@ -1,27 +0,0 @@
-{
-  "files.watcherExclude": {
-    "**/.git/objects/**": true,
-    "**/.git/subtree-cache/**": true,
-    "**/build/**": true,
-    "**/node_modules/**": true
-  },
-  "editor.codeActionsOnSave": {
-    "source.removeUnusedImports": "explicit",
-    "source.organizeImports": "explicit"
-  },
-  "oxc.enable": true,
-  "[javascript]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode"
-  },
-  "[javascriptreact]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode"
-  },
-  "javascript.updateImportsOnFileMove.enabled": "always",
-  "[typescript]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode",
-  },
-  "[typescriptreact]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode"
-  },
-  "typescript.updateImportsOnFileMove.enabled": "always",
-}

package/src/logging/AbstractLogHandler.js

@@ -1,23 +0,0 @@
-export class AbstractLogHandler {
-  /**
-   * Abstract log handler.
-   * @param {number} level - Log handler level.
-   */
-  constructor(level) {
-    this.level = 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) {
-    throw new Error('Not implemented.');
-  }
-}

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