scriptable-testlab/dist/esm/registry.js

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

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import mocker from "@corez/mocker";
import { GLOBAL_CLASSES, GLOBAL_VARIABLES } from "./mocks";
class MockError extends Error {
  constructor(code, message, details) {
    super(message);
    this.code = code;
    this.message = message;
    this.details = details;
    this.name = "MockError";
  }
}
const MockErrorCode = {
  INVALID_TARGET: "INVALID_TARGET"
};
class GlobalRegistry {
  /**
   * Register a mock object globally
   */
  static register(identifier, mockObject) {
    if (mockObject != null && (typeof mockObject === "object" || typeof mockObject === "function")) {
      this.registry.set(identifier, mockObject);
      global[identifier] = mockObject;
    }
  }
  /**
   * Unregister a mock object
   */
  static unregister(identifier) {
    if (this.registry.has(identifier)) {
      this.registry.delete(identifier);
      delete global[identifier];
    }
  }
  /**
   * Get a registered mock object
   */
  static get(identifier) {
    const mockObject = this.registry.get(identifier);
    if (!mockObject) {
      throw {
        code: MockErrorCode.INVALID_TARGET,
        message: `Mock not found: ${identifier}`
      };
    }
    return mockObject;
  }
  /**
   * Check if identifier is registered
   */
  static has(identifier) {
    return this.registry.has(identifier);
  }
  /**
   * Clear all registered mocks
   */
  static clear() {
    this.registry.forEach((_, identifier) => {
      delete global[identifier];
    });
    this.registry.clear();
  }
  /**
   * Get all registered identifiers
   */
  static getRegisteredIdentifiers() {
    return Array.from(this.registry.keys());
  }
}
__publicField(GlobalRegistry, "registry", /* @__PURE__ */ new Map());
class GlobalMockManager {
  static initialize() {
    this.clear();
    GLOBAL_CLASSES.forEach((Class) => {
      Class.initialize(Class, (instance) => mocker.object(instance, { inPlace: true, callThrough: true }));
      GlobalRegistry.register(Class.identifier, Class);
    });
    GLOBAL_VARIABLES.forEach((Variable) => {
      GlobalRegistry.register(
        Variable.identifier,
        mocker.object(Variable.instance, { inPlace: true, callThrough: true })
      );
    });
  }
  static clear() {
    GlobalRegistry.getRegisteredIdentifiers().forEach((identifier) => {
      if (GlobalRegistry.has(identifier)) {
        const mockObject = GlobalRegistry.get(identifier);
        if (mocker.isMock(mockObject)) {
          mockObject.mockClear();
        }
      }
    });
    GlobalRegistry.clear();
    GLOBAL_CLASSES.forEach((Class) => Class.clearInitializer(Class));
    GLOBAL_VARIABLES.forEach((Variable) => Variable.clearInitializer(Variable));
  }
}
export {
  GlobalMockManager,
  GlobalRegistry,
  MockError,
  MockErrorCode
};
//# sourceMappingURL=registry.js.map