@vpmedia/simplify 1.73.0 → 1.75.0

package/src/logging/{ConsoleLogHandler.js → ConsoleLogHandler.ts}

@@ -1,8 +1,11 @@
-import { AbstractLogHandler } from './AbstractLogHandler.js';
+import { AbstractLogHandler, type LogExtra } from './AbstractLogHandler.js';
 import { LOG_LEVEL_DEBUG } from './const.js';
+import type { Logger } from './Logger.js';
 import { formatLogMessage } from './util.js';
 
-const CONSOLE_FUNCTIONS = [
+type ConsoleFn = (...data: unknown[]) => void;
+
+const CONSOLE_FUNCTIONS: ReadonlyArray<ConsoleFn | null> = [
   null, // silent
   console.error, // fatal
   console.error, // error
@@ -14,29 +17,28 @@ const CONSOLE_FUNCTIONS = [
 export class ConsoleLogHandler extends AbstractLogHandler {
   /**
    * Console log handler.
-   * @param {number} level - Log handler level.
    */
-  constructor(level = LOG_LEVEL_DEBUG) {
+  constructor(level: number = 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) {
+  override emit(
+    logger: Logger,
+    timestamp: number,
+    level: number,
+    message: string,
+    extra: LogExtra | null | undefined,
+    error: Error | null | undefined
+  ): void {
     if (logger.level < level) {
       return;
     }
     const logMessage = formatLogMessage(logger, timestamp, level, message);
     const consoleFunction = CONSOLE_FUNCTIONS[level];
-    if (consoleFunction === null) {
+    if (consoleFunction === null || consoleFunction === undefined) {
       return;
     }
     if (error) {

package/src/logging/Logger.test.ts

@@ -0,0 +1,69 @@
+import { AbstractLogHandler, type LogExtra } from './AbstractLogHandler.js';
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_ERROR, LOG_LEVEL_FATAL, LOG_LEVEL_INFO, LOG_LEVEL_WARNING } from './const.js';
+import { Logger } from './Logger.js';
+
+class TestLogHandler extends AbstractLogHandler {
+  emitLogLogger: Logger | null = null;
+  emitLogTimestamp: number | null = null;
+  emitLogLevel: number | null = null;
+  emitLogMessage: string | null = null;
+  emitLogExtra: LogExtra | null | undefined = null;
+  emitLogError: Error | null | undefined = null;
+
+  constructor() {
+    super(LOG_LEVEL_DEBUG);
+  }
+
+  override emit(
+    logger: Logger,
+    timestamp: number,
+    level: number,
+    message: string,
+    extra: LogExtra | null | undefined,
+    error: Error | null | undefined
+  ): void {
+    this.emitLogLogger = logger;
+    this.emitLogTimestamp = timestamp;
+    this.emitLogLevel = level;
+    this.emitLogMessage = message;
+    this.emitLogExtra = extra;
+    this.emitLogError = error;
+  }
+}
+
+test('Tests Logger default level', () => {
+  const logger = new Logger('test');
+  expect(logger.level).toBe(LOG_LEVEL_DEBUG);
+});
+
+test('Tests Logger custom handler', () => {
+  const logger = new Logger('test');
+  const testLogHandler = new TestLogHandler();
+  Logger.addHandler(testLogHandler);
+  // debug
+  logger.debug('debug');
+  expect(testLogHandler.emitLogLevel).toBe(LOG_LEVEL_DEBUG);
+  expect(testLogHandler.emitLogMessage).toBe('debug');
+  // info
+  logger.info('info');
+  expect(testLogHandler.emitLogLevel).toBe(LOG_LEVEL_INFO);
+  expect(testLogHandler.emitLogMessage).toBe('info');
+  // warning
+  logger.warn('warning');
+  expect(testLogHandler.emitLogLevel).toBe(LOG_LEVEL_WARNING);
+  expect(testLogHandler.emitLogMessage).toBe('warning');
+  logger.warning('warning');
+  expect(testLogHandler.emitLogLevel).toBe(LOG_LEVEL_WARNING);
+  expect(testLogHandler.emitLogMessage).toBe('warning');
+  // error
+  logger.error('error');
+  expect(testLogHandler.emitLogLevel).toBe(LOG_LEVEL_ERROR);
+  expect(testLogHandler.emitLogMessage).toBe('error');
+  // exception
+  logger.exception('test', new Error('test_error'), { context: 'ctx' });
+  expect(testLogHandler.emitLogLevel).toBe(LOG_LEVEL_FATAL);
+  expect(testLogHandler.emitLogMessage).toBe('test');
+  expect(testLogHandler.emitLogError?.message).toBe('test_error');
+  expect(testLogHandler.emitLogLogger).toBe(logger);
+  expect(testLogHandler.emitLogExtra?.['context']).toBe('ctx');
+});

package/src/logging/Logger.ts

@@ -0,0 +1,77 @@
+import { getURLParam } from '../util/query.js';
+import type { AbstractLogHandler, LogExtra } from './AbstractLogHandler.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 {
+  static handlers: AbstractLogHandler[] = [];
+
+  name: string;
+  level: number;
+
+  /**
+   * Creates a new Logger instance.
+   */
+  constructor(name: string = 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();
+    this.level = Number.parseInt(paramLevel, 10);
+  }
+
+  static addHandler = (handler: AbstractLogHandler): void => {
+    Logger.handlers.push(handler);
+  };
+
+  static emit = (
+    logger: Logger,
+    level: number,
+    message: string,
+    extra?: LogExtra | null,
+    error?: Error | null
+  ): void => {
+    const timestamp = Date.now();
+    for (const handler of Logger.handlers) {
+      if (handler.level >= level) {
+        handler.emit(logger, timestamp, level, message, extra, error);
+      }
+    }
+  };
+
+  debug(message: string, extra?: LogExtra | null): void {
+    Logger.emit(this, LOG_LEVEL_DEBUG, message, extra);
+  }
+
+  info(message: string, extra?: LogExtra | null): void {
+    Logger.emit(this, LOG_LEVEL_INFO, message, extra);
+  }
+
+  warn(message: string, extra?: LogExtra | null): void {
+    Logger.emit(this, LOG_LEVEL_WARNING, message, extra);
+  }
+
+  warning(message: string, extra?: LogExtra | null): void {
+    Logger.emit(this, LOG_LEVEL_WARNING, message, extra);
+  }
+
+  error(message: string, extra?: LogExtra | null): void {
+    Logger.emit(this, LOG_LEVEL_ERROR, message, extra);
+  }
+
+  exception(message: string, error: Error, extra?: LogExtra | null): void {
+    Logger.emit(this, LOG_LEVEL_FATAL, message, extra, error);
+  }
+}

package/src/logging/OpenTelemetryLogHandler.ts

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

package/src/logging/SentryLogHandler.ts

@@ -0,0 +1,44 @@
+import { addBreadcrumb, captureException, captureMessage, type SeverityLevel } from '@sentry/browser';
+import { AbstractLogHandler, type LogExtra } from './AbstractLogHandler.js';
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_WARNING } from './const.js';
+import type { Logger } from './Logger.js';
+import { getLogLevelName } from './util.js';
+
+export class SentryLogHandler extends AbstractLogHandler {
+  /**
+   * Sentry log handler.
+   */
+  constructor(level: number = LOG_LEVEL_DEBUG) {
+    super(level);
+  }
+
+  /**
+   * Emit log record.
+   */
+  override emit(
+    logger: Logger,
+    _timestamp: number,
+    level: number,
+    message: string,
+    extra: LogExtra | null | undefined,
+    error: Error | null | undefined
+  ): void {
+    const levelName = getLogLevelName(level) as SeverityLevel;
+    const logMessage = `[${logger.name}] ${message}`;
+    const breadcrumb = {
+      type: 'default',
+      category: 'console',
+      message: logMessage,
+      level: levelName,
+      data: extra ?? undefined,
+    };
+    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/{const.js → const.ts}

@@ -12,7 +12,7 @@ export const LOG_LEVEL_NAME_WARNING = 'warning';
 export const LOG_LEVEL_NAME_INFO = 'info';
 export const LOG_LEVEL_NAME_DEBUG = 'debug';
 
-export const LOG_LEVEL_NAMES = [
+export const LOG_LEVEL_NAMES: readonly string[] = [
   LOG_LEVEL_NAME_SILENT,
   LOG_LEVEL_NAME_FATAL,
   LOG_LEVEL_NAME_ERROR,

package/src/logging/util.test.ts

@@ -0,0 +1,33 @@
+import {
+  LOG_LEVEL_DEBUG,
+  LOG_LEVEL_ERROR,
+  LOG_LEVEL_FATAL,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NAME_DEBUG,
+  LOG_LEVEL_NAME_ERROR,
+  LOG_LEVEL_NAME_FATAL,
+  LOG_LEVEL_NAME_INFO,
+  LOG_LEVEL_NAME_SILENT,
+  LOG_LEVEL_NAME_WARNING,
+  LOG_LEVEL_SILENT,
+  LOG_LEVEL_WARNING,
+} from './const.js';
+import { Logger } from './Logger.js';
+import { formatLogMessage, getLogLevelName } from './util.js';
+
+test('formatLogMessage()', () => {
+  expect(
+    formatLogMessage(new Logger('loggerName'), Date.now(), LOG_LEVEL_INFO, 'logMessage').endsWith(
+      '[loggerName] logMessage'
+    )
+  ).toBe(true);
+});
+
+test('getLogLevelName()', () => {
+  expect(getLogLevelName(LOG_LEVEL_DEBUG)).toBe(LOG_LEVEL_NAME_DEBUG);
+  expect(getLogLevelName(LOG_LEVEL_INFO)).toBe(LOG_LEVEL_NAME_INFO);
+  expect(getLogLevelName(LOG_LEVEL_WARNING)).toBe(LOG_LEVEL_NAME_WARNING);
+  expect(getLogLevelName(LOG_LEVEL_ERROR)).toBe(LOG_LEVEL_NAME_ERROR);
+  expect(getLogLevelName(LOG_LEVEL_FATAL)).toBe(LOG_LEVEL_NAME_FATAL);
+  expect(getLogLevelName(LOG_LEVEL_SILENT)).toBe(LOG_LEVEL_NAME_SILENT);
+});

package/src/logging/util.ts

@@ -0,0 +1,36 @@
+import type { Logger } from './Logger.js';
+import { LOG_LEVEL_NAMES } from './const.js';
+
+/**
+ * Format log message.
+ */
+export const formatLogMessage = (logger: Logger, timestamp: number, _level: number, message: string): string =>
+  `${timestamp} [${logger.name}] ${message}`;
+
+/**
+ * Get log level name.
+ */
+export const getLogLevelName = (level: number): string | undefined => LOG_LEVEL_NAMES[level];
+
+/**
+ * Returns the application environment identifier.
+ */
+export const getAppEnvironment = (): string => {
+  let appEnvironment = 'local';
+  try {
+    const { env } = import.meta as unknown as { env?: Record<string, string | undefined> };
+    if (env?.['VITE_APP_ENVIRONMENT']) {
+      appEnvironment = env['VITE_APP_ENVIRONMENT'];
+    }
+  } catch {
+    // pass
+  }
+  try {
+    if (process.env['APP_ENVIRONMENT']) {
+      appEnvironment = process.env['APP_ENVIRONMENT'];
+    }
+  } catch {
+    // pass
+  }
+  return appEnvironment;
+};

package/src/pagelifecycle/{const.js → const.ts}

@@ -4,7 +4,7 @@ export const PAGE_LIFECYCLE_STATE_PASSIVE = 'passive';
 export const PAGE_LIFECYCLE_STATE_FROZEN = 'frozen';
 export const PAGE_LIFECYCLE_STATE_TERMINATED = 'terminated';
 
-export const PAGE_LIFECYCLE_STATES = new Set([
+export const PAGE_LIFECYCLE_STATES: ReadonlySet<string> = new Set([
   PAGE_LIFECYCLE_STATE_ACTIVE,
   PAGE_LIFECYCLE_STATE_FROZEN,
   PAGE_LIFECYCLE_STATE_HIDDEN,
@@ -18,7 +18,7 @@ export const DOCUMENT_STATE_COMPLETE = 'complete';
 export const DOCUMENT_STATE_INTERACTIVE = 'interactive';
 export const DOCUMENT_STATE_LOADING = 'loading';
 
-export const DOCUMENT_STATES = new Set([
+export const DOCUMENT_STATES: ReadonlySet<string> = new Set([
   DOCUMENT_STATE_COMPLETE,
   DOCUMENT_STATE_DOM_LOADED,
   DOCUMENT_STATE_FULLY_LOADED,

package/src/pagelifecycle/typedef.ts

@@ -0,0 +1,5 @@
+export const TYPEDEF = true;
+
+export type PageLifecycleState = 'hidden' | 'active' | 'passive' | 'frozen' | 'terminated';
+
+export type DocumentState = 'loading' | 'interactive' | 'complete' | 'domLoaded' | 'fullyLoaded';

package/src/pagelifecycle/util.test.ts

@@ -0,0 +1,99 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import {
+  DOCUMENT_STATE_CHANGE_EVENT,
+  DOCUMENT_STATES,
+  PAGE_LIFECYCLE_STATE_CHANGE_EVENT,
+  PAGE_LIFECYCLE_STATES,
+} from './const.js';
+import {
+  getDocumentState,
+  getPageLifecycleEventEmitter,
+  getPageLifecycleState,
+  initPageLifecycle,
+  isPageLifecycleInitialized,
+} from './util.js';
+
+describe('Page Lifecycle', () => {
+  beforeAll(() => {
+    initPageLifecycle();
+  });
+
+  it('should initialize page lifecycle', () => {
+    expect(isPageLifecycleInitialized()).toBe(true);
+  });
+
+  it('should return current page lifecycle state', () => {
+    const state = getPageLifecycleState();
+    expect(state).toBeOneOf([...PAGE_LIFECYCLE_STATES]);
+  });
+
+  it('should return current document state', () => {
+    const state = getDocumentState();
+    expect(state).toBeOneOf([...DOCUMENT_STATES]);
+  });
+
+  it('should return event emitter instance', () => {
+    const emitter = getPageLifecycleEventEmitter();
+    expect(emitter).toBeDefined();
+  });
+
+  it('should handle page lifecycle state changes', () => {
+    const emitter = getPageLifecycleEventEmitter();
+    let stateChanged = false;
+
+    emitter.on(PAGE_LIFECYCLE_STATE_CHANGE_EVENT, (data: unknown) => {
+      stateChanged = true;
+      expect(data).toHaveProperty('previousState');
+      expect(data).toHaveProperty('nextState');
+    });
+
+    // Trigger visibility change
+    const originalVisibilityState = document.visibilityState;
+    Object.defineProperty(document, 'visibilityState', {
+      value: originalVisibilityState === 'visible' ? 'hidden' : 'visible',
+      writable: true,
+      configurable: true,
+    });
+
+    document.dispatchEvent(new Event('visibilitychange'));
+
+    // Restore original state
+    Object.defineProperty(document, 'visibilityState', {
+      value: originalVisibilityState,
+      writable: true,
+      configurable: true,
+    });
+
+    expect(stateChanged).toBe(true);
+  });
+
+  it('should handle document state changes', () => {
+    const emitter = getPageLifecycleEventEmitter();
+    let stateChanged = false;
+
+    emitter.on(DOCUMENT_STATE_CHANGE_EVENT, (data: unknown) => {
+      stateChanged = true;
+      expect(data).toHaveProperty('previousState');
+      expect(data).toHaveProperty('nextState');
+    });
+
+    // Trigger ready state change
+    const originalReadyState = document.readyState;
+    Object.defineProperty(document, 'readyState', {
+      value: originalReadyState === 'complete' ? 'interactive' : 'complete',
+      writable: true,
+      configurable: true,
+    });
+
+    document.dispatchEvent(new Event('readystatechange'));
+
+    // Restore original state
+    Object.defineProperty(document, 'readyState', {
+      value: originalReadyState,
+      writable: true,
+      configurable: true,
+    });
+
+    expect(stateChanged).toBe(true);
+  });
+});

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

@@ -16,27 +16,24 @@ import {
   PAGE_LIFECYCLE_STATE_PASSIVE,
   PAGE_LIFECYCLE_STATE_TERMINATED,
 } from './const.js';
+import type { DocumentState, PageLifecycleState } from './typedef.js';
 
 const logger = new Logger('pagelifecycle');
 
 const eventEmitter = new EventEmitter();
 
-/** @type {import('./typedef.js').PageLifecycleState | null | undefined} */
-let currentPageLifecycleState = null;
+let currentPageLifecycleState: PageLifecycleState | null | undefined = null;
 
-/** @type {import('./typedef.js').DocumentState | null | undefined} */
-let currentDocumentState = null;
+let currentDocumentState: DocumentState | null | undefined = null;
 
 let isInitialized = false;
 
-/** @type {Record<string, (() => void)[]>} */
-const callbacks = {};
+const callbacks: Record<string, (() => void)[]> = {};
 
 /**
  * Run callbacks for a specific state change.
- * @param {import('./typedef.js').DocumentState | import('./typedef.js').PageLifecycleState} state - Callback state condition.
  */
-const processCallbacks = (state) => {
+const processCallbacks = (state: DocumentState | PageLifecycleState): void => {
   const stateCallbacks = callbacks[state];
   if (!stateCallbacks) {
     return;
@@ -49,9 +46,8 @@ const processCallbacks = (state) => {
 
 /**
  * Detects the current page lifecycle state.
- * @returns {import('./typedef.js').PageLifecycleState} Current page lifecycle state.
  */
-const detectPageLifecycleState = () => {
+const detectPageLifecycleState = (): PageLifecycleState => {
   if (document.visibilityState === 'hidden') {
     return PAGE_LIFECYCLE_STATE_HIDDEN;
   }
@@ -63,9 +59,8 @@ const detectPageLifecycleState = () => {
 
 /**
  * Handles page lifecycle state change.
- * @param {import('./typedef.js').PageLifecycleState} nextState - Next page lifecycle state.
  */
-const onPageLifecycleStateChange = (nextState) => {
+const onPageLifecycleStateChange = (nextState: PageLifecycleState): void => {
   const previousState = currentPageLifecycleState;
   if (nextState !== previousState) {
     currentPageLifecycleState = nextState;
@@ -78,9 +73,8 @@ const onPageLifecycleStateChange = (nextState) => {
 
 /**
  * Handles document state change.
- * @param {import('./typedef.js').DocumentState} nextState - Next document state.
  */
-const onDocumentStateChange = (nextState) => {
+const onDocumentStateChange = (nextState: DocumentState): void => {
   const previousState = currentDocumentState;
   if (nextState !== previousState) {
     currentDocumentState = nextState;
@@ -94,7 +88,7 @@ const onDocumentStateChange = (nextState) => {
 /**
  * Initialize page lifecycle observer.
  */
-export const initPageLifecycle = () => {
+export const initPageLifecycle = (): void => {
   if (isInitialized) {
     return;
   }
@@ -103,7 +97,6 @@ export const initPageLifecycle = () => {
   onDocumentStateChange(document.readyState);
   const options = { capture: true };
   document.addEventListener('visibilitychange', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
-  // globalThis.addEventListener('popstate', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
   globalThis.addEventListener('pageshow', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
   globalThis.addEventListener('focus', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
   globalThis.addEventListener('blur', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
@@ -123,21 +116,18 @@ export const initPageLifecycle = () => {
 
 /**
  * Returns the current page lifecycle state.
- * @returns {string | null | undefined} Current page lifecycle state.
  */
-export const getPageLifecycleState = () => currentPageLifecycleState;
+export const getPageLifecycleState = (): PageLifecycleState | null | undefined => currentPageLifecycleState;
 
 /**
  * Returns the current document state.
- * @returns {import('./typedef.js').DocumentState | null | undefined} Current document state.
  */
-export const getDocumentState = () => currentDocumentState;
+export const getDocumentState = (): DocumentState | null | undefined => currentDocumentState;
 
 /**
  * Returns the event emitter instance.
- * @returns {EventEmitter} Event emitter instance.
  */
-export const getPageLifecycleEventEmitter = () => {
+export const getPageLifecycleEventEmitter = (): EventEmitter => {
   if (!isInitialized) {
     initPageLifecycle();
   }
@@ -146,16 +136,13 @@ export const getPageLifecycleEventEmitter = () => {
 
 /**
  * Returns the page lifecycle observer initialized state.
- * @returns {boolean} Page lifecycle observer initialized flag.
  */
-export const isPageLifecycleInitialized = () => isInitialized;
+export const isPageLifecycleInitialized = (): boolean => isInitialized;
 
 /**
  * Add callback for a specific state change.
- * @param {import('./typedef.js').DocumentState | import('./typedef.js').PageLifecycleState} state - Callback state condition.
- * @param {() => void} callback - Callback function.
  */
-export const addPageLifecycleCallback = (state, callback) => {
+export const addPageLifecycleCallback = (state: DocumentState | PageLifecycleState, callback: () => void): void => {
   const stateCallbacks = callbacks[state] ?? [];
   stateCallbacks.push(callback);
   callbacks[state] = stateCallbacks;

package/src/typecheck/{TypeCheckError.js → TypeCheckError.ts}

@@ -1,10 +1,14 @@
+export interface TypeCheckErrorOptions extends ErrorOptions {
+  value?: unknown;
+}
+
 export class TypeCheckError extends TypeError {
+  value: unknown;
+
   /**
    * Creates a new `TypeCheckError` instance.
-   * @param {string} message - Error message.
-   * @param {{ cause?: unknown, value?: unknown }} [options] - Error options.
    */
-  constructor(message, options) {
+  constructor(message: string, options?: TypeCheckErrorOptions) {
     super(message, options);
     this.name = 'TypeCheckError';
     this.value = options?.value;