scriptable-testlab/src/registry.ts

A lightweight, efficient tool designed to manage and update scripts for Scriptable.

import mocker from '@corez/mocker';

import {GLOBAL_CLASSES, GLOBAL_VARIABLES} from './mocks';

export class MockError extends Error {
  constructor(
    public code: string,
    public message: string,
    public details?: unknown,
  ) {
    super(message);
    this.name = 'MockError';
  }
}

export const MockErrorCode = {
  INVALID_TARGET: 'INVALID_TARGET',
} as const;

/**
 * Registry for managing global Scriptable mocks
 * Responsibilities:
 * 1. Register/unregister global mocks
 * 2. Track registered identifiers
 * 3. Provide access to registered mocks
 */
export class GlobalRegistry {
  private static registry = new Map<string, unknown>();

  /**
   * Register a mock object globally
   */
  static register(identifier: string, mockObject: unknown): void {
    if (mockObject != null && (typeof mockObject === 'object' || typeof mockObject === 'function')) {
      this.registry.set(identifier, mockObject);
      (global as Record<string, unknown>)[identifier] = mockObject;
    }
  }

  /**
   * Unregister a mock object
   */
  static unregister(identifier: string): void {
    if (this.registry.has(identifier)) {
      this.registry.delete(identifier);
      delete (global as Record<string, unknown>)[identifier];
    }
  }

  /**
   * Get a registered mock object
   */
  static get<T>(identifier: string): T {
    const mockObject = this.registry.get(identifier);
    if (!mockObject) {
      throw {
        code: MockErrorCode.INVALID_TARGET,
        message: `Mock not found: ${identifier}`,
      } as MockError;
    }
    return mockObject as T;
  }

  /**
   * Check if identifier is registered
   */
  static has(identifier: string): boolean {
    return this.registry.has(identifier);
  }

  /**
   * Clear all registered mocks
   */
  static clear(): void {
    this.registry.forEach((_, identifier) => {
      delete (global as Record<string, unknown>)[identifier];
    });
    this.registry.clear();
  }

  /**
   * Get all registered identifiers
   */
  static getRegisteredIdentifiers(): string[] {
    return Array.from(this.registry.keys());
  }
}

/**
 * Manager for initializing and cleaning up global mocks
 */
export class GlobalMockManager {
  static initialize(): void {
    this.clear();

    // Initialize global classes
    GLOBAL_CLASSES.forEach(Class => {
      Class.initialize(Class as any, instance => mocker.object(instance, {inPlace: true, callThrough: true}));
      GlobalRegistry.register(Class.identifier, Class);
    });

    // Initialize global variables
    GLOBAL_VARIABLES.forEach(Variable => {
      // Variable.initialize(Variable as any, instance => mocker.object(instance, {inPlace: true, callThrough: true}));
      GlobalRegistry.register(
        Variable.identifier,
        mocker.object(Variable.instance, {inPlace: true, callThrough: true}),
      );
    });
  }

  static clear(): void {
    // Reset all mock objects
    GlobalRegistry.getRegisteredIdentifiers().forEach(identifier => {
      if (GlobalRegistry.has(identifier)) {
        const mockObject = GlobalRegistry.get(identifier);
        if (mocker.isMock(mockObject)) {
          mockObject.mockClear();
        }
      }
    });

    GlobalRegistry.clear();

    // Initialize global classes
    GLOBAL_CLASSES.forEach(Class => Class.clearInitializer(Class as any));

    // Initialize global variables
    GLOBAL_VARIABLES.forEach(Variable => Variable.clearInitializer(Variable as any));
  }
}