@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/async-with-notice.cjs

@@ -0,0 +1,235 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var async_with_notice_exports = {};
+__export(async_with_notice_exports, {
+  retryWithTimeoutNotice: () => retryWithTimeoutNotice,
+  runWithTimeoutNotice: () => runWithTimeoutNotice
+});
+module.exports = __toCommonJS(async_with_notice_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_debug = require('@mnaoumov/typescript-lib/debug');
+var import_value_provider = require('@mnaoumov/typescript-lib/value-provider');
+var import_i18n = require('./i18n/i18n.cjs');
+async function retryWithTimeoutNotice(params) {
+  return (0, import_async.retryWithTimeout)({
+    ...params,
+    onTimeout: resolveOnTimeout(params.shouldShowTimeoutNotice, params.pluginNoticeComponent, params.content)
+  });
+}
+async function runWithTimeoutNotice(params) {
+  return (0, import_async.runWithTimeout)({
+    ...params,
+    onTimeout: resolveOnTimeout(params.shouldShowTimeoutNotice, params.pluginNoticeComponent, params.content)
+  });
+}
+function onTimeoutNotice(context, pluginNoticeComponent, content) {
+  if (content !== void 0) {
+    showCustomContentNotice(context, pluginNoticeComponent, content);
+    return;
+  }
+  const startTime = Math.trunc(performance.now() - context.duration);
+  let runningTimeEl;
+  const SECOND_IN_MILLISECONDS = 1e3;
+  const cleanup = { intervalId: 0 };
+  const notice = pluginNoticeComponent.showNotice(createFragment((f) => {
+    if (context.operationName) {
+      f.appendText((0, import_i18n.t)(($) => $.obsidianDevUtils.asyncWithNotice.operation));
+      f.appendText(": ");
+      f.appendText(context.operationName);
+      f.createEl("br");
+    }
+    f.appendText((0, import_i18n.t)(($) => $.obsidianDevUtils.asyncWithNotice.timedOut, { duration: context.duration }));
+    f.createEl("br");
+    f.appendText((0, import_i18n.t)(($) => $.obsidianDevUtils.asyncWithNotice.runningFor));
+    f.appendText(" ");
+    runningTimeEl = f.createSpan();
+    f.appendText(" ");
+    f.appendText((0, import_i18n.t)(($) => $.obsidianDevUtils.asyncWithNotice.milliseconds));
+    f.createEl("br");
+    f.appendText((0, import_i18n.t)(($) => $.obsidianDevUtils.asyncWithNotice.terminateOperation));
+    f.createEl("br");
+    const button = f.createEl("button", {
+      text: (0, import_i18n.t)(($) => $.obsidianDevUtils.buttons.cancel)
+    });
+    button.addEventListener("click", () => {
+      context.terminateOperation();
+      window.clearInterval(cleanup.intervalId);
+      notice.hide();
+    });
+  }));
+  updateRunningTime();
+  cleanup.intervalId = window.setInterval(updateRunningTime, SECOND_IN_MILLISECONDS);
+  context.onOperationCompleted(() => {
+    window.clearInterval(cleanup.intervalId);
+    notice.hide();
+  });
+  function updateRunningTime() {
+    const runningTimeInMilliseconds = Math.max(context.duration, Math.round((performance.now() - startTime) / SECOND_IN_MILLISECONDS) * SECOND_IN_MILLISECONDS);
+    runningTimeEl.textContent = String(runningTimeInMilliseconds);
+  }
+}
+function onTimeoutWithoutNotice(context) {
+  const startTime = Math.trunc(performance.now() - context.duration);
+  context.onOperationCompleted(() => {
+    (0, import_debug.getDebugger)("AsyncWithNotice:onTimeoutWithoutNotice")("Operation completed after timeout", {
+      operationName: context.operationName,
+      totalDuration: Math.trunc(performance.now() - startTime)
+    });
+  });
+}
+function resolveOnTimeout(shouldShowTimeoutNotice, pluginNoticeComponent, content) {
+  return !(shouldShowTimeoutNotice ?? true) || pluginNoticeComponent === null ? onTimeoutWithoutNotice : (context) => {
+    onTimeoutNotice(context, pluginNoticeComponent, content);
+  };
+}
+function showCustomContentNotice(context, pluginNoticeComponent, content) {
+  let isOperationCompleted = false;
+  let notice = null;
+  context.onOperationCompleted(() => {
+    isOperationCompleted = true;
+    notice?.hide();
+  });
+  (0, import_async.invokeAsyncSafely)(async () => {
+    const resolvedContent = await (0, import_value_provider.resolveValue)(content, {});
+    if (isOperationCompleted) {
+      return;
+    }
+    notice = pluginNoticeComponent.showNotice(resolvedContent, { isPermanent: true });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  retryWithTimeoutNotice,
+  runWithTimeoutNotice
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/async-with-notice.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Provides a utility to execute an asynchronous function with a notice.\n */\n\nimport type {\n  RetryOptions,\n  TimeoutContext\n} from '@mnaoumov/typescript-lib/async';\nimport type { ValueProvider } from '@mnaoumov/typescript-lib/value-provider';\nimport type { Notice } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  invokeAsyncSafely,\n  retryWithTimeout,\n  runWithTimeout\n} from '@mnaoumov/typescript-lib/async';\nimport { getDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { resolveValue } from '@mnaoumov/typescript-lib/value-provider';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { t } from './i18n/i18n.ts';\n\n/**\n * Options for {@link retryWithTimeoutNotice}.\n */\nexport interface RetryWithTimeoutNoticeParams {\n  /**\n   * Custom content to show in the notice instead of the default timed-out message. Resolved only if\n   * the operation exceeds the timeout, shown as a permanent notice, and hidden when the operation\n   * completes.\n   */\n  readonly content?: ValueProvider<DocumentFragment | string>;\n\n  /**\n   * The operation function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<boolean>;\n\n  /**\n   * The name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Plugin notice component used to show the timeout notice. When `null` (or `shouldShowTimeoutNotice`\n   * is `false`), no notice is shown and the timeout is only logged.\n   */\n  readonly pluginNoticeComponent: null | PluginNoticeComponent;\n\n  /**\n   * The retry options.\n   */\n  readonly retryOptions?: RetryOptions;\n\n  /**\n   * Whether to show a timeout notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n}\n\n/**\n * Options for {@link runWithTimeout}.\n *\n * @typeParam Result - The type of the result from the operation function.\n */\nexport interface RunWithTimeoutNoticeParams<Result> {\n  /**\n   * Custom content to show in the notice instead of the default timed-out message. Resolved only if\n   * the operation exceeds {@link RunWithTimeoutNoticeParams.timeoutInMilliseconds}, shown as a\n   * permanent notice, and hidden when the operation completes.\n   */\n  readonly content?: ValueProvider<DocumentFragment | string>;\n\n  /**\n   * The context of the function.\n   */\n  readonly context?: unknown;\n\n  /**\n   * The operation function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<Result>;\n\n  /**\n   * The name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Plugin notice component used to show the timeout notice. When `null` (or `shouldShowTimeoutNotice`\n   * is `false`), no notice is shown and the timeout is only logged.\n   */\n  readonly pluginNoticeComponent: null | PluginNoticeComponent;\n\n  /**\n   * Whether to show a timeout notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The maximum time to wait in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Retries the provided function until it returns `true` or the timeout is reached and displays a notice if the function times out.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves when the function returns `true` or rejects when the timeout is reached.\n */\nexport async function retryWithTimeoutNotice(params: RetryWithTimeoutNoticeParams): Promise<void> {\n  return retryWithTimeout({\n    ...params,\n    onTimeout: resolveOnTimeout(params.shouldShowTimeoutNotice, params.pluginNoticeComponent, params.content)\n  });\n}\n\n/**\n * Executes a function with a timeout and displays a notice if the function times out.\n *\n * @typeParam Result - The type of the result from the asynchronous function.\n * @param params - The parameters for the function.\n * @returns The result of the function.\n */\nexport async function runWithTimeoutNotice<Result>(params: RunWithTimeoutNoticeParams<Result>): Promise<Result> {\n  return runWithTimeout({\n    ...params,\n    onTimeout: resolveOnTimeout(params.shouldShowTimeoutNotice, params.pluginNoticeComponent, params.content)\n  });\n}\n\nfunction onTimeoutNotice(context: TimeoutContext, pluginNoticeComponent: PluginNoticeComponent, content?: ValueProvider<DocumentFragment | string>): void {\n  if (content !== undefined) {\n    showCustomContentNotice(context, pluginNoticeComponent, content);\n    return;\n  }\n\n  const startTime = Math.trunc(performance.now() - context.duration);\n  let runningTimeEl: HTMLSpanElement;\n  const SECOND_IN_MILLISECONDS = 1000;\n  const cleanup = { intervalId: 0 };\n\n  const notice = pluginNoticeComponent.showNotice(createFragment((f) => {\n    if (context.operationName) {\n      f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.operation));\n      f.appendText(': ');\n      f.appendText(context.operationName);\n      f.createEl('br');\n    }\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.timedOut, { duration: context.duration }));\n    f.createEl('br');\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.runningFor));\n    f.appendText(' ');\n    runningTimeEl = f.createSpan();\n    f.appendText(' ');\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.milliseconds));\n    f.createEl('br');\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.terminateOperation));\n    f.createEl('br');\n    const button = f.createEl('button', {\n      text: t(($) => $.obsidianDevUtils.buttons.cancel)\n    });\n    button.addEventListener('click', () => {\n      context.terminateOperation();\n      window.clearInterval(cleanup.intervalId);\n      notice.hide();\n    });\n  }));\n\n  updateRunningTime();\n  cleanup.intervalId = window.setInterval(updateRunningTime, SECOND_IN_MILLISECONDS);\n\n  context.onOperationCompleted(() => {\n    window.clearInterval(cleanup.intervalId);\n    notice.hide();\n  });\n\n  function updateRunningTime(): void {\n    const runningTimeInMilliseconds = Math.max(context.duration, Math.round((performance.now() - startTime) / SECOND_IN_MILLISECONDS) * SECOND_IN_MILLISECONDS);\n    runningTimeEl.textContent = String(runningTimeInMilliseconds);\n  }\n}\n\nfunction onTimeoutWithoutNotice(context: TimeoutContext): void {\n  const startTime = Math.trunc(performance.now() - context.duration);\n\n  context.onOperationCompleted(() => {\n    getDebugger('AsyncWithNotice:onTimeoutWithoutNotice')('Operation completed after timeout', {\n      operationName: context.operationName,\n      totalDuration: Math.trunc(performance.now() - startTime)\n    });\n  });\n}\n\n/**\n * Selects the timeout handler for {@link retryWithTimeoutNotice} / {@link runWithTimeoutNotice}. A notice\n * is shown only when notices are enabled AND a real {@link PluginNoticeComponent} is supplied; otherwise\n * the timeout is silently logged.\n *\n * @param shouldShowTimeoutNotice - Whether a timeout notice is requested (defaults to `true`).\n * @param pluginNoticeComponent - The component used to show the notice, if any.\n * @param content - Optional custom content for the notice.\n * @returns The timeout handler to pass to the underlying retry/run helper.\n */\nfunction resolveOnTimeout(\n  shouldShowTimeoutNotice: boolean | undefined,\n  pluginNoticeComponent: null | PluginNoticeComponent,\n  content?: ValueProvider<DocumentFragment | string>\n): (context: TimeoutContext) => void {\n  return !(shouldShowTimeoutNotice ?? true) || pluginNoticeComponent === null\n    ? onTimeoutWithoutNotice\n    : (context): void => {\n      onTimeoutNotice(context, pluginNoticeComponent, content);\n    };\n}\n\nfunction showCustomContentNotice(context: TimeoutContext, pluginNoticeComponent: PluginNoticeComponent, content: ValueProvider<DocumentFragment | string>): void {\n  let isOperationCompleted = false;\n  let notice: Notice | null = null;\n\n  context.onOperationCompleted(() => {\n    isOperationCompleted = true;\n    notice?.hide();\n  });\n\n  invokeAsyncSafely(async () => {\n    const resolvedContent = await resolveValue(content, {});\n    // The operation may have completed while the content was resolving; if so, do not show a stale notice.\n    if (isOperationCompleted) {\n      return;\n    }\n    notice = pluginNoticeComponent.showNotice(resolvedContent, { isPermanent: true });\n  });\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/async-with-notice.d.cts

@@ -0,0 +1,113 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Provides a utility to execute an asynchronous function with a notice.
+ */
+import type { RetryOptions } from '@mnaoumov/typescript-lib/async' with { 'resolution-mode': 'import' };
+import type { ValueProvider } from '@mnaoumov/typescript-lib/value-provider' with { 'resolution-mode': 'import' };
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
+import type { PluginNoticeComponent } from './components/plugin-notice-component.cjs';
+/**
+ * Options for {@link retryWithTimeoutNotice}.
+ */
+export interface RetryWithTimeoutNoticeParams {
+    /**
+     * Custom content to show in the notice instead of the default timed-out message. Resolved only if
+     * the operation exceeds the timeout, shown as a permanent notice, and hidden when the operation
+     * completes.
+     */
+    readonly content?: ValueProvider<DocumentFragment | string>;
+    /**
+     * The operation function to execute.
+     *
+     * @param abortSignal - The abort signal to listen to.
+     * @returns The result of the function.
+     */
+    readonly operationFunction: (abortSignal: AbortSignal) => Promisable<boolean>;
+    /**
+     * The name of the operation.
+     */
+    readonly operationName?: string;
+    /**
+     * Plugin notice component used to show the timeout notice. When `null` (or `shouldShowTimeoutNotice`
+     * is `false`), no notice is shown and the timeout is only logged.
+     */
+    readonly pluginNoticeComponent: null | PluginNoticeComponent;
+    /**
+     * The retry options.
+     */
+    readonly retryOptions?: RetryOptions;
+    /**
+     * Whether to show a timeout notice.
+     *
+     * @default `true`
+     */
+    readonly shouldShowTimeoutNotice?: boolean;
+    /**
+     * The stack trace of the source function.
+     */
+    readonly stackTrace?: string;
+}
+/**
+ * Options for {@link runWithTimeout}.
+ *
+ * @typeParam Result - The type of the result from the operation function.
+ */
+export interface RunWithTimeoutNoticeParams<Result> {
+    /**
+     * Custom content to show in the notice instead of the default timed-out message. Resolved only if
+     * the operation exceeds {@link RunWithTimeoutNoticeParams.timeoutInMilliseconds}, shown as a
+     * permanent notice, and hidden when the operation completes.
+     */
+    readonly content?: ValueProvider<DocumentFragment | string>;
+    /**
+     * The context of the function.
+     */
+    readonly context?: unknown;
+    /**
+     * The operation function to execute.
+     *
+     * @param abortSignal - The abort signal to listen to.
+     * @returns The result of the function.
+     */
+    readonly operationFunction: (abortSignal: AbortSignal) => Promisable<Result>;
+    /**
+     * The name of the operation.
+     */
+    readonly operationName?: string;
+    /**
+     * Plugin notice component used to show the timeout notice. When `null` (or `shouldShowTimeoutNotice`
+     * is `false`), no notice is shown and the timeout is only logged.
+     */
+    readonly pluginNoticeComponent: null | PluginNoticeComponent;
+    /**
+     * Whether to show a timeout notice.
+     *
+     * @default `true`
+     */
+    readonly shouldShowTimeoutNotice?: boolean;
+    /**
+     * The stack trace of the source function.
+     */
+    readonly stackTrace?: string;
+    /**
+     * The maximum time to wait in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * Retries the provided function until it returns `true` or the timeout is reached and displays a notice if the function times out.
+ *
+ * @param params - The parameters for the function.
+ * @returns A {@link Promise} that resolves when the function returns `true` or rejects when the timeout is reached.
+ */
+export declare function retryWithTimeoutNotice(params: RetryWithTimeoutNoticeParams): Promise<void>;
+/**
+ * Executes a function with a timeout and displays a notice if the function times out.
+ *
+ * @typeParam Result - The type of the result from the asynchronous function.
+ * @param params - The parameters for the function.
+ * @returns The result of the function.
+ */
+export declare function runWithTimeoutNotice<Result>(params: RunWithTimeoutNoticeParams<Result>): Promise<Result>;