@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/plugin/plugin-api.d.cts

@@ -0,0 +1,413 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * A typed, versioned, lifecycle-aware registry for cross-plugin APIs — the advanced successor to
+ * `@vanakat/plugin-api`.
+ *
+ * A provider publishes its API once, under a contract version that is independent of its plugin version:
+ *
+ * ```ts
+ * publishPluginApi({
+ *   api: new MyApi(this),
+ *   apiVersion: '2.1.0',
+ *   contract: MY_API_CONTRACT_V2,
+ *   plugin: this
+ * });
+ * ```
+ *
+ * A consumer gets a LIVE REF whose {@link PluginApiRef.value} is always current — `null` before the
+ * provider loads, the API once it publishes, `null` again once it unloads, and the API again after a
+ * re-enable:
+ *
+ * ```ts
+ * const ref = watchPluginApi<MyApi>({
+ *   apiVersionRange: '^2',
+ *   app: this.app,
+ *   component: this,
+ *   pluginId: 'my-provider'
+ * });
+ *
+ * ref.value;                    // MyApi | null — sync, free, always correct
+ * await ref.whenAvailable();    // one-shot flows; rejects with a typed, classified error
+ * ref.on('change', () => { }); // for consumers that must REACT rather than read
+ * ```
+ *
+ * What this fixes, relative to publishing a bare object on `window.PluginApi`:
+ *
+ * - **Load order.** The ref subscribes; it does not sample. Reading `null` during `onload` means "not yet",
+ *   and it becomes non-`null` on its own.
+ * - **Version negotiation.** The provider declares a contract version; the consumer declares the range it
+ *   compiled against; the highest satisfying record wins.
+ * - **Stale handles.** The value is a revocable handle — after the provider unloads, a property read throws
+ *   a {@link PluginApiRevokedError} naming the provider instead of a null deref deep in someone else's stack.
+ * - **Free-string names.** Records are keyed by `plugin.manifest.id`, which Obsidian already keeps unique.
+ * - **Legible failure.** {@link PluginApiRef.whenAvailable} rejects with a
+ *   {@link PluginApiUnavailableError} carrying a {@link PluginApiUnavailabilityReason}, so the five distinct
+ *   causes are told apart.
+ *
+ * Payload validation is opt-in per method through {@link https://standardschema.dev | Standard Schema}, so
+ * zod / valibot / arktype / a hand-written validator all plug in and none of them is a dependency here. It
+ * runs only while the `obsidian-dev-utils:PluginApi` debugger is enabled, so production pays nothing.
+ *
+ * @remarks
+ * Every plugin bundles its OWN copy of `obsidian-dev-utils`, so a registry record is a wire format between
+ * different library versions and must stay backward-compatible forever. Nothing crossing it may be
+ * `instanceof`-checked — reads are structural, and only plain data objects and plain functions are stored.
+ *
+ * That wire format is also PUBLISHED, as of the `Plugin API protocol` guide: a plugin that does not use
+ * this library reaches an API by reading
+ * `globalThis.__obsidianDevUtils.pluginApiRegistry.value.records[pluginId]` and applying the selection rule
+ * {@link selectRecord} implements. So {@link PublishedPluginApiRecord}'s field names, the state key, and
+ * "highest live record satisfying the range wins" are a documented contract with an audience outside this
+ * repository, and the guide has to be updated in the same change as any of them. Only `pluginApiRegistry`
+ * is public within the shared-state bag; the rest of it stays internal.
+ */
+import type { AsyncEventSource } from '@mnaoumov/typescript-lib/async-events' with { 'resolution-mode': 'import' };
+import type { StandardSchemaV1 } from '@standard-schema/spec' with { 'resolution-mode': 'import' };
+import type { App, Component, Plugin } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Which half of a method call a validation failure came from.
+ */
+export declare enum PluginApiPayloadKind {
+    /**
+     * The method's arguments.
+     */
+    Input = "input",
+    /**
+     * The method's return value.
+     */
+    Output = "output"
+}
+/**
+ * The reason a plugin API could not be handed over.
+ *
+ * The whole point of the enum is that these are told apart. `@vanakat/plugin-api` cannot tell any of them
+ * apart, and not uniformly: `NotInstalled` / `NotEnabled` / `NotPublished` all reduce to one `Notice` plus
+ * `undefined`, while `VersionMismatch` / `ShapeMismatch` produce NO signal at all — it never examines what it
+ * found, so it hands the object over and the mismatch surfaces later, somewhere else, as somebody else's
+ * `TypeError`.
+ *
+ * @remarks
+ * {@link PluginApiRef.whenAvailable} can report the first five; {@link PluginApiUnavailabilityReason.Revoked}
+ * is not one of them, because it describes a handle that WAS valid and is carried by
+ * {@link PluginApiRevokedError} instead.
+ */
+export declare enum PluginApiUnavailabilityReason {
+    /**
+     * The plugin is installed but not enabled.
+     */
+    NotEnabled = "notEnabled",
+    /**
+     * The plugin is not installed in this vault.
+     */
+    NotInstalled = "notInstalled",
+    /**
+     * The plugin is installed and enabled but has not published any API.
+     */
+    NotPublished = "notPublished",
+    /**
+     * The handle was valid but the provider has since unloaded, so it has been revoked.
+     */
+    Revoked = "revoked",
+    /**
+     * A record satisfies the requested version range, but the API object is missing a method the contract
+     * declares — the provider's shipped shape and its declared shape disagree.
+     */
+    ShapeMismatch = "shapeMismatch",
+    /**
+     * The plugin published an API, but no published contract version satisfies the requested range.
+     */
+    VersionMismatch = "versionMismatch"
+}
+/**
+ * The contract a provider declares for its API: every key is a method the API is promising to expose, and
+ * its value optionally carries the payload schemas for that method.
+ *
+ * The KEYS are the part that always matters — they drive the shape check that decides whether a published
+ * record is usable at all. The schemas are optional and only ever consulted while debugging.
+ *
+ * @remarks
+ * Why the shape check is a `typeof` rather than a schema over the whole API object. In zod 4 `z.function()`
+ * returns a function FACTORY, not a schema, so it cannot be a `z.object()` member directly. There is a known
+ * workaround (zod#4143) — `z.custom((fn) => functionSchema.implement(fn))` — and it does buy correct
+ * `z.infer` types for a function member. It does not buy runtime validation here, though: `z.custom` is a
+ * boolean predicate that returns its input unchanged, so the validating wrapper `implement` builds is
+ * discarded and the check collapses back to "is it callable". Keeping that wrapper would need a further
+ * `.transform()`, and would then move validation onto every call instead of behind the debug gate, and bind
+ * the contract to zod specifically — which is exactly what reaching through Standard Schema avoids. So the
+ * declared method names are checked with `typeof`, and the payloads are validated per method instead.
+ */
+export type PluginApiContract = Record<string, PluginApiMethodContract>;
+/**
+ * One API a plugin exposes: the object, the contract version it satisfies, and optionally the contract
+ * itself. This is {@link PublishPluginApiParams} without the publishing plugin, so a plugin can DECLARE what
+ * it exposes without also stating who is publishing it — which is what lets `PluginBase.getPluginApis` collect
+ * the declarations and do the publishing itself.
+ *
+ * @typeParam TApi - The API type being declared.
+ */
+export interface PluginApiDeclaration<TApi extends object = object> {
+    /**
+     * The API object to publish. Its methods are handed to consumers through a revocable handle, and they are
+     * always invoked with this object as their `this`, so an implementation using private class fields keeps
+     * working.
+     */
+    readonly api: TApi;
+    /**
+     * The CONTRACT version, in semver form — independent of the plugin's own version. Plugin `1.4.7` may
+     * perfectly well expose API `2.0.0`.
+     */
+    readonly apiVersion: string;
+    /**
+     * The contract this version of the API satisfies. Optional: when omitted, no shape check is performed on
+     * the provider's behalf and the consumer's own contract (if any) is used instead.
+     */
+    readonly contract?: PluginApiContract;
+}
+/**
+ * The payload schemas for a single API method. Both halves are optional: a method may declare only its input,
+ * only its output, neither (the entry then just declares that the method must exist), or both.
+ */
+export interface PluginApiMethodContract {
+    /**
+     * Validates the method's arguments, as an array.
+     */
+    readonly input?: StandardSchemaV1;
+    /**
+     * Validates the method's return value — or, when the method returns a thenable, the value it resolves to.
+     */
+    readonly output?: StandardSchemaV1;
+}
+/**
+ * A live reference to another plugin's API.
+ *
+ * @typeParam TApi - The API type the consumer compiled against.
+ *
+ * @remarks
+ * The ref is the WHOLE consumer surface, deliberately. A plain {@link Promise} cannot model this because it
+ * settles once, whereas availability is a repeating signal (available → gone → available again across a
+ * disable/enable cycle) — which is why {@link PluginApiRef.whenAvailable} is a method ON the ref rather than
+ * the thing handed back. The `change` event exists for consumers that must react rather than read, and is
+ * secondary: it imposes no ceremony on the common case, which is reading {@link PluginApiRef.value}.
+ */
+export interface PluginApiRef<TApi extends object> extends AsyncEventSource<PluginApiRefEventMap> {
+    /**
+     * The API, or `null` when it is not currently available.
+     *
+     * Always current, synchronous, and free — the ref maintains it, so there is no registry lookup per read.
+     * `null` here means "not available right now", NOT "not installed": during a consumer's `onload` the
+     * provider may simply not have loaded yet, and the value becomes non-`null` on its own.
+     */
+    readonly value: null | TApi;
+    /**
+     * Waits for the API to become available.
+     *
+     * @param options - The options for the wait.
+     * @returns A {@link Promise} that resolves with the API.
+     * @throws A {@link PluginApiUnavailableError} whose {@link PluginApiUnavailableError.reason} says which of
+     * the five failures occurred, if the API does not become available before the timeout elapses.
+     */
+    whenAvailable: (options?: WhenAvailablePluginApiOptions) => Promise<TApi>;
+}
+/**
+ * The events a {@link PluginApiRef} fires.
+ */
+export interface PluginApiRefEventMap {
+    /**
+     * Fired whenever {@link PluginApiRef.value} changes — including when it becomes `null` because the provider
+     * unloaded.
+     */
+    change: [];
+}
+/**
+ * Parameters for the {@link PluginApiUnavailableError} constructor.
+ */
+export interface PluginApiUnavailableErrorConstructorParams {
+    /**
+     * An explicit message. When omitted, one is derived from the plugin id and the reason.
+     */
+    readonly message?: string;
+    /**
+     * The `manifest.id` of the plugin whose API was requested.
+     */
+    readonly pluginId: string;
+    /**
+     * Which of the five failures occurred.
+     */
+    readonly reason: PluginApiUnavailabilityReason;
+}
+/**
+ * Parameters for the {@link PluginApiValidationError} constructor.
+ */
+export interface PluginApiValidationErrorConstructorParams {
+    /**
+     * The issues the schema reported.
+     */
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    /**
+     * The name of the method whose payload failed validation.
+     */
+    readonly methodName: string;
+    /**
+     * Whether the input or the output failed.
+     */
+    readonly payloadKind: PluginApiPayloadKind;
+    /**
+     * The `manifest.id` of the providing plugin.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Parameters for {@link publishPluginApi}.
+ *
+ * @typeParam TApi - The API type being published.
+ */
+export interface PublishPluginApiParams<TApi extends object> extends PluginApiDeclaration<TApi> {
+    /**
+     * The component whose unload revokes the record. Defaults to {@link PublishPluginApiParams.plugin}, which is
+     * the right owner for an API published for as long as the plugin runs.
+     *
+     * Pass a narrower one when the API is only valid for part of the plugin's life — a plugin whose feature
+     * surface is torn down and rebuilt while the plugin itself stays loaded must revoke with the surface, or it
+     * leaves consumers holding handles into code that is no longer there.
+     */
+    readonly component?: Component;
+    /**
+     * The publishing plugin. The record is keyed by its `manifest.id` and revoked automatically when the plugin
+     * unloads, via `plugin.register()`.
+     */
+    readonly plugin: Plugin;
+}
+/**
+ * Parameters for {@link watchPluginApi}.
+ */
+export interface WatchPluginApiParams {
+    /**
+     * The semver range of contract versions the consumer compiled against, e.g. `'^2'`. The highest published
+     * version satisfying it wins.
+     *
+     * @remarks
+     * The range is evaluated by `compare-versions`, which accepts `^`, `~`, comparison operators, and `x`
+     * wildcards — but NOT a bare `*`. Spell "any version" as `'>=0.0.0'`.
+     */
+    readonly apiVersionRange: string;
+    /**
+     * The Obsidian app instance, used to classify a failure as not-installed vs not-enabled.
+     */
+    readonly app: App;
+    /**
+     * The component owning the subscription. The watch is torn down when it unloads.
+     */
+    readonly component: Component;
+    /**
+     * The contract the CONSUMER expects. Optional, and it wins over the provider's published contract when
+     * supplied — it is the consumer's own compiled-against expectation, so it is the one whose violation is
+     * the consumer's problem.
+     */
+    readonly contract?: PluginApiContract;
+    /**
+     * The `manifest.id` of the providing plugin.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Options for {@link PluginApiRef.whenAvailable}.
+ */
+export interface WhenAvailablePluginApiOptions {
+    /**
+     * How long to wait before giving up and classifying the failure.
+     *
+     * @default 10000
+     */
+    readonly timeoutInMilliseconds?: number;
+}
+/**
+ * Thrown when a plugin API cannot be handed over, carrying the {@link PluginApiUnavailabilityReason} that says
+ * why.
+ */
+export declare class PluginApiUnavailableError extends Error {
+    /**
+     * The `manifest.id` of the plugin whose API was requested.
+     */
+    readonly pluginId: string;
+    /**
+     * Which of the five failures occurred.
+     */
+    readonly reason: PluginApiUnavailabilityReason;
+    /**
+     * Creates a {@link PluginApiUnavailableError}.
+     *
+     * @param params - The parameters for the error.
+     */
+    constructor(params: PluginApiUnavailableErrorConstructorParams);
+}
+/**
+ * Thrown when a property is read from a handle whose provider has since unloaded.
+ *
+ * This is the point of handing out a revocable handle rather than the raw object: a consumer that cached the
+ * API in a field and kept using it across a disable gets an error naming the provider, instead of
+ * `Cannot read properties of undefined` somewhere deep inside a torn-down plugin.
+ */
+export declare class PluginApiRevokedError extends PluginApiUnavailableError {
+    /**
+     * Creates a {@link PluginApiRevokedError}.
+     *
+     * @param pluginId - The `manifest.id` of the plugin whose API was revoked.
+     */
+    constructor(pluginId: string);
+}
+/**
+ * Thrown when a published API's payload fails the schema its contract declares.
+ *
+ * Only ever thrown while the `obsidian-dev-utils:PluginApi` debugger is enabled — in production the methods
+ * are not wrapped at all.
+ */
+export declare class PluginApiValidationError extends Error {
+    /**
+     * The issues the schema reported.
+     */
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    /**
+     * The name of the method whose payload failed validation.
+     */
+    readonly methodName: string;
+    /**
+     * The `manifest.id` of the providing plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * Creates a {@link PluginApiValidationError}.
+     *
+     * @param params - The parameters for the error.
+     */
+    constructor(params: PluginApiValidationErrorConstructorParams);
+}
+/**
+ * Publishes a plugin's API so other plugins can consume it, keyed by the plugin's `manifest.id` and revoked
+ * automatically when the plugin unloads.
+ *
+ * Several contract versions may be published side by side, so a provider can move to `2.0.0` without breaking
+ * consumers still pinned to `^1`.
+ *
+ * @typeParam TApi - The API type being published.
+ * @param params - The parameters for publishing.
+ * @throws An {@link Error} if this plugin has already published this exact `apiVersion`.
+ */
+export declare function publishPluginApi<TApi extends object>(params: PublishPluginApiParams<TApi>): void;
+/**
+ * Watches another plugin's API and returns a live {@link PluginApiRef} whose {@link PluginApiRef.value} stays
+ * correct across the provider's load, unload, and re-enable.
+ *
+ * This is the entire consumer surface. There is deliberately no synchronous "get it or `null`" probe: a probe
+ * only answers "now" and never tells you when "now" changed, so calling one during `onload` reads `null` and
+ * invites the conclusion "not installed". A consumer that needs a synchronous answer inside a callback whose
+ * signature forbids `await` — `checkCallback(isChecking): boolean`, `canExecute()`, a settings-row `visible`
+ * predicate — holds the ref (or the value it maintains) in a field and reads that, which is both cheaper and
+ * correct across BOTH edges.
+ *
+ * @typeParam TApi - The API type the consumer compiled against.
+ * @param params - The parameters for the watch.
+ * @returns The live reference.
+ */
+export declare function watchPluginApi<TApi extends object>(params: WatchPluginApiParams): PluginApiRef<TApi>;

package/dist/lib/cjs/plugin/plugin-context.cjs

@@ -0,0 +1,215 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  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 = 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 = 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);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        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);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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 plugin_context_exports = {};
+__export(plugin_context_exports, {
+  addPluginCssClasses: () => addPluginCssClasses,
+  initDebugController: () => initDebugController,
+  initPluginContext: () => initPluginContext
+});
+module.exports = __toCommonJS(plugin_context_exports);
+var import_abort_controller = require('@mnaoumov/typescript-lib/abort-controller');
+var import_debug = require('@mnaoumov/typescript-lib/debug');
+var import_library = require('@mnaoumov/typescript-lib/library');
+var import_css_class = require('../css-class.cjs');
+var import_generated_during_build = require('../generated-during-build.cjs');
+var import_library_styles = require('../library-styles.cjs');
+var import_library2 = require('../library.cjs');
+var import_obsidian_dev_utils_state = require('../obsidian-dev-utils-state.cjs');
+const DEBUG_GUIDE_URL = "https://mnaoumov.dev/obsidian-dev-utils/guides/debugging/";
+function addPluginCssClasses(element, cssClasses) {
+  const extraCssClasses = typeof cssClasses === "string" ? [cssClasses] : cssClasses ?? [];
+  element.addClass(
+    import_css_class.CssClass.LibraryName,
+    ...import_library2.ObsidianLibrary.cssClassScope ? [import_library2.ObsidianLibrary.cssClassScope] : [],
+    ...extraCssClasses
+  );
+}
+function initDebugController(win, component) {
+  const pluginContextWindow = win;
+  const oldDebug = pluginContextWindow.DEBUG;
+  const newDebug = (0, import_debug.getDebugController)();
+  pluginContextWindow.DEBUG = newDebug;
+  component.register(() => {
+    if (pluginContextWindow.DEBUG === newDebug) {
+      pluginContextWindow.DEBUG = oldDebug;
+    }
+  });
+}
+function initPluginContext(pluginId) {
+  import_library2.ObsidianLibrary.init({ cssClassScope: pluginId });
+  import_library.Library.init({
+    debugGuideUrl: DEBUG_GUIDE_URL,
+    debugNamespace: import_library2.OBSIDIAN_LIBRARY_NAME,
+    debugPrefixNamespace: `${pluginId}:`,
+    shouldPrintStackTrace: true
+  });
+  (0, import_debug.showInitialDebugMessage)(pluginId);
+  (0, import_abort_controller.getSharedAbortController)();
+  (0, import_obsidian_dev_utils_state.shareTypescriptLibStateWithObsidianDevUtilsState)();
+  (0, import_library_styles.injectLibraryStyles)({
+    doc: document,
+    libraryStyles: import_generated_during_build.LIBRARY_STYLES,
+    libraryVersion: import_generated_during_build.LIBRARY_VERSION
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addPluginCssClasses,
+  initDebugController,
+  initPluginContext
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3BsdWdpbi9wbHVnaW4tY29udGV4dC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEluaXRpYWxpemVzIHRoZSBwbHVnaW4gY29udGV4dCBhbmQgc2V0cyB1cCB0aGUgcGx1Z2luIElELlxuICovXG5cbmltcG9ydCB0eXBlIHsgRGVidWdDb250cm9sbGVyIH0gZnJvbSAnQG1uYW91bW92L3R5cGVzY3JpcHQtbGliL2RlYnVnLWNvbnRyb2xsZXInO1xuaW1wb3J0IHR5cGUgeyBDb21wb25lbnQgfSBmcm9tICdvYnNpZGlhbic7XG5cbmltcG9ydCB7IGdldFNoYXJlZEFib3J0Q29udHJvbGxlciB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi9hYm9ydC1jb250cm9sbGVyJztcbmltcG9ydCB7XG4gIGdldERlYnVnQ29udHJvbGxlcixcbiAgc2hvd0luaXRpYWxEZWJ1Z01lc3NhZ2Vcbn0gZnJvbSAnQG1uYW91bW92L3R5cGVzY3JpcHQtbGliL2RlYnVnJztcbmltcG9ydCB7IExpYnJhcnkgfSBmcm9tICdAbW5hb3Vtb3YvdHlwZXNjcmlwdC1saWIvbGlicmFyeSc7XG5cbmltcG9ydCB7IENzc0NsYXNzIH0gZnJvbSAnLi4vY3NzLWNsYXNzLnRzJztcbmltcG9ydCB7XG4gIExJQlJBUllfU1RZTEVTLFxuICBMSUJSQVJZX1ZFUlNJT05cbn0gZnJvbSAnLi4vZ2VuZXJhdGVkLWR1cmluZy1idWlsZC50cyc7XG5pbXBvcnQgeyBpbmplY3RMaWJyYXJ5U3R5bGVzIH0gZnJvbSAnLi4vbGlicmFyeS1zdHlsZXMudHMnO1xuaW1wb3J0IHtcbiAgT0JTSURJQU5fTElCUkFSWV9OQU1FLFxuICBPYnNpZGlhbkxpYnJhcnlcbn0gZnJvbSAnLi4vbGlicmFyeS50cyc7XG5pbXBvcnQgeyBzaGFyZVR5cGVzY3JpcHRMaWJTdGF0ZVdpdGhPYnNpZGlhbkRldlV0aWxzU3RhdGUgfSBmcm9tICcuLi9vYnNpZGlhbi1kZXYtdXRpbHMtc3RhdGUudHMnO1xuXG5pbnRlcmZhY2UgUGx1Z2luQ29udGV4dFdpbmRvdyB7XG4gIERFQlVHOiBEZWJ1Z0NvbnRyb2xsZXIgfCB1bmRlZmluZWQ7XG59XG5cbmNvbnN0IERFQlVHX0dVSURFX1VSTCA9ICdodHRwczovL21uYW91bW92LmRldi9vYnNpZGlhbi1kZXYtdXRpbHMvZ3VpZGVzL2RlYnVnZ2luZy8nO1xuXG4vKipcbiAqIFNldHMgdGhlIENTUyBjbGFzcyBvZiBhbiBlbGVtZW50LlxuICpcbiAqIEBwYXJhbSBlbGVtZW50IC0gVGhlIGVsZW1lbnQgdG8gc2V0IHRoZSBDU1MgY2xhc3Mgb2YuXG4gKiBAcGFyYW0gY3NzQ2xhc3NlcyAtIFRoZSBDU1MgY2xhc3NlcyB0byBzZXQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhZGRQbHVnaW5Dc3NDbGFzc2VzKGVsZW1lbnQ6IEhUTUxFbGVtZW50LCBjc3NDbGFzc2VzPzogc3RyaW5nIHwgc3RyaW5nW10pOiB2b2lkIHtcbiAgY29uc3QgZXh0cmFDc3NDbGFzc2VzID0gdHlwZW9mIGNzc0NsYXNzZXMgPT09ICdzdHJpbmcnID8gW2Nzc0NsYXNzZXNdIDogY3NzQ2xhc3NlcyA/PyBbXTtcbiAgZWxlbWVudC5hZGRDbGFzcyhcbiAgICBDc3NDbGFzcy5MaWJyYXJ5TmFtZSxcbiAgICAvLyBUaGUgc2NvcGUgaXMgZW1wdHkgdW50aWwgdGhlIHBsdWdpbiBjb250ZXh0IGlzIGluaXRpYWxpemVkOyBza2lwIGl0IHNvIHdlIG5ldmVyIGFkZCBhbiBlbXB0eSBjbGFzcy5cbiAgICAuLi4oT2JzaWRpYW5MaWJyYXJ5LmNzc0NsYXNzU2NvcGUgPyBbT2JzaWRpYW5MaWJyYXJ5LmNzc0NsYXNzU2NvcGVdIDogW10pLFxuICAgIC4uLmV4dHJhQ3NzQ2xhc3Nlc1xuICApO1xufVxuXG4vKipcbiAqIEluaXRpYWxpemVzIHRoZSBkZWJ1ZyBjb250cm9sbGVyLlxuICpcbiAqIEBwYXJhbSB3aW4gLSBUaGUgd2luZG93IHRvIGluaXRpYWxpemUgdGhlIGRlYnVnIGNvbnRyb2xsZXIgZm9yLlxuICogQHBhcmFtIGNvbXBvbmVudCAtIFRoZSBjb21wb25lbnQgdG8gcmVnaXN0ZXIgY2xlYW51cCBvbi5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGluaXREZWJ1Z0NvbnRyb2xsZXIod2luOiBXaW5kb3csIGNvbXBvbmVudDogQ29tcG9uZW50KTogdm9pZCB7XG4gIGNvbnN0IHBsdWdpbkNvbnRleHRXaW5kb3cgPSB3aW4gYXMgUGFydGlhbDxQbHVnaW5Db250ZXh0V2luZG93PjtcbiAgY29uc3Qgb2xkRGVidWcgPSBwbHVnaW5Db250ZXh0V2luZG93LkRFQlVHO1xuICBjb25zdCBuZXdEZWJ1ZyA9IGdldERlYnVnQ29udHJvbGxlcigpO1xuICBwbHVnaW5Db250ZXh0V2luZG93LkRFQlVHID0gbmV3RGVidWc7XG5cbiAgY29tcG9uZW50LnJlZ2lzdGVyKCgpID0+IHtcbiAgICBpZiAocGx1Z2luQ29udGV4dFdpbmRvdy5ERUJVRyA9PT0gbmV3RGVidWcpIHtcbiAgICAgIHBsdWdpbkNvbnRleHRXaW5kb3cuREVCVUcgPSBvbGREZWJ1ZztcbiAgICB9XG4gIH0pO1xufVxuXG4vKipcbiAqIEluaXRpYWxpemVzIHRoZSBwbHVnaW4gY29udGV4dC5cbiAqXG4gKiBAcGFyYW0gcGx1Z2luSWQgLSBUaGUgcGx1Z2luIElELlxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5pdFBsdWdpbkNvbnRleHQocGx1Z2luSWQ6IHN0cmluZyk6IHZvaWQge1xuICBPYnNpZGlhbkxpYnJhcnkuaW5pdCh7IGNzc0NsYXNzU2NvcGU6IHBsdWdpbklkIH0pO1xuICBMaWJyYXJ5LmluaXQoe1xuICAgIGRlYnVnR3VpZGVVcmw6IERFQlVHX0dVSURFX1VSTCxcbiAgICBkZWJ1Z05hbWVzcGFjZTogT0JTSURJQU5fTElCUkFSWV9OQU1FLFxuICAgIGRlYnVnUHJlZml4TmFtZXNwYWNlOiBgJHtwbHVnaW5JZH06YCxcbiAgICBzaG91bGRQcmludFN0YWNrVHJhY2U6IHRydWVcbiAgfSk7XG4gIHNob3dJbml0aWFsRGVidWdNZXNzYWdlKHBsdWdpbklkKTtcblxuICAvLyBOb3RoaW5nIGVsc2UgaW4gdGhlIGxpYnJhcnkgcmVhY2hlcyBmb3IgdGhlIHNoYXJlZCBhYm9ydCBjb250cm9sbGVyIC0tIG9ubHkgY29uc3VtZXIgcGx1Z2lucyBkby4gQ3JlYXRlXG4gIC8vIGl0IGhlcmUgc28gYF9fb2JzaWRpYW5EZXZVdGlscy5zaGFyZWRBYm9ydENvbnRyb2xsZXIudmFsdWUuYWJvcnQoKWAgYWx3YXlzIHJlc29sdmVzIGluIHRoZSBkZXZ0b29sc1xuICAvLyBjb25zb2xlLCBpbnN0ZWFkIG9mIHRocm93aW5nIHVudGlsIHNvbWUgcGx1Z2luIGhhcHBlbnMgdG8gc3RhcnQgYW4gYWJvcnRhYmxlIG9wZXJhdGlvbi5cbiAgZ2V0U2hhcmVkQWJvcnRDb250cm9sbGVyKCk7XG5cbiAgLy8gVGhlIGRlYnVnZ2VycywgdGhlIGBkZWJ1Z2AgaW5zdGFuY2UgYW5kIHRoZSBzaGFyZWQgYWJvcnQgY29udHJvbGxlciBtb3ZlZCBvdXQgb2YgYF9fb2JzaWRpYW5EZXZVdGlsc2AuIExpbmsgdGhlbVxuICAvLyBiYWNrLCBzbyBwbHVnaW5zIGJ1bmRsaW5nIGFuIG9sZGVyIGNvcHkgb2YgdGhpcyBsaWJyYXJ5IHNoYXJlIHRoZW0sIGFuZCB0aGUgZGV2dG9vbHMgbGluZSBhYm92ZSBrZWVwcyB3b3JraW5nLlxuICBzaGFyZVR5cGVzY3JpcHRMaWJTdGF0ZVdpdGhPYnNpZGlhbkRldlV0aWxzU3RhdGUoKTtcblxuICBpbmplY3RMaWJyYXJ5U3R5bGVzKHtcbiAgICBkb2M6IGRvY3VtZW50LFxuICAgIGxpYnJhcnlTdHlsZXM6IExJQlJBUllfU1RZTEVTLFxuICAgIGxpYnJhcnlWZXJzaW9uOiBMSUJSQVJZX1ZFUlNJT05cbiAgfSk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVNBLDhCQUF5QztBQUN6QyxtQkFHTztBQUNQLHFCQUF3QjtBQUV4Qix1QkFBeUI7QUFDekIsb0NBR087QUFDUCw0QkFBb0M7QUFDcEMsSUFBQUEsa0JBR087QUFDUCxzQ0FBaUU7QUFNakUsTUFBTSxrQkFBa0I7QUFRakIsU0FBUyxvQkFBb0IsU0FBc0IsWUFBc0M7QUFDOUYsUUFBTSxrQkFBa0IsT0FBTyxlQUFlLFdBQVcsQ0FBQyxVQUFVLElBQUksY0FBYyxDQUFDO0FBQ3ZGLFVBQVE7QUFBQSxJQUNOLDBCQUFTO0FBQUEsSUFFVCxHQUFJLGdDQUFnQixnQkFBZ0IsQ0FBQyxnQ0FBZ0IsYUFBYSxJQUFJLENBQUM7QUFBQSxJQUN2RSxHQUFHO0FBQUEsRUFDTDtBQUNGO0FBUU8sU0FBUyxvQkFBb0IsS0FBYSxXQUE0QjtBQUMzRSxRQUFNLHNCQUFzQjtBQUM1QixRQUFNLFdBQVcsb0JBQW9CO0FBQ3JDLFFBQU0sZUFBVyxpQ0FBbUI7QUFDcEMsc0JBQW9CLFFBQVE7QUFFNUIsWUFBVSxTQUFTLE1BQU07QUFDdkIsUUFBSSxvQkFBb0IsVUFBVSxVQUFVO0FBQzFDLDBCQUFvQixRQUFRO0FBQUEsSUFDOUI7QUFBQSxFQUNGLENBQUM7QUFDSDtBQU9PLFNBQVMsa0JBQWtCLFVBQXdCO0FBQ3hELGtDQUFnQixLQUFLLEVBQUUsZUFBZSxTQUFTLENBQUM7QUFDaEQseUJBQVEsS0FBSztBQUFBLElBQ1gsZUFBZTtBQUFBLElBQ2YsZ0JBQWdCO0FBQUEsSUFDaEIsc0JBQXNCLEdBQUcsUUFBUTtBQUFBLElBQ2pDLHVCQUF1QjtBQUFBLEVBQ3pCLENBQUM7QUFDRCw0Q0FBd0IsUUFBUTtBQUtoQyx3REFBeUI7QUFJekIsd0ZBQWlEO0FBRWpELGlEQUFvQjtBQUFBLElBQ2xCLEtBQUs7QUFBQSxJQUNMLGVBQWU7QUFBQSxJQUNmLGdCQUFnQjtBQUFBLEVBQ2xCLENBQUM7QUFDSDsiLAogICJuYW1lcyI6IFsiaW1wb3J0X2xpYnJhcnkiXQp9Cg==

package/dist/lib/cjs/plugin/plugin-context.d.cts

@@ -0,0 +1,27 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Initializes the plugin context and sets up the plugin ID.
+ */
+import type { Component } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Sets the CSS class of an element.
+ *
+ * @param element - The element to set the CSS class of.
+ * @param cssClasses - The CSS classes to set.
+ */
+export declare function addPluginCssClasses(element: HTMLElement, cssClasses?: string | string[]): void;
+/**
+ * Initializes the debug controller.
+ *
+ * @param win - The window to initialize the debug controller for.
+ * @param component - The component to register cleanup on.
+ */
+export declare function initDebugController(win: Window, component: Component): void;
+/**
+ * Initializes the plugin context.
+ *
+ * @param pluginId - The plugin ID.
+ */
+export declare function initPluginContext(pluginId: string): void;