obsidian-dev-utils
Version:
This is the collection of useful functions that you can use for your Obsidian plugin development
214 lines (210 loc) • 18.6 kB
JavaScript
/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/
(function initEsm() {
if (globalThis.process) {
return;
}
const browserProcess = {
browser: true,
cwd() {
return '/';
},
env: {},
platform: 'android'
};
globalThis.process = browserProcess;
})();
import { filterInPlace } from "./Array.mjs";
class AsyncEvents {
eventRefsMap = /* @__PURE__ */ new Map();
/**
* Remove an event listener.
*
* @param name - The name of the event.
* @param callback - The callback to remove.
*
* @example
* ```ts
* events.off('my-event', myListener);
* ```
*
* @public
*/
// 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) {
return;
}
filterInPlace(eventRefs, (eventRef) => eventRef.callback !== callback);
if (eventRefs.length === 0) {
this.eventRefsMap.delete(name);
}
}
/**
* Remove an event listener by reference.
*
* @param eventRef - The reference to the event listener.
*
* @example
* ```ts
* events.offref(myRef);
* ```
*
* @public
*/
offref(eventRef) {
const eventRefs = this.eventRefsMap.get(eventRef.name);
if (!eventRefs) {
return;
}
filterInPlace(eventRefs, (storedEventRef) => storedEventRef !== eventRef);
if (eventRefs.length === 0) {
this.eventRefsMap.delete(eventRef.name);
}
}
/**
* Add an event listener.
*
* @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.
*
* @example
* ```ts
* events.on('my-event', async (arg1, arg2) => {
* await sleep(100);
* console.log(arg1, arg2);
* });
* ```
*
* @public
*/
// 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) {
eventRefs = [];
this.eventRefsMap.set(name, eventRefs);
}
const eventRef = {
asyncEvents: this,
callback,
name,
thisArg
};
eventRefs.push(eventRef);
return eventRef;
}
/**
* Add an event listener that will be triggered only 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.
*
* @example
* ```ts
* events.once('my-event', async (arg1, arg2) => {
* await sleep(100);
* console.log(arg1, arg2);
* });
* ```
*
* @public
*/
// 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, () => {
this.offref(originalEventRef);
this.offref(cleanupEventRef);
});
return originalEventRef;
}
/**
* Trigger an event, executing all the listeners in order even if some of them throw an error.
*
* @param name - The name of the event.
* @param args - The data to pass to the event listeners.
*
* @example
* ```ts
* events.trigger('my-event', 'arg1', 'arg2');
* ```
*
* @public
*/
// 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()) {
this.tryTrigger(eventRef, args);
}
}
/**
* Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
*
* @param name - The name of the event.
* @param args - The data to pass to the event listeners.
*
* @public
*/
// 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()) {
await this.tryTriggerAsync(eventRef, args);
}
}
/**
* Try to trigger an event, executing all the listeners in order even if some of them throw an error.
*
* @param eventRef - The event reference.
* @param args - The data to pass to the event listeners.
*
* @example
* ```ts
* events.tryTrigger(myRef, ['arg1', 'arg2']);
* ```
*
* @public
*/
// 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);
} catch (e) {
window.setTimeout(() => {
throw e;
}, 0);
}
}
/**
* Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
*
* @param eventRef - The event reference.
* @param args - The data to pass to the event listeners.
*
* @public
*/
// 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;
} catch (e) {
window.setTimeout(() => {
throw e;
}, 0);
}
}
}
export {
AsyncEvents
};
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/AsyncEvents.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Async event emitter.\n */\n\nimport type { Promisable } from 'type-fest';\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 = (...args: unknown[]) => Promisable<void>;\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\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<Args extends unknown[]>(name: string, callback: (...args: Args) => Promisable<void>): 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\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   * @public\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<Args extends unknown[]>(name: string, callback: (...args: Args) => Promisable<void>, 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   * @public\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<Args extends unknown[]>(name: string, callback: (...args: Args) => Promisable<void>, 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   * @public\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   * @public\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   * @public\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   * @public\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": []
}
