@lee-zg/melange 1.0.0

package/dist/chunk-Q7XG6YN6.cjs

@@ -0,0 +1,682 @@
+'use strict';
+
+var chunkPK6SKIKE_cjs = require('./chunk-PK6SKIKE.cjs');
+
+// src/core/events.ts
+var EventEmitter = class {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "EventEmitter");
+  }
+  /**
+   * 事件名称到其监听器的映射
+   */
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * 订阅事件。
+   *
+   * @param event - 要订阅的事件名称
+   * @param handler - 事件发射时要调用的处理函数
+   * @returns 带有取消订阅方法的订阅对象
+   */
+  on(event, handler) {
+    return this.addListener(event, handler, false);
+  }
+  /**
+   * 仅订阅事件的一次发射。
+   * 监听器在被调用一次后自动移除。
+   *
+   * @param event - 要订阅的事件名称
+   * @param handler - 事件发射时要调用的处理函数
+   * @returns 带有取消订阅方法的订阅对象
+   */
+  once(event, handler) {
+    return this.addListener(event, handler, true);
+  }
+  /**
+   * 从事件中移除特定监听器。
+   *
+   * @param event - 事件名称
+   * @param handler - 要移除的处理函数
+   */
+  off(event, handler) {
+    const eventListeners = this.listeners.get(event);
+    if (eventListeners) {
+      const index = eventListeners.findIndex((entry) => entry.handler === handler);
+      if (index !== -1) {
+        eventListeners.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * 发射带有给定载荷的事件。
+   * 所有订阅的监听器将同步调用。
+   *
+   * @param event - 要发射的事件名称
+   * @param payload - 事件载荷
+   */
+  emit(event, payload) {
+    const eventListeners = this.listeners.get(event);
+    if (!eventListeners) return;
+    const listenersCopy = [...eventListeners];
+    for (const entry of listenersCopy) {
+      entry.handler(payload);
+      if (entry.once) {
+        this.off(event, entry.handler);
+      }
+    }
+  }
+  /**
+   * 移除特定事件的所有监听器，或如果不指定事件则移除所有监听器。
+   *
+   * @param event - 可选的事件名称，用于清除监听器
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  /**
+   * 返回特定事件的监听器数量。
+   *
+   * @param event - 事件名称
+   * @returns 监听器数量
+   */
+  listenerCount(event) {
+    const eventListeners = this.listeners.get(event);
+    return eventListeners?.length ?? 0;
+  }
+  /**
+   * 返回所有具有监听器的事件名称。
+   *
+   * @returns 事件名称数组
+   */
+  eventNames() {
+    return Array.from(this.listeners.keys());
+  }
+  /**
+   * 添加监听器的内部方法。
+   */
+  addListener(event, handler, once) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    const entry = { handler, once };
+    this.listeners.get(event).push(entry);
+    return {
+      unsubscribe: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => this.off(event, handler), "unsubscribe")
+    };
+  }
+};
+
+// src/core/container.ts
+var Lifecycle = /* @__PURE__ */ ((Lifecycle2) => {
+  Lifecycle2["Transient"] = "transient";
+  Lifecycle2["Singleton"] = "singleton";
+  return Lifecycle2;
+})(Lifecycle || {});
+var INJECTABLE_METADATA = /* @__PURE__ */ Symbol("melange:injectable");
+var INJECT_METADATA = /* @__PURE__ */ Symbol("melange:inject");
+var Container = class _Container {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "Container");
+  }
+  /**
+   * 已注册依赖项的映射
+   */
+  registrations = /* @__PURE__ */ new Map();
+  /**
+   * 用于分层解析的父容器
+   */
+  parent;
+  /**
+   * 创建新的容器实例。
+   *
+   * @param parent - 用于分层解析的可选父容器
+   */
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * 使用工厂函数注册依赖项。
+   *
+   * @template T - 依赖项类型
+   * @param token - 用于标识依赖项的令牌
+   * @param factory - 创建依赖项的工厂函数
+   * @param lifecycle - 依赖项的生命周期（默认：Transient）
+   * @returns 容器实例，用于链式调用
+   */
+  register(token, factory, lifecycle = "transient" /* Transient */) {
+    this.registrations.set(token, {
+      factory,
+      lifecycle
+    });
+    return this;
+  }
+  /**
+   * 注册单例依赖项。
+   * 工厂函数只会被调用一次，之后返回相同的实例。
+   *
+   * @template T - 依赖项类型
+   * @param token - 用于标识依赖项的令牌
+   * @param factory - 创建依赖项的工厂函数
+   * @returns 容器实例，用于链式调用
+   */
+  registerSingleton(token, factory) {
+    return this.register(token, factory, "singleton" /* Singleton */);
+  }
+  /**
+   * 直接将值注册为单例。
+   *
+   * @template T - 值类型
+   * @param token - 用于标识依赖项的令牌
+   * @param value - 要注册的值
+   * @returns 容器实例，用于链式调用
+   */
+  registerValue(token, value) {
+    this.registrations.set(token, {
+      factory: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => value, "factory"),
+      lifecycle: "singleton" /* Singleton */,
+      instance: value
+    });
+    return this;
+  }
+  /**
+   * 将类注册为依赖项。
+   * 类的实例化会自动解析其依赖项。
+   *
+   * @template T - 类类型
+   * @param ClassConstructor - 要注册的类构造函数
+   * @param lifecycle - 依赖项的生命周期（默认：Transient）
+   * @returns 容器实例，用于链式调用
+   */
+  registerClass(ClassConstructor, lifecycle = "transient" /* Transient */) {
+    const factory = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((container) => {
+      const injectTokens = this.getInjectMetadata(ClassConstructor);
+      const dependencies = injectTokens.map((token) => container.resolve(token));
+      return new ClassConstructor(...dependencies);
+    }, "factory");
+    return this.register(ClassConstructor, factory, lifecycle);
+  }
+  /**
+   * 通过令牌解析依赖项。
+   *
+   * @template T - 依赖项类型
+   * @param token - 标识依赖项的令牌
+   * @returns 已解析的依赖项
+   * @throws Error 如果依赖项未注册
+   */
+  resolve(token) {
+    const registration = this.registrations.get(token);
+    if (!registration) {
+      if (this.parent) {
+        return this.parent.resolve(token);
+      }
+      throw new Error(`Dependency not registered: ${String(token)}`);
+    }
+    if (registration.lifecycle === "singleton" /* Singleton */) {
+      if (registration.instance === void 0) {
+        registration.instance = registration.factory(this);
+      }
+      return registration.instance;
+    }
+    return registration.factory(this);
+  }
+  /**
+   * 检查依赖项是否已注册。
+   *
+   * @param token - 要检查的令牌
+   * @returns 如果依赖项已注册则返回 true
+   */
+  has(token) {
+    if (this.registrations.has(token)) {
+      return true;
+    }
+    return this.parent?.has(token) ?? false;
+  }
+  /**
+   * 移除依赖项注册。
+   *
+   * @param token - 要移除的令牌
+   * @returns 如果注册已被移除则返回 true
+   */
+  unregister(token) {
+    return this.registrations.delete(token);
+  }
+  /**
+   * 清除所有注册。
+   */
+  clear() {
+    this.registrations.clear();
+  }
+  /**
+   * 创建子容器。
+   * 子容器从父容器继承注册。
+   *
+   * @returns 新的子容器
+   */
+  createChild() {
+    return new _Container(this);
+  }
+  /**
+   * 获取类的注入元数据。
+   */
+  getInjectMetadata(target) {
+    const reflect = Reflect;
+    return reflect.getMetadata?.(INJECT_METADATA, target) ?? [];
+  }
+};
+var globalContainer = new Container();
+function Injectable() {
+  return function(target) {
+    const reflect = Reflect;
+    reflect.defineMetadata?.(INJECTABLE_METADATA, true, target);
+    return target;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Injectable, "Injectable");
+function Inject(token) {
+  return function(target, _propertyKey, parameterIndex) {
+    const reflect = Reflect;
+    const existingTokens = reflect.getMetadata?.(INJECT_METADATA, target) ?? [];
+    existingTokens[parameterIndex] = token;
+    reflect.defineMetadata?.(INJECT_METADATA, existingTokens, target);
+  };
+}
+chunkPK6SKIKE_cjs.__name(Inject, "Inject");
+function Singleton() {
+  return function(target) {
+    const reflect = Reflect;
+    reflect.defineMetadata?.(INJECTABLE_METADATA, true, target);
+    reflect.defineMetadata?.("melange:singleton", true, target);
+    return target;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Singleton, "Singleton");
+
+// src/core/decorators.ts
+function Memoize(keyFn) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const cache = /* @__PURE__ */ new Map();
+    descriptor.value = function(...args) {
+      const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+      if (cache.has(key)) {
+        return cache.get(key);
+      }
+      const result = originalMethod.apply(this, args);
+      cache.set(key, result);
+      return result;
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Memoize, "Memoize");
+function Debounce(waitMs) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    let timeoutId = null;
+    descriptor.value = function(...args) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        originalMethod.apply(this, args);
+        timeoutId = null;
+      }, waitMs);
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Debounce, "Debounce");
+function Throttle(limitMs) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    let lastCall = 0;
+    descriptor.value = function(...args) {
+      const now = Date.now();
+      if (now - lastCall >= limitMs) {
+        lastCall = now;
+        return originalMethod.apply(this, args);
+      }
+      return void 0;
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Throttle, "Throttle");
+function Log(options = {}) {
+  const { logArgs = false, logResult = false, prefix = "" } = options;
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    descriptor.value = function(...args) {
+      const logPrefix = prefix ? `[${prefix}] ` : "";
+      if (logArgs) {
+        console.log(`${logPrefix}Entering ${methodName} with args:`, args);
+      } else {
+        console.log(`${logPrefix}Entering ${methodName}`);
+      }
+      try {
+        const result = originalMethod.apply(this, args);
+        if (result instanceof Promise) {
+          return result.then((asyncResult) => {
+            if (logResult) {
+              console.log(`${logPrefix}Exiting ${methodName} with result:`, asyncResult);
+            } else {
+              console.log(`${logPrefix}Exiting ${methodName}`);
+            }
+            return asyncResult;
+          }).catch((error) => {
+            console.error(`${logPrefix}${methodName} threw error:`, error);
+            throw error;
+          });
+        }
+        if (logResult) {
+          console.log(`${logPrefix}Exiting ${methodName} with result:`, result);
+        } else {
+          console.log(`${logPrefix}Exiting ${methodName}`);
+        }
+        return result;
+      } catch (error) {
+        console.error(`${logPrefix}${methodName} threw error:`, error);
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Log, "Log");
+function Validate(validator) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      validator(...args);
+      return originalMethod.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Validate, "Validate");
+function Deprecated(message) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    const warningMessage = message ?? `${methodName} is deprecated`;
+    descriptor.value = function(...args) {
+      console.warn(`[DEPRECATED] ${warningMessage}`);
+      return originalMethod.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Deprecated, "Deprecated");
+function Sealed() {
+  return function(target) {
+    Object.seal(target);
+    Object.seal(target.prototype);
+    return target;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Sealed, "Sealed");
+function Frozen() {
+  return function(target) {
+    Object.freeze(target);
+    Object.freeze(target.prototype);
+    return target;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Frozen, "Frozen");
+function Bind() {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    return {
+      configurable: true,
+      get() {
+        const bound = originalMethod.bind(this);
+        Object.defineProperty(this, propertyKey, {
+          value: bound,
+          configurable: true,
+          writable: true
+        });
+        return bound;
+      }
+    };
+  };
+}
+chunkPK6SKIKE_cjs.__name(Bind, "Bind");
+function Retry(maxRetries, delayMs = 0) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      let lastError;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          return await originalMethod.apply(this, args);
+        } catch (error) {
+          lastError = error;
+          if (attempt < maxRetries && delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+          }
+        }
+      }
+      throw lastError;
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Retry, "Retry");
+function Timeout(timeoutMs, errorMessage) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    descriptor.value = async function(...args) {
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(
+            new Error(errorMessage ?? `${methodName} timed out after ${timeoutMs}ms`)
+          );
+        }, timeoutMs);
+      });
+      return Promise.race([originalMethod.apply(this, args), timeoutPromise]);
+    };
+    return descriptor;
+  };
+}
+chunkPK6SKIKE_cjs.__name(Timeout, "Timeout");
+
+// src/core/disposable.ts
+var Disposable = class {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "Disposable");
+  }
+  /**
+   * 此对象是否已被释放
+   */
+  _isDisposed = false;
+  /**
+   * 待清理的可释放对象列表
+   */
+  disposables = [];
+  /**
+   * 获取此对象是否已被释放。
+   */
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  /**
+   * 释放此对象和所有已注册的可释放对象。
+   * 多次调用 dispose 是安全的（后续调用无效）。
+   */
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    for (let i = this.disposables.length - 1; i >= 0; i--) {
+      try {
+        this.disposables[i]?.dispose();
+      } catch (error) {
+        console.error("Error during disposal:", error);
+      }
+    }
+    this.disposables.length = 0;
+    this.onDispose();
+  }
+  /**
+   * 注册一个可释放对象，在此对象被释放时进行清理。
+   *
+   * @template T - 可释放对象类型
+   * @param disposable - 要注册的可释放对象
+   * @returns 相同的可释放对象，用于链式调用
+   */
+  addDisposable(disposable) {
+    if (this._isDisposed) {
+      disposable.dispose();
+    } else {
+      this.disposables.push(disposable);
+    }
+    return disposable;
+  }
+  /**
+   * 注册一个清理函数，在此对象被释放时调用。
+   *
+   * @param fn - 清理函数
+   */
+  addDisposeFn(fn) {
+    this.addDisposable({ dispose: fn, isDisposed: false });
+  }
+  /**
+   * 如果此对象已被释放则抛出错误。
+   * 在不应在释放后调用的方法开头使用此函数。
+   *
+   * @throws Error 如果对象已被释放
+   */
+  ensureNotDisposed() {
+    if (this._isDisposed) {
+      throw new Error("Object has been disposed");
+    }
+  }
+  /**
+   * 在对象被释放时调用。
+   * 在子类中重写以执行自定义清理。
+   */
+  onDispose() {
+  }
+};
+var DisposableStore = class {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "DisposableStore");
+  }
+  items = /* @__PURE__ */ new Set();
+  _isDisposed = false;
+  /**
+   * 获取此存储是否已被释放。
+   */
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  /**
+   * 向存储中添加可释放对象。
+   *
+   * @template T - 可释放对象类型
+   * @param disposable - 要添加的可释放对象
+   * @returns 相同的可释放对象，用于链式调用
+   */
+  add(disposable) {
+    if (this._isDisposed) {
+      disposable.dispose();
+    } else {
+      this.items.add(disposable);
+    }
+    return disposable;
+  }
+  /**
+   * 从存储中移除可释放对象而不释放它。
+   *
+   * @param disposable - 要移除的可释放对象
+   */
+  delete(disposable) {
+    this.items.delete(disposable);
+  }
+  /**
+   * 释放存储中的所有项目并清空存储。
+   */
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    for (const item of this.items) {
+      try {
+        item.dispose();
+      } catch (error) {
+        console.error("Error during disposal:", error);
+      }
+    }
+    this.items.clear();
+  }
+  /**
+   * 释放所有项目但保持存储活跃以接收新项目。
+   */
+  clear() {
+    for (const item of this.items) {
+      try {
+        item.dispose();
+      } catch (error) {
+        console.error("Error during disposal:", error);
+      }
+    }
+    this.items.clear();
+  }
+  /**
+   * 获取存储中的项目数量。
+   */
+  get size() {
+    return this.items.size;
+  }
+};
+function toDisposable(dispose) {
+  return {
+    dispose,
+    isDisposed: false
+  };
+}
+chunkPK6SKIKE_cjs.__name(toDisposable, "toDisposable");
+function combineDisposables(...disposables) {
+  return {
+    dispose: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => {
+      for (const d of disposables) {
+        d.dispose();
+      }
+    }, "dispose"),
+    isDisposed: false
+  };
+}
+chunkPK6SKIKE_cjs.__name(combineDisposables, "combineDisposables");
+
+exports.Bind = Bind;
+exports.Container = Container;
+exports.Debounce = Debounce;
+exports.Deprecated = Deprecated;
+exports.Disposable = Disposable;
+exports.DisposableStore = DisposableStore;
+exports.EventEmitter = EventEmitter;
+exports.Frozen = Frozen;
+exports.Inject = Inject;
+exports.Injectable = Injectable;
+exports.Lifecycle = Lifecycle;
+exports.Log = Log;
+exports.Memoize = Memoize;
+exports.Retry = Retry;
+exports.Sealed = Sealed;
+exports.Singleton = Singleton;
+exports.Throttle = Throttle;
+exports.Timeout = Timeout;
+exports.Validate = Validate;
+exports.combineDisposables = combineDisposables;
+exports.globalContainer = globalContainer;
+exports.toDisposable = toDisposable;
+//# sourceMappingURL=chunk-Q7XG6YN6.cjs.map
+//# sourceMappingURL=chunk-Q7XG6YN6.cjs.map