@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/esm/worker-protocol.d.mts

@@ -0,0 +1,282 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+/**
+ * @file
+ *
+ * The message protocol between `WorkerComponent` on the main thread and {@link exposeWorkerApi} inside a worker.
+ *
+ * This module imports nothing, so a worker entry point bundled by `@mnaoumov/obsidian-dev-toolkit`'s `workers` feature
+ * can import it: a worker has no `obsidian` module and no Node builtins. Its message shapes are a wire format between
+ * the plugin's main bundle and its worker bundle, which may come from different copies of this library, so fields are
+ * only ever added and a change of meaning moves to a new {@link WORKER_PROTOCOL} value.
+ */
+/**
+ * The tag every message of this protocol carries. Messages without it are ignored on both sides, so a worker can
+ * exchange its own messages too.
+ */
+export declare const WORKER_PROTOCOL = "obsidian-lib-worker-v1";
+/**
+ * An error reduced to plain data, because an `Error` loses its class across the worker boundary.
+ */
+export interface SerializedWorkerError {
+    /**
+     * The error message.
+     */
+    readonly message: string;
+    /**
+     * The error name.
+     */
+    readonly name: string;
+    /**
+     * The stack in the worker, when there was one.
+     */
+    readonly stack?: string;
+}
+/**
+ * A result marked to transfer some of its objects rather than copy them. Build it with {@link withTransfer}.
+ *
+ * @typeParam TValue - The value type.
+ */
+export interface TransferredValue<TValue> {
+    /**
+     * The marker that identifies the wrapper structurally, so a wrapper built by another copy of this library is
+     * recognized too.
+     */
+    readonly __obsidianLibTransferredValue: true;
+    /**
+     * The objects to transfer.
+     */
+    readonly transfer: readonly Transferable[];
+    /**
+     * The value.
+     */
+    readonly value: TValue;
+}
+/**
+ * A value split from its transfer list, ready to post.
+ */
+export interface UnwrappedTransferredValue {
+    /**
+     * The objects to transfer.
+     */
+    readonly transfer: Transferable[];
+    /**
+     * The value to post.
+     */
+    readonly value: unknown;
+}
+/**
+ * An API a worker exposes: an object whose every member is a function.
+ *
+ * @typeParam TApi - The API type.
+ */
+export type WorkerApi<TApi> = {
+    readonly [TMethod in keyof TApi]: (...parameters: never[]) => unknown;
+};
+/**
+ * The handlers implementing a {@link WorkerApi}, with the {@link WorkerCallContext} as `this`.
+ *
+ * Each handler takes the method's arguments and returns its result, or a promise of it, or the result wrapped by
+ * {@link withTransfer} to transfer buffers back instead of copying them. Declare the handlers as methods or `function`
+ * expressions, not arrow functions, when they need `this`.
+ *
+ * @typeParam TApi - The API type.
+ */
+export type WorkerApiHandlers<TApi extends WorkerApi<TApi>> = {
+    readonly [TMethod in keyof TApi]: (this: WorkerCallContext, ...parameters: Parameters<TApi[TMethod]>) => WorkerHandlerResult<Awaited<ReturnType<TApi[TMethod]>>>;
+};
+/**
+ * The context of one call, passed to a handler as `this`.
+ */
+export interface WorkerCallContext {
+    /**
+     * Aborted when the caller cancels the call. A long handler checks it between steps; nothing interrupts a synchronous
+     * loop, so a job that cannot check it is stopped only by terminating the worker.
+     */
+    readonly abortSignal: AbortSignal;
+}
+/**
+ * A call from the main thread.
+ */
+export interface WorkerCallMessage {
+    /**
+     * The method's arguments.
+     */
+    readonly arguments: readonly unknown[];
+    /**
+     * The call id, unique per `WorkerComponent`.
+     */
+    readonly id: number;
+    /**
+     * The message kind.
+     */
+    readonly kind: 'call';
+    /**
+     * The method name.
+     */
+    readonly method: string;
+    /**
+     * The protocol tag.
+     */
+    readonly protocol: typeof WORKER_PROTOCOL;
+}
+/**
+ * A cancellation of a call from the main thread.
+ */
+export interface WorkerCancelMessage {
+    /**
+     * The id of the call to cancel.
+     */
+    readonly id: number;
+    /**
+     * The message kind.
+     */
+    readonly kind: 'cancel';
+    /**
+     * The protocol tag.
+     */
+    readonly protocol: typeof WORKER_PROTOCOL;
+}
+/**
+ * A failed call, answered by the worker.
+ */
+export interface WorkerErrorMessage {
+    /**
+     * The error, reduced to plain data.
+     */
+    readonly error: SerializedWorkerError;
+    /**
+     * The id of the call.
+     */
+    readonly id: number;
+    /**
+     * The message kind.
+     */
+    readonly kind: 'error';
+    /**
+     * The protocol tag.
+     */
+    readonly protocol: typeof WORKER_PROTOCOL;
+}
+/**
+ * What a handler may return.
+ *
+ * @typeParam TResult - The method's result type.
+ */
+export type WorkerHandlerResult<TResult> = Promise<TransferredValue<TResult> | TResult> | TransferredValue<TResult> | TResult;
+/**
+ * The port a worker talks through: the worker's global scope, or a test double.
+ */
+export interface WorkerMessagePort {
+    /**
+     * Subscribes to messages.
+     *
+     * @param type - Always `message`.
+     * @param listener - The listener.
+     */
+    readonly addEventListener: (type: 'message', listener: ($event: MessageEvent<unknown>) => void) => void;
+    /**
+     * Posts a message.
+     *
+     * @param message - The message.
+     * @param transfer - The objects to transfer.
+     */
+    readonly postMessage: (message: unknown, transfer: Transferable[]) => void;
+}
+/**
+ * Any message sent to the worker.
+ */
+export type WorkerRequestMessage = WorkerCallMessage | WorkerCancelMessage;
+/**
+ * Any message sent by the worker.
+ */
+export type WorkerResponseMessage = WorkerErrorMessage | WorkerResultMessage;
+/**
+ * A successful call, answered by the worker.
+ */
+export interface WorkerResultMessage {
+    /**
+     * The id of the call.
+     */
+    readonly id: number;
+    /**
+     * The message kind.
+     */
+    readonly kind: 'result';
+    /**
+     * The protocol tag.
+     */
+    readonly protocol: typeof WORKER_PROTOCOL;
+    /**
+     * The result.
+     */
+    readonly value: unknown;
+}
+/**
+ * Exposes handlers to the main thread. Call it once, at the top level of a worker entry point.
+ *
+ * A handler that throws or rejects answers with a {@link SerializedWorkerError}, which the caller receives as a
+ * `WorkerCallError`. An unknown method answers with an error too, so a caller never waits for nothing.
+ *
+ * @typeParam TApi - The API type.
+ * @param handlers - The handlers.
+ * @param port - The port to talk through. Defaults to the worker's global scope.
+ */
+export declare function exposeWorkerApi<TApi extends WorkerApi<TApi>>(handlers: WorkerApiHandlers<TApi>, port?: WorkerMessagePort): void;
+/**
+ * Calls one handler by name, as the worker does. `WorkerComponent` uses it for its main-thread fallback, so both paths
+ * behave alike.
+ *
+ * @param handlers - The handlers.
+ * @param method - The method name.
+ * @param callArguments - The arguments.
+ * @param context - The call context.
+ * @returns The result, or a {@link TransferredValue} wrapping it.
+ */
+export declare function invokeWorkerHandler(handlers: object, method: string, callArguments: readonly unknown[], context: WorkerCallContext): Promise<unknown>;
+/**
+ * Tells whether a value is a {@link TransferredValue}.
+ *
+ * @param value - The value.
+ * @returns Whether it is one.
+ */
+export declare function isTransferredValue(value: unknown): value is TransferredValue<unknown>;
+/**
+ * Tells whether a message is a request of this protocol.
+ *
+ * @param message - The message.
+ * @returns Whether it is one.
+ */
+export declare function isWorkerRequestMessage(message: unknown): message is WorkerRequestMessage;
+/**
+ * Tells whether a message is a response of this protocol.
+ *
+ * @param message - The message.
+ * @returns Whether it is one.
+ */
+export declare function isWorkerResponseMessage(message: unknown): message is WorkerResponseMessage;
+/**
+ * Reduces a thrown value to plain data.
+ *
+ * @param error - The thrown value.
+ * @returns The serialized error.
+ */
+export declare function serializeWorkerError(error: unknown): SerializedWorkerError;
+/**
+ * Splits a result into the value to post and the objects to transfer.
+ *
+ * @param result - A result, possibly wrapped by {@link withTransfer}.
+ * @returns The value and its transfer list.
+ */
+export declare function unwrapTransferredValue(result: unknown): UnwrappedTransferredValue;
+/**
+ * Marks a result to transfer some of its objects (an `ArrayBuffer`, a `MessagePort`, an `OffscreenCanvas`...) instead
+ * of copying them. A transferred object is unusable on the sending side afterwards.
+ *
+ * @typeParam TValue - The value type.
+ * @param value - The value.
+ * @param transfer - The objects inside it to transfer.
+ * @returns The wrapped value.
+ */
+export declare function withTransfer<TValue>(value: TValue, transfer: readonly Transferable[]): TransferredValue<TValue>;

package/dist/lib/esm/worker-protocol.mjs

@@ -0,0 +1,113 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+const WORKER_PROTOCOL = "obsidian-lib-worker-v1";
+function exposeWorkerApi(handlers, port) {
+  const messagePort = port ?? getWorkerGlobalScope();
+  const abortControllers = /* @__PURE__ */ new Map();
+  messagePort.addEventListener("message", ($event) => {
+    const message = $event.data;
+    if (!isWorkerRequestMessage(message)) {
+      return;
+    }
+    if (message.kind === "cancel") {
+      abortControllers.get(message.id)?.abort(new Error("The call was cancelled"));
+      return;
+    }
+    const abortController = new AbortController();
+    abortControllers.set(message.id, abortController);
+    void answerCall(message, abortController.signal);
+  });
+  async function answerCall(message, abortSignal) {
+    let response;
+    try {
+      const value = await invokeWorkerHandler(handlers, message.method, message.arguments, { abortSignal });
+      response = { id: message.id, kind: "result", protocol: WORKER_PROTOCOL, value };
+    } catch (error) {
+      response = { error: serializeWorkerError(error), id: message.id, kind: "error", protocol: WORKER_PROTOCOL };
+    }
+    abortControllers.delete(message.id);
+    postResponse(messagePort, response);
+  }
+}
+async function invokeWorkerHandler(handlers, method, callArguments, context) {
+  const handler = Object.hasOwn(handlers, method) ? handlers[method] : void 0;
+  if (typeof handler !== "function") {
+    throw new TypeError(`The worker exposes no method named '${method}'`);
+  }
+  return await handler.apply(context, [...callArguments]);
+}
+function isTransferredValue(value) {
+  return typeof value === "object" && value !== null && value.__obsidianLibTransferredValue === true;
+}
+function isWorkerRequestMessage(message) {
+  if (!hasProtocol(message)) {
+    return false;
+  }
+  const candidate = message;
+  if (typeof candidate.id !== "number") {
+    return false;
+  }
+  if (candidate.kind === "cancel") {
+    return true;
+  }
+  return candidate.kind === "call" && typeof candidate.method === "string" && Array.isArray(candidate.arguments);
+}
+function isWorkerResponseMessage(message) {
+  if (!hasProtocol(message)) {
+    return false;
+  }
+  const candidate = message;
+  if (typeof candidate.id !== "number") {
+    return false;
+  }
+  if (candidate.kind === "result") {
+    return true;
+  }
+  return candidate.kind === "error" && typeof candidate.error === "object";
+}
+function serializeWorkerError(error) {
+  if (!(error instanceof Error)) {
+    return { message: String(error), name: "Error" };
+  }
+  return error.stack === void 0 ? { message: error.message, name: error.name } : { message: error.message, name: error.name, stack: error.stack };
+}
+function unwrapTransferredValue(result) {
+  return isTransferredValue(result) ? { transfer: [...result.transfer], value: result.value } : { transfer: [], value: result };
+}
+function withTransfer(value, transfer) {
+  return { __obsidianLibTransferredValue: true, transfer, value };
+}
+function getWorkerGlobalScope() {
+  const scope = globalThis;
+  return scope;
+}
+function hasProtocol(message) {
+  return typeof message === "object" && message !== null && message.protocol === WORKER_PROTOCOL;
+}
+function postResponse(port, response) {
+  if (response.kind === "error") {
+    port.postMessage(response, []);
+    return;
+  }
+  const { transfer, value } = unwrapTransferredValue(response.value);
+  try {
+    port.postMessage({ ...response, value }, transfer);
+  } catch (error) {
+    port.postMessage({ error: serializeWorkerError(error), id: response.id, kind: "error", protocol: WORKER_PROTOCOL }, []);
+  }
+}
+export {
+  WORKER_PROTOCOL,
+  exposeWorkerApi,
+  invokeWorkerHandler,
+  isTransferredValue,
+  isWorkerRequestMessage,
+  isWorkerResponseMessage,
+  serializeWorkerError,
+  unwrapTransferredValue,
+  withTransfer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/worker-protocol.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The message protocol between `WorkerComponent` on the main thread and {@link exposeWorkerApi} inside a worker.\n *\n * This module imports nothing, so a worker entry point bundled by `@mnaoumov/obsidian-dev-toolkit`'s `workers` feature\n * can import it: a worker has no `obsidian` module and no Node builtins. Its message shapes are a wire format between\n * the plugin's main bundle and its worker bundle, which may come from different copies of this library, so fields are\n * only ever added and a change of meaning moves to a new {@link WORKER_PROTOCOL} value.\n */\n\n/**\n * The tag every message of this protocol carries. Messages without it are ignored on both sides, so a worker can\n * exchange its own messages too.\n */\nexport const WORKER_PROTOCOL = 'obsidian-lib-worker-v1';\n\n/**\n * An error reduced to plain data, because an `Error` loses its class across the worker boundary.\n */\nexport interface SerializedWorkerError {\n  /**\n   * The error message.\n   */\n  readonly message: string;\n\n  /**\n   * The error name.\n   */\n  readonly name: string;\n\n  /**\n   * The stack in the worker, when there was one.\n   */\n  readonly stack?: string;\n}\n\n/**\n * A result marked to transfer some of its objects rather than copy them. Build it with {@link withTransfer}.\n *\n * @typeParam TValue - The value type.\n */\nexport interface TransferredValue<TValue> {\n  /**\n   * The marker that identifies the wrapper structurally, so a wrapper built by another copy of this library is\n   * recognized too.\n   */\n  readonly __obsidianLibTransferredValue: true;\n\n  /**\n   * The objects to transfer.\n   */\n  readonly transfer: readonly Transferable[];\n\n  /**\n   * The value.\n   */\n  readonly value: TValue;\n}\n\n/**\n * A value split from its transfer list, ready to post.\n */\nexport interface UnwrappedTransferredValue {\n  /**\n   * The objects to transfer.\n   */\n  readonly transfer: Transferable[];\n\n  /**\n   * The value to post.\n   */\n  readonly value: unknown;\n}\n\n/**\n * An API a worker exposes: an object whose every member is a function.\n *\n * @typeParam TApi - The API type.\n */\nexport type WorkerApi<TApi> = { readonly [TMethod in keyof TApi]: (...parameters: never[]) => unknown };\n\n/**\n * The handlers implementing a {@link WorkerApi}, with the {@link WorkerCallContext} as `this`.\n *\n * Each handler takes the method's arguments and returns its result, or a promise of it, or the result wrapped by\n * {@link withTransfer} to transfer buffers back instead of copying them. Declare the handlers as methods or `function`\n * expressions, not arrow functions, when they need `this`.\n *\n * @typeParam TApi - The API type.\n */\nexport type WorkerApiHandlers<TApi extends WorkerApi<TApi>> = {\n  readonly [TMethod in keyof TApi]: (\n    this: WorkerCallContext,\n    ...parameters: Parameters<TApi[TMethod]>\n  ) => WorkerHandlerResult<Awaited<ReturnType<TApi[TMethod]>>>;\n};\n\n/**\n * The context of one call, passed to a handler as `this`.\n */\nexport interface WorkerCallContext {\n  /**\n   * Aborted when the caller cancels the call. A long handler checks it between steps; nothing interrupts a synchronous\n   * loop, so a job that cannot check it is stopped only by terminating the worker.\n   */\n  readonly abortSignal: AbortSignal;\n}\n\n/**\n * A call from the main thread.\n */\nexport interface WorkerCallMessage {\n  /**\n   * The method's arguments.\n   */\n  readonly arguments: readonly unknown[];\n\n  /**\n   * The call id, unique per `WorkerComponent`.\n   */\n  readonly id: number;\n\n  /**\n   * The message kind.\n   */\n  readonly kind: 'call';\n\n  /**\n   * The method name.\n   */\n  readonly method: string;\n\n  /**\n   * The protocol tag.\n   */\n  readonly protocol: typeof WORKER_PROTOCOL;\n}\n\n/**\n * A cancellation of a call from the main thread.\n */\nexport interface WorkerCancelMessage {\n  /**\n   * The id of the call to cancel.\n   */\n  readonly id: number;\n\n  /**\n   * The message kind.\n   */\n  readonly kind: 'cancel';\n\n  /**\n   * The protocol tag.\n   */\n  readonly protocol: typeof WORKER_PROTOCOL;\n}\n\n/**\n * A failed call, answered by the worker.\n */\nexport interface WorkerErrorMessage {\n  /**\n   * The error, reduced to plain data.\n   */\n  readonly error: SerializedWorkerError;\n\n  /**\n   * The id of the call.\n   */\n  readonly id: number;\n\n  /**\n   * The message kind.\n   */\n  readonly kind: 'error';\n\n  /**\n   * The protocol tag.\n   */\n  readonly protocol: typeof WORKER_PROTOCOL;\n}\n\n/**\n * What a handler may return.\n *\n * @typeParam TResult - The method's result type.\n */\nexport type WorkerHandlerResult<TResult> = Promise<TransferredValue<TResult> | TResult> | TransferredValue<TResult> | TResult;\n\n/**\n * The port a worker talks through: the worker's global scope, or a test double.\n */\nexport interface WorkerMessagePort {\n  /**\n   * Subscribes to messages.\n   *\n   * @param type - Always `message`.\n   * @param listener - The listener.\n   */\n  readonly addEventListener: (type: 'message', listener: ($event: MessageEvent<unknown>) => void) => void;\n\n  /**\n   * Posts a message.\n   *\n   * @param message - The message.\n   * @param transfer - The objects to transfer.\n   */\n  readonly postMessage: (message: unknown, transfer: Transferable[]) => void;\n}\n\n/**\n * Any message sent to the worker.\n */\nexport type WorkerRequestMessage = WorkerCallMessage | WorkerCancelMessage;\n\n/**\n * Any message sent by the worker.\n */\nexport type WorkerResponseMessage = WorkerErrorMessage | WorkerResultMessage;\n\n/**\n * A successful call, answered by the worker.\n */\nexport interface WorkerResultMessage {\n  /**\n   * The id of the call.\n   */\n  readonly id: number;\n\n  /**\n   * The message kind.\n   */\n  readonly kind: 'result';\n\n  /**\n   * The protocol tag.\n   */\n  readonly protocol: typeof WORKER_PROTOCOL;\n\n  /**\n   * The result.\n   */\n  readonly value: unknown;\n}\n\ninterface ProtocolTaggedMessage {\n  readonly protocol?: unknown;\n}\n\n/**\n * Exposes handlers to the main thread. Call it once, at the top level of a worker entry point.\n *\n * A handler that throws or rejects answers with a {@link SerializedWorkerError}, which the caller receives as a\n * `WorkerCallError`. An unknown method answers with an error too, so a caller never waits for nothing.\n *\n * @typeParam TApi - The API type.\n * @param handlers - The handlers.\n * @param port - The port to talk through. Defaults to the worker's global scope.\n */\nexport function exposeWorkerApi<TApi extends WorkerApi<TApi>>(handlers: WorkerApiHandlers<TApi>, port?: WorkerMessagePort): void {\n  const messagePort = port ?? getWorkerGlobalScope();\n  const abortControllers = new Map<number, AbortController>();\n\n  messagePort.addEventListener('message', ($event): void => {\n    const message = $event.data;\n    if (!isWorkerRequestMessage(message)) {\n      return;\n    }\n\n    if (message.kind === 'cancel') {\n      abortControllers.get(message.id)?.abort(new Error('The call was cancelled'));\n      return;\n    }\n\n    const abortController = new AbortController();\n    abortControllers.set(message.id, abortController);\n    // eslint-disable-next-line no-void -- `answerCall` never rejects: it answers every failure as a message.\n    void answerCall(message, abortController.signal);\n  });\n\n  async function answerCall(message: WorkerCallMessage, abortSignal: AbortSignal): Promise<void> {\n    let response: WorkerResponseMessage;\n    try {\n      const value = await invokeWorkerHandler(handlers, message.method, message.arguments, { abortSignal });\n      response = { id: message.id, kind: 'result', protocol: WORKER_PROTOCOL, value };\n    } catch (error) {\n      response = { error: serializeWorkerError(error), id: message.id, kind: 'error', protocol: WORKER_PROTOCOL };\n    }\n    abortControllers.delete(message.id);\n    postResponse(messagePort, response);\n  }\n}\n\n/**\n * Calls one handler by name, as the worker does. `WorkerComponent` uses it for its main-thread fallback, so both paths\n * behave alike.\n *\n * @param handlers - The handlers.\n * @param method - The method name.\n * @param callArguments - The arguments.\n * @param context - The call context.\n * @returns The result, or a {@link TransferredValue} wrapping it.\n */\nexport async function invokeWorkerHandler(\n  handlers: object,\n  method: string,\n  callArguments: readonly unknown[],\n  context: WorkerCallContext\n): Promise<unknown> {\n  const handler = Object.hasOwn(handlers, method) ? (handlers as Record<string, unknown>)[method] : undefined;\n  if (typeof handler !== 'function') {\n    throw new TypeError(`The worker exposes no method named '${method}'`);\n  }\n  return await (handler as (this: WorkerCallContext, ...handlerArguments: unknown[]) => unknown).apply(context, [...callArguments]);\n}\n\n/**\n * Tells whether a value is a {@link TransferredValue}.\n *\n * @param value - The value.\n * @returns Whether it is one.\n */\nexport function isTransferredValue(value: unknown): value is TransferredValue<unknown> {\n  return typeof value === 'object' && value !== null && (value as Partial<TransferredValue<unknown>>).__obsidianLibTransferredValue === true;\n}\n\n/**\n * Tells whether a message is a request of this protocol.\n *\n * @param message - The message.\n * @returns Whether it is one.\n */\nexport function isWorkerRequestMessage(message: unknown): message is WorkerRequestMessage {\n  if (!hasProtocol(message)) {\n    return false;\n  }\n  const candidate = message as Partial<WorkerCallMessage> | Partial<WorkerCancelMessage>;\n  if (typeof candidate.id !== 'number') {\n    return false;\n  }\n  if (candidate.kind === 'cancel') {\n    return true;\n  }\n  return candidate.kind === 'call' && typeof candidate.method === 'string' && Array.isArray(candidate.arguments);\n}\n\n/**\n * Tells whether a message is a response of this protocol.\n *\n * @param message - The message.\n * @returns Whether it is one.\n */\nexport function isWorkerResponseMessage(message: unknown): message is WorkerResponseMessage {\n  if (!hasProtocol(message)) {\n    return false;\n  }\n  const candidate = message as Partial<WorkerErrorMessage> | Partial<WorkerResultMessage>;\n  if (typeof candidate.id !== 'number') {\n    return false;\n  }\n  if (candidate.kind === 'result') {\n    return true;\n  }\n  return candidate.kind === 'error' && typeof candidate.error === 'object';\n}\n\n/**\n * Reduces a thrown value to plain data.\n *\n * @param error - The thrown value.\n * @returns The serialized error.\n */\nexport function serializeWorkerError(error: unknown): SerializedWorkerError {\n  if (!(error instanceof Error)) {\n    return { message: String(error), name: 'Error' };\n  }\n  return error.stack === undefined\n    ? { message: error.message, name: error.name }\n    : { message: error.message, name: error.name, stack: error.stack };\n}\n\n/**\n * Splits a result into the value to post and the objects to transfer.\n *\n * @param result - A result, possibly wrapped by {@link withTransfer}.\n * @returns The value and its transfer list.\n */\nexport function unwrapTransferredValue(result: unknown): UnwrappedTransferredValue {\n  return isTransferredValue(result)\n    ? { transfer: [...result.transfer], value: result.value }\n    : { transfer: [], value: result };\n}\n\n/**\n * Marks a result to transfer some of its objects (an `ArrayBuffer`, a `MessagePort`, an `OffscreenCanvas`...) instead\n * of copying them. A transferred object is unusable on the sending side afterwards.\n *\n * @typeParam TValue - The value type.\n * @param value - The value.\n * @param transfer - The objects inside it to transfer.\n * @returns The wrapped value.\n */\nexport function withTransfer<TValue>(value: TValue, transfer: readonly Transferable[]): TransferredValue<TValue> {\n  return { __obsidianLibTransferredValue: true, transfer, value };\n}\n\nfunction getWorkerGlobalScope(): WorkerMessagePort {\n  // eslint-disable-next-line obsidianmd/no-global-this -- A worker has no `window`: its global scope is the port.\n  const scope: unknown = globalThis;\n  return scope as WorkerMessagePort;\n}\n\nfunction hasProtocol(message: unknown): boolean {\n  return typeof message === 'object' && message !== null && (message as ProtocolTaggedMessage).protocol === WORKER_PROTOCOL;\n}\n\nfunction postResponse(port: WorkerMessagePort, response: WorkerResponseMessage): void {\n  if (response.kind === 'error') {\n    port.postMessage(response, []);\n    return;\n  }\n  const { transfer, value } = unwrapTransferredValue(response.value);\n  try {\n    port.postMessage({ ...response, value }, transfer);\n  } catch (error) {\n    // A result that cannot be cloned (a function, a DOM node) still answers, so the caller is never left waiting.\n    port.postMessage({ error: serializeWorkerError(error), id: response.id, kind: 'error', protocol: WORKER_PROTOCOL }, []);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/obsidian-lib",
-  "version": "10.12.0",
+  "version": "11.0.0",
   "description": "Runtime library for Obsidian plugin development: plugin base classes, components, settings, modals, vault and metadata helpers.",
   "keywords": [
     "obsidian",
@@ -347,11 +347,13 @@
     "test": "jiti scripts/test.ts",
     "test:coverage": "jiti scripts/test-coverage.ts",
     "test:integration": "jiti scripts/test-integration.ts integration-tests obsidian-integration-tests",
+    "test:integration:android": "jiti scripts/test-integration.ts obsidian-integration-tests:android",
     "test:mutation": "jiti scripts/test-mutation.ts",
     "test:watch": "jiti scripts/test-watch.ts",
     "version": "jiti scripts/version.ts"
   },
   "overrides": {
+    "@mnaoumov/typescript-lib": "$@mnaoumov/typescript-lib",
     "@puppeteer/browsers": "^3.2.2",
     "@vitest/coverage-v8": "$@vitest/coverage-v8",
     "deepmerge-ts": "^8.0.2",
@@ -363,13 +365,12 @@
     "katex": "^0.18.2",
     "markdown-it@>=15.0.0": "^15.0.3",
     "moment": "^2.31.0",
-    "re2js": "^2.9.1",
     "smol-toml": "^1.8.0",
     "typescript": "$typescript"
   },
   "dependencies": {
     "@mnaoumov/obsidian-dataview": "^1.0.0",
-    "@mnaoumov/typescript-lib": "^2.0.0",
+    "@mnaoumov/typescript-lib": "^4.0.0",
     "@standard-schema/spec": "^1.1.0",
     "@types/react": "^19.3.0",
     "compare-versions": "^6.1.1",
@@ -391,10 +392,10 @@
     "@commitlint/cli": "^21.2.2",
     "@commitlint/config-conventional": "^21.2.2",
     "@lezer/common": "1.5.2",
-    "@mnaoumov/obsidian-dev-toolkit": "^8.2.1",
-    "@mnaoumov/typescript-dev-toolkit": "^6.1.0",
+    "@mnaoumov/obsidian-dev-toolkit": "^10.0.0",
+    "@mnaoumov/typescript-dev-toolkit": "^7.0.3",
     "@mnaoumov/typescript-test-toolkit": "^1.0.3",
-    "@obsidian-typings/obsidian-public-latest": "^6.59.0",
+    "@obsidian-typings/obsidian-public-latest": "^6.60.0",
     "@resvg/resvg-js": "^2.6.2",
     "@stryker-mutator/core": "^10.1.1",
     "@stryker-mutator/vitest-runner": "^10.1.1",
@@ -412,7 +413,7 @@
     "esbuild": "^0.28.2",
     "eslint": "^10.11.0",
     "eslint-plugin-jsdoc": "^64.5.4",
-    "eslint-plugin-obsidianmd": "^0.4.2",
+    "eslint-plugin-obsidianmd": "^0.5.1",
     "eslint-plugin-tsdoc": "^0.5.3",
     "fake-indexeddb": "^6.2.6",
     "fflate": "^0.8.3",
@@ -423,7 +424,7 @@
     "nano-staged": "^1.0.2",
     "obsidian": "^1.14.4",
     "obsidian-integration-testing": "^17.7.4",
-    "obsidian-test-mocks": "^7.2.3",
+    "obsidian-test-mocks": "^8.0.0",
     "prismjs": "^1.30.0",
     "sass": "^1.104.1",
     "satori": "^0.33.5",

package/plugin/third-party-plugin/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/plugin/third-party-plugin.cjs",
+  "module": "../../dist/lib/esm/plugin/third-party-plugin.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/plugin/third-party-plugin.d.cts"
+}