obsidian-dev-utils 66.0.1 → 68.0.0

package/dist/lib/esm/async-events.mjs

@@ -22,11 +22,13 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { filterInPlace } from "./array.mjs";
-class AsyncEvents {
+class AsyncEventsBase {
   eventRefsMap = /* @__PURE__ */ new Map();
   /**
    * Remove an event listener.
    *
+   * @typeParam EventName - The name of the event.
+   * @typeParam Args - The types of the arguments the event callback accepts.
    * @param name - The name of the event.
    * @param callback - The callback to remove.
    *
@@ -35,6 +37,7 @@ class AsyncEvents {
    * events.off('my-event', myListener);
    * ```
    */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
   off(name, callback) {
     const eventRefs = this.eventRefsMap.get(name);
     if (!eventRefs) {
@@ -68,6 +71,8 @@ class AsyncEvents {
   /**
    * Add an event listener.
    *
+   * @typeParam EventName - The name of the event.
+   * @typeParam Args - The types of the arguments the event callback accepts.
    * @param name - The name of the event.
    * @param callback - The callback to call when the event is triggered.
    * @param thisArg - The context passed as `this` to the `callback`.
@@ -81,14 +86,7 @@ class AsyncEvents {
    * });
    * ```
    */
-  /**
-   * Subscribes to an event.
-   *
-   * @param name - The name of the event.
-   * @param callback - The callback.
-   * @param thisArg - The `this` context.
-   * @returns A reference to the event listener.
-   */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
   on(name, callback, thisArg) {
     let eventRefs = this.eventRefsMap.get(name);
     if (!eventRefs) {
@@ -96,7 +94,7 @@ class AsyncEvents {
       this.eventRefsMap.set(name, eventRefs);
     }
     const eventRef = {
-      asyncEvents: this,
+      asyncEventSource: this,
       callback,
       name,
       thisArg
@@ -107,6 +105,8 @@ class AsyncEvents {
   /**
    * Add an event listener that will be triggered only once.
    *
+   * @typeParam EventName - The name of the event.
+   * @typeParam Args - The types of the arguments the event callback accepts.
    * @param name - The name of the event.
    * @param callback - The callback to call when the event is triggered.
    * @param thisArg - The context passed as `this` to the `callback`.
@@ -120,14 +120,7 @@ class AsyncEvents {
    * });
    * ```
    */
-  /**
-   * Subscribes to an event once.
-   *
-   * @param name - The name of the event.
-   * @param callback - The callback to call when the event is triggered.
-   * @param thisArg - The context passed as `this` to the `callback`.
-   * @returns A reference to the event listener.
-   */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
   once(name, callback, thisArg) {
     const originalEventRef = this.on(name, callback, thisArg);
     const cleanupEventRef = this.on(name, () => {
@@ -139,6 +132,7 @@ class AsyncEvents {
   /**
    * Trigger an event, executing all the listeners in order even if some of them throw an error.
    *
+   * @typeParam EventName - The name of the event.
    * @param name - The name of the event.
    * @param args - The data to pass to the event listeners.
    *
@@ -147,7 +141,6 @@ class AsyncEvents {
    * events.trigger('my-event', 'arg1', 'arg2');
    * ```
    */
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
   trigger(name, ...args) {
     const eventRefs = this.eventRefsMap.get(name) ?? [];
     for (const eventRef of eventRefs.slice()) {
@@ -157,10 +150,11 @@ class AsyncEvents {
   /**
    * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
    *
+   * @typeParam EventName - The name of the event.
    * @param name - The name of the event.
    * @param args - The data to pass to the event listeners.
+   * @returns A {@link Promise} that resolves when all listeners have completed.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
   async triggerAsync(name, ...args) {
     const eventRefs = this.eventRefsMap.get(name) ?? [];
     for (const eventRef of eventRefs.slice()) {
@@ -170,6 +164,7 @@ class AsyncEvents {
   /**
    * Try to trigger an event, executing all the listeners in order even if some of them throw an error.
    *
+   * @typeParam Args - The types of the arguments the function accepts.
    * @param eventRef - The event reference.
    * @param args - The data to pass to the event listeners.
    *
@@ -181,32 +176,185 @@ class AsyncEvents {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
   tryTrigger(eventRef, args) {
     try {
-      eventRef.callback.apply(eventRef.thisArg, args);
+      const result = eventRef.callback.call(eventRef.thisArg, ...args);
+      if (result instanceof Promise) {
+        result.catch(throwDelayed);
+      }
     } catch (e) {
-      window.setTimeout(() => {
-        throw e;
-      }, 0);
+      throwDelayed(e);
     }
   }
   /**
    * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
    *
+   * @typeParam Args - The types of the arguments the function accepts.
    * @param eventRef - The event reference.
    * @param args - The data to pass to the event listeners.
+   * @returns A {@link Promise} that resolves when all listeners have completed.
    */
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
   async tryTriggerAsync(eventRef, args) {
     try {
-      const result = eventRef.callback.call(eventRef.thisArg, ...args);
-      await result;
+      await eventRef.callback.call(eventRef.thisArg, ...args);
     } catch (e) {
-      window.setTimeout(() => {
-        throw e;
-      }, 0);
+      throwDelayed(e);
     }
   }
 }
+class AsyncEvents extends AsyncEventsBase {
+  /**
+   * Trigger an event, executing all the listeners in order even if some of them throw an error.
+   *
+   * @typeParam EventName - The name of the event.
+   * @param name - The name of the event.
+   * @param args - The data to pass to the event listeners.
+   */
+  trigger(name, ...args) {
+    super.trigger(name, ...args);
+  }
+  /**
+   * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+   *
+   * @typeParam EventName - The name of the event.
+   * @param name - The name of the event.
+   * @param args - The data to pass to the event listeners.
+   * @returns A {@link Promise} that resolves when all listeners have completed.
+   */
+  triggerAsync(name, ...args) {
+    return super.triggerAsync(name, ...args);
+  }
+  /**
+   * Try to trigger an event, executing all the listeners in order even if some of them throw an error.
+   *
+   * @typeParam Args - The types of the arguments the function accepts.
+   * @param eventRef - The event reference.
+   * @param args - The data to pass to the event listeners.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
+  tryTrigger(eventRef, args) {
+    super.tryTrigger(eventRef, args);
+  }
+  /**
+   * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+   *
+   * @typeParam Args - The types of the arguments the function accepts.
+   * @param eventRef - The event reference.
+   * @param args - The data to pass to the event listeners.
+   * @returns A {@link Promise} that resolves when all listeners have completed.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
+  async tryTriggerAsync(eventRef, args) {
+    return super.tryTriggerAsync(eventRef, args);
+  }
+}
+function mixinAsyncEvents() {
+  return function inner(baseClass) {
+    class AsyncEventsMixin extends baseClass {
+      #asyncEvents = new AsyncEvents();
+      /**
+       * Remove an event listener.
+       *
+       * @typeParam EventName - The name of the event.
+       * @typeParam Args - The types of the arguments the event callback accepts.
+       * @param name - The name of the event.
+       * @param callback - The callback to remove.
+       */
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
+      off(name, callback) {
+        this.#asyncEvents.off(name, callback);
+      }
+      /**
+       * Remove an event listener by reference.
+       *
+       * @param eventRef - The event reference to remove.
+       */
+      offref(eventRef) {
+        this.#asyncEvents.offref(eventRef);
+      }
+      /**
+       * Add an event listener.
+       *
+       * @typeParam EventName - The name of the event.
+       * @typeParam Args - The types of the arguments the event callback accepts.
+       * @param name - The name of the event.
+       * @param callback - The callback to call when the event is triggered.
+       * @param thisArg - The context passed as `this` to the `callback`.
+       * @returns A reference to the event listener.
+       */
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
+      on(name, callback, thisArg) {
+        return this.#asyncEvents.on(name, callback, thisArg);
+      }
+      /**
+       * Add an event listener that will be called only once.
+       *
+       * @typeParam EventName - The name of the event.
+       * @typeParam Args - The types of the arguments the event callback accepts.
+       * @param name - The name of the event.
+       * @param callback - The callback to call when the event is triggered.
+       * @param thisArg - The context passed as `this` to the `callback`.
+       * @returns A reference to the event listener.
+       */
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.
+      once(name, callback, thisArg) {
+        return this.#asyncEvents.once(name, callback, thisArg);
+      }
+      /**
+       * Trigger an event, executing all the listeners in order even if some of them throw an error.
+       *
+       * @typeParam EventName - The name of the event.
+       * @param name - The name of the event.
+       * @param args - The data to pass to the event listeners.
+       */
+      trigger(name, ...args) {
+        this.#asyncEvents.trigger(name, ...args);
+      }
+      /**
+       * Trigger an event asynchronously.
+       *
+       * @typeParam EventName - The name of the event.
+       * @param name - The name of the event.
+       * @param args - The data to pass to the event listeners.
+       * @returns A {@link Promise} that resolves when all listeners have completed.
+       */
+      async triggerAsync(name, ...args) {
+        await this.#asyncEvents.triggerAsync(name, ...args);
+      }
+      /**
+       * Try to trigger an event, executing all the listeners in order even if some of them throw an error.
+       *
+       * @typeParam Args - The types of the arguments the function accepts.
+       * @param eventRef - The event reference.
+       * @param args - The data to pass to the event listeners.
+       */
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- Parity with Obsidian's Events.tryTrigger.
+      tryTrigger(eventRef, args) {
+        this.#asyncEvents.tryTrigger(eventRef, args);
+      }
+      /**
+       * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+       *
+       * @typeParam Args - The types of the arguments the function accepts.
+       * @param eventRef - The event reference.
+       * @param args - The data to pass to the event listeners.
+       * @returns A {@link Promise} that resolves when all listeners have completed.
+       */
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- Parity with Obsidian's Events.tryTrigger.
+      async tryTriggerAsync(eventRef, args) {
+        await this.#asyncEvents.tryTriggerAsync(eventRef, args);
+      }
+    }
+    return AsyncEventsMixin;
+  };
+}
+function throwDelayed(error) {
+  window.setTimeout(() => {
+    throw error;
+  }, 0);
+}
 export {
-  AsyncEvents
+  AsyncEvents,
+  AsyncEventsBase,
+  mixinAsyncEvents
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/async-events.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Async event emitter.\n */\n\nimport type { GenericPromisableVoidFunction } from './function.ts';\n\nimport { filterInPlace } from './array.ts';\n\n/**\n * Async event reference.\n */\nexport interface AsyncEventRef {\n  /**\n   * An event emitter.\n   */\n  asyncEvents: AsyncEvents;\n\n  /**\n   * A callback to call when the event is triggered.\n   */\n  callback: GenericCallback;\n\n  /**\n   * A name of the event.\n   */\n  name: string;\n\n  /**\n   * A context passed as `this` to the `callback`.\n   */\n  thisArg: unknown;\n}\n\ntype GenericCallback = GenericPromisableVoidFunction<unknown[]>;\n\n/**\n * Async event emitter implementation\n */\nexport class AsyncEvents {\n  private readonly eventRefsMap = new Map<string, AsyncEventRef[]>();\n\n  /**\n   * Remove an event listener.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   *\n   * @example\n   * ```ts\n   * events.off('my-event', myListener);\n   * ```\n   */\n  public off<Args extends unknown[]>(name: string, callback: GenericPromisableVoidFunction<Args>): void {\n    const eventRefs = this.eventRefsMap.get(name);\n    if (!eventRefs) {\n      return;\n    }\n\n    filterInPlace(eventRefs, (eventRef) => eventRef.callback !== callback);\n    if (eventRefs.length === 0) {\n      this.eventRefsMap.delete(name);\n    }\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.offref(myRef);\n   * ```\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    const eventRefs = this.eventRefsMap.get(eventRef.name);\n    if (!eventRefs) {\n      return;\n    }\n\n    filterInPlace(eventRefs, (storedEventRef) => storedEventRef !== eventRef);\n    if (eventRefs.length === 0) {\n      this.eventRefsMap.delete(eventRef.name);\n    }\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.on('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   */\n\n  /**\n   * Subscribes to an event.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback.\n   * @param thisArg - The `this` context.\n   * @returns A reference to the event listener.\n   */\n  public on<Args extends unknown[]>(name: string, callback: GenericPromisableVoidFunction<Args>, thisArg?: unknown): AsyncEventRef {\n    let eventRefs = this.eventRefsMap.get(name);\n    if (!eventRefs) {\n      eventRefs = [];\n      this.eventRefsMap.set(name, eventRefs);\n    }\n\n    const eventRef: AsyncEventRef = {\n      asyncEvents: this,\n      callback: callback as GenericCallback,\n      name,\n      thisArg\n    };\n    eventRefs.push(eventRef);\n    return eventRef;\n  }\n\n  /**\n   * Add an event listener that will be triggered only once.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.once('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   */\n\n  /**\n   * Subscribes to an event once.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   */\n  public once<Args extends unknown[]>(name: string, callback: GenericPromisableVoidFunction<Args>, thisArg?: unknown): AsyncEventRef {\n    const originalEventRef = this.on(name, callback, thisArg);\n    const cleanupEventRef = this.on(name, () => {\n      this.offref(originalEventRef);\n      this.offref(cleanupEventRef);\n    });\n    return originalEventRef;\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @example\n   * ```ts\n   * events.trigger('my-event', 'arg1', 'arg2');\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public trigger<Args extends unknown[]>(name: string, ...args: Args): void {\n    const eventRefs = this.eventRefsMap.get(name) ?? [];\n    for (const eventRef of eventRefs.slice()) {\n      this.tryTrigger(eventRef, args);\n    }\n  }\n\n  /**\n   * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public async triggerAsync<Args extends unknown[]>(name: string, ...args: Args): Promise<void> {\n    const eventRefs = this.eventRefsMap.get(name) ?? [];\n    for (const eventRef of eventRefs.slice()) {\n      await this.tryTriggerAsync(eventRef, args);\n    }\n  }\n\n  /**\n   * Try to trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @example\n   * ```ts\n   * events.tryTrigger(myRef, ['arg1', 'arg2']);\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public tryTrigger<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): void {\n    try {\n      eventRef.callback.apply(eventRef.thisArg, args);\n    } catch (e) {\n      window.setTimeout(() => {\n        throw e;\n      }, 0);\n    }\n  }\n\n  /**\n   * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public async tryTriggerAsync<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): Promise<void> {\n    try {\n      const result = eventRef.callback.call(eventRef.thisArg, ...args);\n      await (result as Promise<void>);\n    } catch (e) {\n      window.setTimeout(() => {\n        throw e;\n      }, 0);\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/async-events.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Async event emitter.\n */\n\nimport type {\n  AbstractConstructor,\n  Promisable\n} from 'type-fest';\n\nimport type { GenericPromisableVoidFunction } from './function.ts';\nimport type { StringKeys } from './type.ts';\n\nimport { filterInPlace } from './array.ts';\n\n/**\n * Async event reference.\n */\nexport interface AsyncEventRef {\n  /**\n   * An event source.\n   */\n  asyncEventSource: GenericAsyncEventSource;\n\n  /**\n   * A callback to call when the event is triggered.\n   */\n  callback: GenericCallback;\n\n  /**\n   * A name of the event.\n   */\n  name: string;\n\n  /**\n   * A context passed as `this` to the `callback`.\n   */\n  thisArg: unknown;\n}\n\n/**\n * Async event emitter implementation.\n *\n * @typeParam EventMap - Maps event names to their argument tuples.\n * When omitted, the emitter accepts any string event name with any arguments.\n * When provided, methods enforce correct event names and argument types\n * with full autocomplete. Works with both `type` aliases and `interface` declarations.\n *\n * @example\n * ```ts\n * // Untyped (default) \u2014 any event name, any args:\n * const events = new AsyncEvents();\n * events.on('my-event', (arg1: string) => { ... });\n *\n * // Typed \u2014 only declared events with correct args:\n * interface MyEventMap {\n *   save: [data: string];\n *   load: [id: number, force: boolean];\n * }\n * const events = new AsyncEvents<MyEventMap>();\n * events.on('save', (data) => { ... });   // data: string \u2014 autocomplete on event name\n * events.on('load', (id, force) => { ... }); // id: number, force: boolean\n * ```\n */\nexport interface AsyncEventSource<EventMap extends EventMapConstraint<EventMap> = EventMapBase> extends GenericAsyncEventSource {\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Args - The arguments of the event.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   *\n   * @example\n   * ```ts\n   * events.off('my-event', myListener);\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  off<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n    name: EventName,\n    callback: (...args: Args) => Promisable<void>\n  ): void;\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Args - The arguments of the event.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.on('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  on<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n    name: EventName,\n    callback: (...args: Args) => Promisable<void>,\n    thisArg?: unknown\n  ): AsyncEventRef;\n\n  /**\n   * Add an event listener that will be triggered only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.once('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  once<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n    name: EventName,\n    callback: (...args: Args) => Promisable<void>,\n    thisArg?: unknown\n  ): AsyncEventRef;\n}\n\n/**\n * Interface exposing event-triggering methods for subclasses of mixin-created classes.\n *\n * These methods are `protected` at runtime but surfaced in the declaration type\n * because TypeScript cannot represent `protected` in anonymous-class return types.\n *\n * @typeParam EventMap - Maps event names to their argument tuples.\n */\nexport interface AsyncEventTrigger<EventMap extends EventMapConstraint<EventMap> = EventMapBase> {\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam EventName - The name of the event.\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   */\n  trigger<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): void;\n\n  /**\n   * Trigger an event asynchronously.\n   *\n   * @typeParam EventName - The name of the event.\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   * @returns A {@link Promise} that resolves when all listeners have completed.\n   */\n  triggerAsync<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): Promise<void>;\n\n  /**\n   * Try to trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam Args - The types of the arguments the function accepts.\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  tryTrigger<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): void;\n\n  /**\n   * Try to trigger an event asynchronously.\n   *\n   * @typeParam Args - The types of the arguments the function accepts.\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   * @returns A {@link Promise} that resolves when all listeners have completed.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  tryTriggerAsync<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): Promise<void>;\n}\n\n/**\n * Resolves callback argument types for an event.\n *\n * - When `EventMap` has an index signature (untyped default): returns `unknown[]`,\n *   allowing `Args` to be inferred freely from the callback.\n * - When `EventMap` has explicit keys only (typed map): returns `EventMap[EventName]`,\n *   enforcing the declared argument types and enabling autocomplete.\n *\n * @typeParam EventMap - Maps event names to their argument tuples.\n * @typeParam EventName - The name of the event.\n */\nexport type CallbackArgs<EventMap, EventName extends string> = string extends keyof EventMap ? unknown[]\n  : (EventName extends keyof EventMap ? EventMap[EventName] : unknown[]);\n\n/**\n * Base event map type for untyped emitters.\n */\nexport type EventMapBase = Record<string, unknown[]>;\n\n/**\n * Interface for event source, used by {@link AsyncEventRef}\n * so that refs can be stored regardless of the emitter's `EventMap`.\n */\nexport interface GenericAsyncEventSource {\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to remove.\n   */\n  offref(eventRef: AsyncEventRef): void;\n}\n\ntype EventMapConstraint<T> = Record<keyof T, unknown[]>;\n\ntype GenericCallback = GenericPromisableVoidFunction<unknown[]>;\n\n/**\n * Async event source implementation.\n *\n * @typeParam EventMap - Maps event names to their argument tuples.\n * When omitted, the emitter accepts any string event name with any arguments.\n * When provided, methods enforce correct event names and argument types\n * with full autocomplete. Works with both `type` aliases and `interface` declarations.\n *\n * @example\n * ```ts\n * // Untyped (default) \u2014 any event name, any args:\n * const events = new AsyncEvents();\n * events.on('my-event', (arg1: string) => { ... });\n *\n * // Typed \u2014 only declared events with correct args:\n * interface MyEventMap {\n *   save: [data: string];\n *   load: [id: number, force: boolean];\n * }\n * const events = new AsyncEvents<MyEventMap>();\n * events.on('save', (data) => { ... });   // data: string \u2014 autocomplete on event name\n * events.on('load', (id, force) => { ... }); // id: number, force: boolean\n * ```\n */\nexport abstract class AsyncEventsBase<EventMap extends EventMapConstraint<EventMap> = EventMapBase> implements AsyncEventSource<EventMap> {\n  private readonly eventRefsMap = new Map<string, AsyncEventRef[]>();\n\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Args - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   *\n   * @example\n   * ```ts\n   * events.off('my-event', myListener);\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public off<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n    name: EventName,\n    callback: (...args: Args) => Promisable<void>\n  ): void {\n    const eventRefs = this.eventRefsMap.get(name);\n    if (!eventRefs) {\n      return;\n    }\n\n    filterInPlace(eventRefs, (eventRef) => eventRef.callback !== callback);\n    if (eventRefs.length === 0) {\n      this.eventRefsMap.delete(name);\n    }\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.offref(myRef);\n   * ```\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    const eventRefs = this.eventRefsMap.get(eventRef.name);\n    if (!eventRefs) {\n      return;\n    }\n\n    filterInPlace(eventRefs, (storedEventRef) => storedEventRef !== eventRef);\n    if (eventRefs.length === 0) {\n      this.eventRefsMap.delete(eventRef.name);\n    }\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Args - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.on('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public on<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n    name: EventName,\n    callback: (...args: Args) => Promisable<void>,\n    thisArg?: unknown\n  ): AsyncEventRef {\n    let eventRefs = this.eventRefsMap.get(name);\n    if (!eventRefs) {\n      eventRefs = [];\n      this.eventRefsMap.set(name, eventRefs);\n    }\n\n    const eventRef: AsyncEventRef = {\n      asyncEventSource: this,\n      callback: callback as GenericCallback,\n      name,\n      thisArg\n    };\n    eventRefs.push(eventRef);\n    return eventRef;\n  }\n\n  /**\n   * Add an event listener that will be triggered only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Args - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.once('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public once<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n    name: EventName,\n    callback: (...args: Args) => Promisable<void>,\n    thisArg?: unknown\n  ): AsyncEventRef {\n    const originalEventRef = this.on(name, callback, thisArg);\n    const cleanupEventRef = this.on(name, () => {\n      this.offref(originalEventRef);\n      this.offref(cleanupEventRef);\n    });\n    return originalEventRef;\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam EventName - The name of the event.\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @example\n   * ```ts\n   * events.trigger('my-event', 'arg1', 'arg2');\n   * ```\n   */\n  protected trigger<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): void {\n    const eventRefs = this.eventRefsMap.get(name) ?? [];\n    for (const eventRef of eventRefs.slice()) {\n      this.tryTrigger(eventRef, args);\n    }\n  }\n\n  /**\n   * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam EventName - The name of the event.\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   * @returns A {@link Promise} that resolves when all listeners have completed.\n   */\n  protected async triggerAsync<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): Promise<void> {\n    const eventRefs = this.eventRefsMap.get(name) ?? [];\n    for (const eventRef of eventRefs.slice()) {\n      await this.tryTriggerAsync(eventRef, args);\n    }\n  }\n\n  /**\n   * Try to trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam Args - The types of the arguments the function accepts.\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @example\n   * ```ts\n   * events.tryTrigger(myRef, ['arg1', 'arg2']);\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  protected tryTrigger<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): void {\n    try {\n      const result = eventRef.callback.call(eventRef.thisArg, ...args);\n      if (result instanceof Promise) {\n        result.catch(throwDelayed);\n      }\n    } catch (e) {\n      throwDelayed(e);\n    }\n  }\n\n  /**\n   * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam Args - The types of the arguments the function accepts.\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   * @returns A {@link Promise} that resolves when all listeners have completed.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  protected async tryTriggerAsync<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): Promise<void> {\n    try {\n      await eventRef.callback.call(eventRef.thisArg, ...args);\n    } catch (e) {\n      throwDelayed(e);\n    }\n  }\n}\n\n/**\n * A class that extends {@link AsyncEventsBase} and provides public methods for triggering events.\n *\n * This class exists as parity with {@link obsidian#Events}. But exposing publicly `trigger()` methods violates encapsulation.\n *\n * Avoid using it in favor of {@link AsyncEventsBase}.\n *\n * @typeParam EventMap - The type of the event map.\n */\nexport class AsyncEvents<EventMap extends EventMapConstraint<EventMap> = EventMapBase> extends AsyncEventsBase<EventMap> {\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam EventName - The name of the event.\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   */\n  public override trigger<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): void {\n    super.trigger(name, ...args);\n  }\n\n  /**\n   * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam EventName - The name of the event.\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   * @returns A {@link Promise} that resolves when all listeners have completed.\n   */\n  public override triggerAsync<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): Promise<void> {\n    return super.triggerAsync(name, ...args);\n  }\n\n  /**\n   * Try to trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam Args - The types of the arguments the function accepts.\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public override tryTrigger<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): void {\n    super.tryTrigger(eventRef, args);\n  }\n\n  /**\n   * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @typeParam Args - The types of the arguments the function accepts.\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   * @returns A {@link Promise} that resolves when all listeners have completed.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n  public override async tryTriggerAsync<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): Promise<void> {\n    return super.tryTriggerAsync(eventRef, args);\n  }\n}\n\n/**\n * Mixin that adds {@link AsyncEventSource} delegation to a base class.\n *\n * All event methods delegate to a private {@link AsyncEventsBase} instance.\n * The `EventMap` generic is fixed at mixin-application time \u2014 if you need a class\n * that is itself generic over its event map, use composition instead.\n *\n * @typeParam EventMap - Maps event names to their argument tuples.\n * @returns A function that takes a base class and returns a new class extending it with {@link AsyncEventSource}.\n *\n * @example\n * ```ts\n * interface MyEvents {\n *   save: [data: string];\n * }\n * class MyComponent extends mixinAsyncEvents<MyEvents>()(Component) {\n *   // on(), off(), once(), offref() are available\n * }\n * ```\n */\nexport function mixinAsyncEvents<EventMap extends EventMapConstraint<EventMap> = EventMapBase>() {\n  return function inner<TBase extends AbstractConstructor<object>>(\n    baseClass: TBase\n  ): AbstractConstructor<AsyncEventSource<EventMap> & AsyncEventTrigger<EventMap>> & TBase {\n    abstract class AsyncEventsMixin extends baseClass implements AsyncEventSource<EventMap> {\n      readonly #asyncEvents = new AsyncEvents<EventMap>();\n\n      /**\n       * Remove an event listener.\n       *\n       * @typeParam EventName - The name of the event.\n       * @typeParam Args - The types of the arguments the event callback accepts.\n       * @param name - The name of the event.\n       * @param callback - The callback to remove.\n       */\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n      public off<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n        name: EventName,\n        callback: (...args: Args) => Promisable<void>\n      ): void {\n        this.#asyncEvents.off(name, callback);\n      }\n\n      /**\n       * Remove an event listener by reference.\n       *\n       * @param eventRef - The event reference to remove.\n       */\n      public offref(eventRef: AsyncEventRef): void {\n        this.#asyncEvents.offref(eventRef);\n      }\n\n      /**\n       * Add an event listener.\n       *\n       * @typeParam EventName - The name of the event.\n       * @typeParam Args - The types of the arguments the event callback accepts.\n       * @param name - The name of the event.\n       * @param callback - The callback to call when the event is triggered.\n       * @param thisArg - The context passed as `this` to the `callback`.\n       * @returns A reference to the event listener.\n       */\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n      public on<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n        name: EventName,\n        callback: (...args: Args) => Promisable<void>,\n        thisArg?: unknown\n      ): AsyncEventRef {\n        return this.#asyncEvents.on(name, callback, thisArg);\n      }\n\n      /**\n       * Add an event listener that will be called only once.\n       *\n       * @typeParam EventName - The name of the event.\n       * @typeParam Args - The types of the arguments the event callback accepts.\n       * @param name - The name of the event.\n       * @param callback - The callback to call when the event is triggered.\n       * @param thisArg - The context passed as `this` to the `callback`.\n       * @returns A reference to the event listener.\n       */\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n      public once<EventName extends StringKeys<EventMap>, Args extends CallbackArgs<EventMap, EventName>>(\n        name: EventName,\n        callback: (...args: Args) => Promisable<void>,\n        thisArg?: unknown\n      ): AsyncEventRef {\n        return this.#asyncEvents.once(name, callback, thisArg);\n      }\n\n      /**\n       * Trigger an event, executing all the listeners in order even if some of them throw an error.\n       *\n       * @typeParam EventName - The name of the event.\n       * @param name - The name of the event.\n       * @param args - The data to pass to the event listeners.\n       */\n      protected trigger<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): void {\n        this.#asyncEvents.trigger(name, ...args);\n      }\n\n      /**\n       * Trigger an event asynchronously.\n       *\n       * @typeParam EventName - The name of the event.\n       * @param name - The name of the event.\n       * @param args - The data to pass to the event listeners.\n       * @returns A {@link Promise} that resolves when all listeners have completed.\n       */\n      protected async triggerAsync<EventName extends StringKeys<EventMap>>(name: EventName, ...args: CallbackArgs<EventMap, EventName>): Promise<void> {\n        await this.#asyncEvents.triggerAsync(name, ...args);\n      }\n\n      /**\n       * Try to trigger an event, executing all the listeners in order even if some of them throw an error.\n       *\n       * @typeParam Args - The types of the arguments the function accepts.\n       * @param eventRef - The event reference.\n       * @param args - The data to pass to the event listeners.\n       */\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- Parity with Obsidian's Events.tryTrigger.\n      protected tryTrigger<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): void {\n        this.#asyncEvents.tryTrigger(eventRef, args);\n      }\n\n      /**\n       * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n       *\n       * @typeParam Args - The types of the arguments the function accepts.\n       * @param eventRef - The event reference.\n       * @param args - The data to pass to the event listeners.\n       * @returns A {@link Promise} that resolves when all listeners have completed.\n       */\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- Parity with Obsidian's Events.tryTrigger.\n      protected async tryTriggerAsync<Args extends unknown[]>(eventRef: AsyncEventRef, args: Args): Promise<void> {\n        await this.#asyncEvents.tryTriggerAsync(eventRef, args);\n      }\n    }\n\n    return AsyncEventsMixin as AbstractConstructor<AsyncEventSource<EventMap> & AsyncEventTrigger<EventMap>> & TBase;\n  };\n}\n\nfunction throwDelayed(error: unknown): void {\n  window.setTimeout(() => {\n    throw error;\n  }, 0);\n}\n"],
  "mappings": "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",
  "names": []
}
