@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/cjs/path-compatibility.d.cts

@@ -0,0 +1,263 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Which naming constraints each platform imposes, which of them a given path violates, and how to repair a
+ * name so it satisfies every enabled platform at once.
+ *
+ * Pure by design — no `App`, no vault, no I/O — so the whole correctness surface (byte counting, extension
+ * preservation, truncation order, profile composition) is unit-testable without an Obsidian instance. The
+ * vault pass that consumes it lives in each plugin that reports or repairs path problems.
+ *
+ * A vault is synced, so the platform that matters is not necessarily the one running: enabling several
+ * platforms composes their constraints by intersection, and a name has to satisfy all of them.
+ */
+/**
+ * A platform a vault may be synced to, and whose naming rules can therefore be enforced.
+ */
+export declare enum PathCompatibilityPlatform {
+    Android = "Android",
+    Ios = "Ios",
+    Linux = "Linux",
+    MacOs = "MacOs",
+    Windows = "Windows"
+}
+/**
+ * What a single path or name is wrong about, on one platform.
+ */
+export declare enum PathCompatibilityViolationType {
+    ForbiddenCharacter = "ForbiddenCharacter",
+    NameTooLong = "NameTooLong",
+    /**
+     * The name holds a character Obsidian links do not work with (`#`, `^`, `[`, `]`, `|`). Obsidian's rule, not
+     * a platform's: the filesystem stores such a name fine, so naming a platform for it would be false.
+     */
+    ObsidianForbiddenCharacter = "ObsidianForbiddenCharacter",
+    PathTooLong = "PathTooLong",
+    ReservedName = "ReservedName",
+    TrailingCharacter = "TrailingCharacter",
+    /**
+     * The name is stored on disk in a form other than Unicode NFC, e.g. `й` as `и` followed by a combining
+     * breve. Not a platform's rule but a sync hazard: tools outside Obsidian see the two forms as two names.
+     */
+    UnicodeNotNormalized = "UnicodeNotNormalized"
+}
+/**
+ * Parameters for {@link findPathCompatibilityViolations}.
+ */
+export interface FindPathCompatibilityViolationsParams {
+    /**
+     * Whether the path names a folder, which has its own path budget.
+     */
+    readonly isFolder: boolean;
+    /**
+     * The length of the longest vault root path the vault is expected to live under, in characters.
+     *
+     * The vault root of a platform the check is not running on is unknowable, so it is stated rather than
+     * guessed — see the `maxVaultRootPathLength` setting.
+     */
+    readonly maxVaultRootPathLength: number;
+    /**
+     * The vault-relative path to check.
+     */
+    readonly path: string;
+    /**
+     * The platforms whose rules to enforce.
+     */
+    readonly platforms: readonly PathCompatibilityPlatform[];
+}
+/**
+ * A length a path or name was measured at, and the limit it exceeds.
+ */
+export interface PathCompatibilityMeasurement {
+    /**
+     * Whether both numbers count UTF-8 bytes rather than UTF-16 units.
+     */
+    readonly isInBytes: boolean;
+    /**
+     * The measured length.
+     */
+    readonly length: number;
+    /**
+     * The largest length the platform accepts.
+     */
+    readonly limit: number;
+    /**
+     * The vault root length counted into {@link PathCompatibilityMeasurement.length}, before the separator
+     * after it. `null` for a name, which carries no root.
+     */
+    readonly vaultRootLength: null | number;
+}
+/**
+ * The naming rules of one platform.
+ */
+export interface PathCompatibilityProfile {
+    /**
+     * Whether this platform applies Windows' naming rules: its forbidden characters, its reserved device
+     * names, and its rejection of trailing dots and spaces.
+     *
+     * One flag for three rules because they are one filesystem's rules, and no platform adopts a subset.
+     */
+    readonly hasWindowsNamingRules: boolean;
+    /**
+     * The longest absolute path a file may have, in this profile's unit.
+     */
+    readonly maxFilePathLength: number;
+    /**
+     * The longest absolute path a folder may have, in this profile's unit.
+     *
+     * Below {@link PathCompatibilityProfile.maxFilePathLength} on Windows, where the shorter budget leaves
+     * room for an `8.3` name inside the folder.
+     */
+    readonly maxFolderPathLength: number;
+    /**
+     * The longest single name — one path segment — in this profile's unit.
+     */
+    readonly maxNameLength: number;
+    /**
+     * The platform this profile describes.
+     */
+    readonly platform: PathCompatibilityPlatform;
+    /**
+     * Whether lengths count UTF-8 bytes (ext4, APFS) rather than UTF-16 units (NTFS).
+     *
+     * This is the whole reason the 255 limit is not a character count: a name of 128 CJK characters is 384
+     * bytes and is rejected by ext4 while being nowhere near any limit Windows has.
+     */
+    readonly shouldMeasureInBytes: boolean;
+}
+/**
+ * One thing wrong with one path, and the platform that objects to it.
+ */
+export interface PathCompatibilityViolation {
+    /**
+     * The offending characters, each once, in the order they first appear in the name.
+     *
+     * Set for {@link PathCompatibilityViolationType.ForbiddenCharacter} and
+     * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter}, so the report can name them.
+     */
+    readonly characters?: readonly string[];
+    /**
+     * What was measured and the limit it was measured against.
+     *
+     * Set for {@link PathCompatibilityViolationType.NameTooLong} and
+     * {@link PathCompatibilityViolationType.PathTooLong}, so a reader of the report can verify the verdict.
+     */
+    readonly measurement?: PathCompatibilityMeasurement;
+    /**
+     * The platform whose rules the path breaks. Another enabled platform may accept the very same path.
+     *
+     * `null` for a violation no single platform owns, which is
+     * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter} and
+     * {@link PathCompatibilityViolationType.UnicodeNotNormalized}.
+     */
+    readonly platform: null | PathCompatibilityPlatform;
+    /**
+     * What is wrong.
+     */
+    readonly type: PathCompatibilityViolationType;
+}
+/**
+ * Parameters for {@link repairName}.
+ */
+export interface RepairNameParams {
+    /**
+     * The name without its extension. For a folder, the whole name.
+     */
+    readonly basename: string;
+    /**
+     * The name's extension, without the leading dot. Empty for a folder or an extension-less file.
+     */
+    readonly extension: string;
+    /**
+     * What each forbidden character is replaced with. Empty deletes it. Must pass
+     * {@link getForbiddenCharacterReplacementValidationMessage}, or the repair would put back what it removed.
+     */
+    readonly forbiddenCharacterReplacement: string;
+    /**
+     * Whether the name belongs to a folder.
+     */
+    readonly isFolder: boolean;
+    /**
+     * The length of the longest vault root path the vault is expected to live under, in characters.
+     */
+    readonly maxVaultRootPathLength: number;
+    /**
+     * The vault-relative path of the parent folder. Empty at the vault root.
+     */
+    readonly parentPath: string;
+    /**
+     * The platforms whose rules the repaired name must satisfy.
+     */
+    readonly platforms: readonly PathCompatibilityPlatform[];
+}
+/**
+ * Every platform, in the order the settings tab and the consistency report list them: the ones whose limits
+ * actually bind in practice first.
+ */
+export declare const PATH_COMPATIBILITY_PLATFORMS: readonly PathCompatibilityPlatform[];
+/**
+ * How each platform is named in the settings tab and the consistency report.
+ *
+ * Not translated: these are product names, and `macOS` is spelled `macOS` in every language.
+ */
+export declare const PATH_COMPATIBILITY_PLATFORM_LABELS: Record<PathCompatibilityPlatform, string>;
+/**
+ * Finds everything wrong with a path, across every enabled platform.
+ *
+ * Read-only: this is what the consistency report renders, and it never proposes a repair.
+ *
+ * @param params - The path and the platforms to check it against.
+ * @returns The violations, empty when the path is valid everywhere.
+ */
+export declare function findPathCompatibilityViolations(params: FindPathCompatibilityViolationsParams): PathCompatibilityViolation[];
+/**
+ * The platform the plugin is running on, or `null` on a platform with no profile.
+ *
+ * Used only to seed the settings defaults, so that a fresh install reports on the vault in front of it
+ * without the user configuring anything first.
+ *
+ * @returns The current platform, or `null`.
+ */
+export declare function getCurrentPathCompatibilityPlatform(): null | PathCompatibilityPlatform;
+/**
+ * Validates the text a forbidden character is replaced with.
+ *
+ * Every platform's set is checked, not only the enabled ones: the toggles can change after the replacement
+ * is chosen, and a replacement one platform refuses would make the repair of that platform produce a name
+ * that is still invalid there.
+ *
+ * @param replacement - The replacement text. Empty is valid and deletes the character.
+ * @returns A message naming the first refused character, or an empty string when the replacement is valid.
+ */
+export declare function getForbiddenCharacterReplacementValidationMessage(replacement: string): string;
+/**
+ * Whether a name is in Unicode NFC, the form Obsidian gives every name it creates.
+ *
+ * @param name - The name as it is stored on disk.
+ * @returns Whether it is NFC.
+ */
+export declare function isUnicodeNormalized(name: string): boolean;
+/**
+ * Measures a string the way a filesystem does.
+ *
+ * @param $string - The string to measure.
+ * @param shouldMeasureInBytes - Whether to count UTF-8 bytes rather than UTF-16 units.
+ * @returns The length.
+ */
+export declare function measure($string: string, shouldMeasureInBytes: boolean): number;
+/**
+ * Repairs a name so that it satisfies every enabled platform.
+ *
+ * The order is deliberate: characters are replaced and a reserved name de-reserved BEFORE anything is
+ * truncated, because both can change the length, and trailing dots and spaces are trimmed AFTER every cut,
+ * because a cut can expose new ones.
+ *
+ * Truncation only ever shortens the basename — an extension is what tells Obsidian and the OS what the file
+ * is, so a truncated one turns a working `.png` into a broken `.pn`.
+ *
+ * @param params - The name and the platforms it must satisfy.
+ * @returns The repaired name, unchanged when it was already valid, or `null` when no name survives the
+ * repair — which is what the report calls out rather than failing silently.
+ */
+export declare function repairName(params: RepairNameParams): null | string;

package/dist/lib/cjs/path-settings.cjs

@@ -118,9 +118,9 @@ __export(path_settings_exports, {
   pathsValidator: () => pathsValidator
 });
 module.exports = __toCommonJS(path_settings_exports);
-var import_reg_exp = require('@mnaoumov/typescript-lib/reg-exp');
-var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
-var import_i18n = require('./i18n/i18n.cjs');
+var import_reg_exp = require("@mnaoumov/typescript-lib/reg-exp");
+var import_type_guards = require("@mnaoumov/typescript-lib/type-guards");
+var import_i18n = require("./i18n/i18n.cjs");
 const REG_EXP_ENTRY_REG_EXP = /^\/.*\/[a-z]*$/s;
 const CASE_INSENSITIVE_FLAG = "i";
 const STATEFUL_FLAGS_REG_EXP = /[gy]/g;

package/dist/lib/cjs/pdf.cjs

@@ -117,8 +117,8 @@ __export(pdf_exports, {
   printToPdf: () => printToPdf
 });
 module.exports = __toCommonJS(pdf_exports);
-var import_html_element = require('@mnaoumov/typescript-lib/html-element');
-var import_obsidian = require('obsidian');
+var import_html_element = require("@mnaoumov/typescript-lib/html-element");
+var import_obsidian = require("obsidian");
 const ELECTRON_PRINT_TO_PDF_CHANNEL = "print-to-pdf";
 async function printToPdf(element, options) {
   if (import_obsidian.Platform.isMobile) {

package/dist/lib/cjs/plugin/index.cjs

@@ -106,19 +106,21 @@ __export(plugin_exports, {
   "plugin-instance": () => plugin_instance,
   "plugin-lifecycle-events": () => plugin_lifecycle_events,
   "plugin-settings-tab": () => plugin_settings_tab,
-  "settings-migration-api": () => settings_migration_api
+  "settings-migration-api": () => settings_migration_api,
+  "third-party-plugin": () => third_party_plugin
 });
 module.exports = __toCommonJS(plugin_exports);
-var plugin_api = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-api.cjs')), 1);
-var plugin_async_cleanup = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-async-cleanup.cjs')), 1);
-var plugin_context = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-context.cjs')), 1);
-var plugin_event_source = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-event-source.cjs')), 1);
-var plugin_install_state = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-install-state.cjs')), 1);
-var plugin_instance = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-instance.cjs')), 1);
-var plugin_lifecycle_events = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-lifecycle-events.cjs')), 1);
-var plugin_settings_tab = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin-settings-tab.cjs')), 1);
-var plugin = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./plugin.cjs')), 1);
-var settings_migration_api = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./settings-migration-api.cjs')), 1);
+var plugin_api = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-api.cjs")), 1);
+var plugin_async_cleanup = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-async-cleanup.cjs")), 1);
+var plugin_context = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-context.cjs")), 1);
+var plugin_event_source = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-event-source.cjs")), 1);
+var plugin_install_state = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-install-state.cjs")), 1);
+var plugin_instance = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-instance.cjs")), 1);
+var plugin_lifecycle_events = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-lifecycle-events.cjs")), 1);
+var plugin_settings_tab = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin-settings-tab.cjs")), 1);
+var plugin = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./plugin.cjs")), 1);
+var settings_migration_api = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./settings-migration-api.cjs")), 1);
+var third_party_plugin = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./third-party-plugin.cjs")), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   plugin,
@@ -130,6 +132,7 @@ var settings_migration_api = __toESM(((module) => module && module.__esModule &&
   "plugin-instance": null,
   "plugin-lifecycle-events": null,
   "plugin-settings-tab": null,
-  "settings-migration-api": null
+  "settings-migration-api": null,
+  "third-party-plugin": null
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wbHVnaW4vaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdwbHVnaW4tYXBpJyBmcm9tICcuL3BsdWdpbi1hcGkudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1hc3luYy1jbGVhbnVwJyBmcm9tICcuL3BsdWdpbi1hc3luYy1jbGVhbnVwLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4taW5zdGFsbC1zdGF0ZScgZnJvbSAnLi9wbHVnaW4taW5zdGFsbC1zdGF0ZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWluc3RhbmNlJyBmcm9tICcuL3BsdWdpbi1pbnN0YW5jZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWxpZmVjeWNsZS1ldmVudHMnIGZyb20gJy4vcGx1Z2luLWxpZmVjeWNsZS1ldmVudHMudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy10YWInIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLXRhYi50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luJyBmcm9tICcuL3BsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc2V0dGluZ3MtbWlncmF0aW9uLWFwaScgZnJvbSAnLi9zZXR0aW5ncy1taWdyYXRpb24tYXBpLnRzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBLHNCQUFBQTtBQUFBLEVBQUEsOEJBQUFDO0FBQUEsRUFBQSx3QkFBQUM7QUFBQSxFQUFBLDZCQUFBQztBQUFBLEVBQUEsOEJBQUFDO0FBQUEsRUFBQSx5QkFBQUM7QUFBQSxFQUFBLGlDQUFBQztBQUFBLEVBQUEsNkJBQUFDO0FBQUEsRUFBQSxnQ0FBQUM7QUFBQTtBQUFBO0FBRUEsSUFBQVIsYUFBOEI7QUFDOUIsSUFBQUMsdUJBQXdDO0FBQ3hDLElBQUFDLGlCQUFrQztBQUNsQyxJQUFBQyxzQkFBdUM7QUFDdkMsSUFBQUMsdUJBQXdDO0FBQ3hDLElBQUFDLGtCQUFtQztBQUNuQyxJQUFBQywwQkFBMkM7QUFDM0MsSUFBQUMsc0JBQXVDO0FBQ3ZDLGFBQTBCO0FBQzFCLElBQUFDLHlCQUEwQzsiLCJuYW1lcyI6WyJwbHVnaW4tYXBpIiwicGx1Z2luLWFzeW5jLWNsZWFudXAiLCJwbHVnaW4tY29udGV4dCIsInBsdWdpbi1ldmVudC1zb3VyY2UiLCJwbHVnaW4taW5zdGFsbC1zdGF0ZSIsInBsdWdpbi1pbnN0YW5jZSIsInBsdWdpbi1saWZlY3ljbGUtZXZlbnRzIiwicGx1Z2luLXNldHRpbmdzLXRhYiIsInNldHRpbmdzLW1pZ3JhdGlvbi1hcGkiXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wbHVnaW4vaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdwbHVnaW4tYXBpJyBmcm9tICcuL3BsdWdpbi1hcGkudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1hc3luYy1jbGVhbnVwJyBmcm9tICcuL3BsdWdpbi1hc3luYy1jbGVhbnVwLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4taW5zdGFsbC1zdGF0ZScgZnJvbSAnLi9wbHVnaW4taW5zdGFsbC1zdGF0ZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWluc3RhbmNlJyBmcm9tICcuL3BsdWdpbi1pbnN0YW5jZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWxpZmVjeWNsZS1ldmVudHMnIGZyb20gJy4vcGx1Z2luLWxpZmVjeWNsZS1ldmVudHMudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy10YWInIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLXRhYi50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luJyBmcm9tICcuL3BsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc2V0dGluZ3MtbWlncmF0aW9uLWFwaScgZnJvbSAnLi9zZXR0aW5ncy1taWdyYXRpb24tYXBpLnRzJztcbmV4cG9ydCAqIGFzICd0aGlyZC1wYXJ0eS1wbHVnaW4nIGZyb20gJy4vdGhpcmQtcGFydHktcGx1Z2luLnRzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBLHNCQUFBQTtBQUFBLEVBQUEsOEJBQUFDO0FBQUEsRUFBQSx3QkFBQUM7QUFBQSxFQUFBLDZCQUFBQztBQUFBLEVBQUEsOEJBQUFDO0FBQUEsRUFBQSx5QkFBQUM7QUFBQSxFQUFBLGlDQUFBQztBQUFBLEVBQUEsNkJBQUFDO0FBQUEsRUFBQSxnQ0FBQUM7QUFBQSxFQUFBLDRCQUFBQztBQUFBO0FBQUE7QUFFQSxJQUFBVCxhQUE4QjtBQUM5QixJQUFBQyx1QkFBd0M7QUFDeEMsSUFBQUMsaUJBQWtDO0FBQ2xDLElBQUFDLHNCQUF1QztBQUN2QyxJQUFBQyx1QkFBd0M7QUFDeEMsSUFBQUMsa0JBQW1DO0FBQ25DLElBQUFDLDBCQUEyQztBQUMzQyxJQUFBQyxzQkFBdUM7QUFDdkMsYUFBMEI7QUFDMUIsSUFBQUMseUJBQTBDO0FBQzFDLElBQUFDLHFCQUFzQzsiLCJuYW1lcyI6WyJwbHVnaW4tYXBpIiwicGx1Z2luLWFzeW5jLWNsZWFudXAiLCJwbHVnaW4tY29udGV4dCIsInBsdWdpbi1ldmVudC1zb3VyY2UiLCJwbHVnaW4taW5zdGFsbC1zdGF0ZSIsInBsdWdpbi1pbnN0YW5jZSIsInBsdWdpbi1saWZlY3ljbGUtZXZlbnRzIiwicGx1Z2luLXNldHRpbmdzLXRhYiIsInNldHRpbmdzLW1pZ3JhdGlvbi1hcGkiLCJ0aGlyZC1wYXJ0eS1wbHVnaW4iXX0=

package/dist/lib/cjs/plugin/index.d.cts

@@ -9,3 +9,4 @@ export * as 'plugin-lifecycle-events' from './plugin-lifecycle-events.cjs';
 export * as 'plugin-settings-tab' from './plugin-settings-tab.cjs';
 export * as 'plugin' from './plugin.cjs';
 export * as 'settings-migration-api' from './settings-migration-api.cjs';
+export * as 'third-party-plugin' from './third-party-plugin.cjs';

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

@@ -125,14 +125,14 @@ __export(plugin_api_exports, {
   watchPluginApi: () => watchPluginApi
 });
 module.exports = __toCommonJS(plugin_api_exports);
-var import_array = require('@mnaoumov/typescript-lib/array');
-var import_async = require('@mnaoumov/typescript-lib/async');
-var import_async_events = require('@mnaoumov/typescript-lib/async-events');
-var import_debug_switches = require('@mnaoumov/typescript-lib/debug-switches');
-var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
-var import_compare_versions = require('compare-versions');
-var import_debug = require('../debug.cjs');
-var import_obsidian_lib_state = require('../obsidian-lib-state.cjs');
+var import_array = require("@mnaoumov/typescript-lib/array");
+var import_async = require("@mnaoumov/typescript-lib/async");
+var import_async_events = require("@mnaoumov/typescript-lib/async-events");
+var import_debug_switches = require("@mnaoumov/typescript-lib/debug-switches");
+var import_object_utils = require("@mnaoumov/typescript-lib/object-utils");
+var import_compare_versions = require("compare-versions");
+var import_debug = require("../debug.cjs");
+var import_obsidian_lib_state = require("../obsidian-lib-state.cjs");
 const PLUGIN_API_DEBUGGER_NAMESPACE = "PluginApi";
 const PLUGIN_API_REGISTRY_STATE_KEY = "pluginApiRegistry";
 const VALIDATE_PLUGIN_API_PAYLOADS_DEBUG_SWITCH_DEFINITION = {

package/dist/lib/cjs/plugin/plugin-async-cleanup.cjs

@@ -114,6 +114,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var plugin_async_cleanup_exports = {};
 __export(plugin_async_cleanup_exports, {
+  DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS: () => DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS,
   DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS,
   PLUGIN_ASYNC_CLEANUPS_STATE_KEY: () => PLUGIN_ASYNC_CLEANUPS_STATE_KEY,
   didPluginAsyncCleanupsSettle: () => didPluginAsyncCleanupsSettle,
@@ -122,10 +123,11 @@ __export(plugin_async_cleanup_exports, {
   trackPluginAsyncCleanup: () => trackPluginAsyncCleanup
 });
 module.exports = __toCommonJS(plugin_async_cleanup_exports);
-var import_error = require('@mnaoumov/typescript-lib/error');
-var import_obsidian_lib_state = require('../obsidian-lib-state.cjs');
+var import_error = require("@mnaoumov/typescript-lib/error");
+var import_obsidian_lib_state = require("../obsidian-lib-state.cjs");
 const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = "pluginAsyncCleanupsV1";
 const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 1e4;
+const DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS = 500;
 async function didPluginAsyncCleanupsSettle(params) {
   const promise = getPendingCleanups().get(params.pluginId);
   if (!promise) {
@@ -179,6 +181,7 @@ async function runCleanupSafely(params) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS,
   DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS,
   PLUGIN_ASYNC_CLEANUPS_STATE_KEY,
   didPluginAsyncCleanupsSettle,
@@ -186,4 +189,4 @@ async function runCleanupSafely(params) {
   registerPluginAsyncCleanup,
   trackPluginAsyncCleanup
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/plugin-async-cleanup.ts"],"sourcesContent":["/**\n * @file\n *\n * Async cleanup that outlives a plugin instance, so the next instance of the same plugin can await it.\n *\n * Obsidian's `onunload` is synchronous and nothing awaits what it starts. Read from Obsidian `1.15.1`:\n * `Plugins.unloadPlugin` calls the old instance's `unload()` and returns, and `enablePlugin` then constructs the new\n * instance and awaits its `load()`. So on a disable / enable, a reload or an update while enabled, work like closing\n * an IndexedDB connection is still in flight when the new instance starts, and the new instance can open a database\n * the old one still holds.\n *\n * The registry here closes that gap without owning the reload lifecycle: a cleanup starts when the component it is\n * registered on unloads, its promise is kept realm-wide under the plugin id, and the next instance awaits it, bounded\n * by a timeout, before it starts. `PluginBase` does both halves itself.\n *\n * The registry lives in the realm-global shared-state bag under the versioned key `pluginAsyncCleanupsV1`, because the\n * old instance and the new one may bundle different copies of this library. It is a wire format between those copies:\n * a plain `Map` from plugin id to a `Promise<void>` that never rejects. A change of meaning moves to a new key.\n */\n\nimport type { Component } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { printError } from '@mnaoumov/typescript-lib/error';\n\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\n\n/**\n * The shared-state key of the pending cleanups. Versioned, because it is a wire format between copies of this library.\n */\nexport const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = 'pluginAsyncCleanupsV1';\n\n/**\n * How long a new plugin instance waits for the previous instance's cleanups by default.\n */\nexport const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * Parameters for {@link didPluginAsyncCleanupsSettle}.\n */\nexport interface DidPluginAsyncCleanupsSettleParams {\n  /**\n   * The id of the plugin whose pending cleanups to await.\n   */\n  readonly pluginId: string;\n\n  /**\n   * How long to wait before giving up. Defaults to {@link DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS}.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * An async cleanup.\n */\nexport type PluginAsyncCleanup = () => Promisable<void>;\n\n/**\n * Parameters for {@link registerPluginAsyncCleanup}.\n */\nexport interface RegisterPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The component whose unload starts the cleanup.\n   */\n  readonly component: Component;\n\n  /**\n   * The id of the plugin the cleanup belongs to, which the next instance waits under.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link trackPluginAsyncCleanup}.\n */\nexport interface TrackPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run now.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The id of the plugin the cleanup belongs to.\n   */\n  readonly pluginId: string;\n}\n\ninterface TrackedCleanupEntry {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Assigned once the self-removing promise exists.\n  promise?: Promise<void>;\n}\n\n/**\n * Awaits every cleanup still in flight for the plugin, bounded by a timeout.\n *\n * Resolves at once when nothing is pending. Never rejects.\n *\n * @param params - The parameters.\n * @returns `true` if every pending cleanup settled in time, `false` if the timeout was reached first.\n */\nexport async function didPluginAsyncCleanupsSettle(params: DidPluginAsyncCleanupsSettleParams): Promise<boolean> {\n  const promise = getPendingCleanups().get(params.pluginId);\n  if (!promise) {\n    return true;\n  }\n\n  let timeoutId: number | undefined;\n  const timeoutPromise = new Promise<false>((resolve) => {\n    timeoutId = window.setTimeout(() => {\n      resolve(false);\n    }, params.timeoutInMilliseconds ?? DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS);\n  });\n\n  try {\n    return await Promise.race([promise.then(() => true), timeoutPromise]);\n  } finally {\n    window.clearTimeout(timeoutId);\n  }\n}\n\n/**\n * Checks whether a plugin has cleanups still in flight.\n *\n * @param pluginId - The plugin id.\n * @returns Whether any cleanup registered under the id has not settled yet.\n */\nexport function hasPendingPluginAsyncCleanups(pluginId: string): boolean {\n  return getPendingCleanups().has(pluginId);\n}\n\n/**\n * Registers an async cleanup that starts when the component unloads and that the next instance of the plugin awaits.\n *\n * The cleanup runs exactly once, on the component's unload. Register it on the component whose lifetime matches the\n * resource: a `PluginBase` subclass calls `registerAsyncCleanup` instead, which scopes it to the feature surface.\n *\n * @param params - The parameters.\n */\nexport function registerPluginAsyncCleanup(params: RegisterPluginAsyncCleanupParams): void {\n  params.component.register(() => {\n    trackPluginAsyncCleanup({\n      cleanup: params.cleanup,\n      pluginId: params.pluginId\n    });\n  });\n}\n\n/**\n * Runs an async cleanup now and tracks it under the plugin id until it settles.\n *\n * A cleanup that throws or rejects is printed and counts as settled, so a failing cleanup never stops the next\n * instance from loading.\n *\n * @param params - The parameters.\n */\nexport function trackPluginAsyncCleanup(params: TrackPluginAsyncCleanupParams): void {\n  const pendingCleanups = getPendingCleanups();\n  const previousPromise = pendingCleanups.get(params.pluginId);\n  const cleanupPromise = runCleanupSafely(params);\n  // Never rejects: `runCleanupSafely` catches, and so did whichever call tracked `previousPromise`.\n  const entry: TrackedCleanupEntry = {};\n  entry.promise = (async (): Promise<void> => {\n    await Promise.all([previousPromise, cleanupPromise]);\n    // A later call may have chained onto this entry already; only the latest entry removes itself.\n    if (pendingCleanups.get(params.pluginId) === entry.promise) {\n      pendingCleanups.delete(params.pluginId);\n    }\n  })();\n  pendingCleanups.set(params.pluginId, entry.promise);\n}\n\nfunction getPendingCleanups(): Map<string, Promise<void>> {\n  return getObsidianLibState(PLUGIN_ASYNC_CLEANUPS_STATE_KEY, new Map<string, Promise<void>>()).value;\n}\n\nasync function runCleanupSafely(params: TrackPluginAsyncCleanupParams): Promise<void> {\n  try {\n    await params.cleanup();\n  } catch (error) {\n    printError(new Error(`Async cleanup of plugin ${params.pluginId} failed`, { cause: error }));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,mBAA2B;AAE3B,gCAAoC;AAK7B,MAAM,kCAAkC;AAKxC,MAAM,uDAAuD;AAsEpE,eAAsB,6BAA6B,QAA8D;AAC/G,QAAM,UAAU,mBAAmB,EAAE,IAAI,OAAO,QAAQ;AACxD,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAe,CAAC,YAAY;AACrD,gBAAY,OAAO,WAAW,MAAM;AAClC,cAAQ,KAAK;AAAA,IACf,GAAG,OAAO,yBAAyB,oDAAoD;AAAA,EACzF,CAAC;AAED,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,QAAQ,KAAK,MAAM,IAAI,GAAG,cAAc,CAAC;AAAA,EACtE,UAAE;AACA,WAAO,aAAa,SAAS;AAAA,EAC/B;AACF;AAQO,SAAS,8BAA8B,UAA2B;AACvE,SAAO,mBAAmB,EAAE,IAAI,QAAQ;AAC1C;AAUO,SAAS,2BAA2B,QAAgD;AACzF,SAAO,UAAU,SAAS,MAAM;AAC9B,4BAAwB;AAAA,MACtB,SAAS,OAAO;AAAA,MAChB,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH,CAAC;AACH;AAUO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,kBAAkB,mBAAmB;AAC3C,QAAM,kBAAkB,gBAAgB,IAAI,OAAO,QAAQ;AAC3D,QAAM,iBAAiB,iBAAiB,MAAM;AAE9C,QAAM,QAA6B,CAAC;AACpC,QAAM,WAAW,YAA2B;AAC1C,UAAM,QAAQ,IAAI,CAAC,iBAAiB,cAAc,CAAC;AAEnD,QAAI,gBAAgB,IAAI,OAAO,QAAQ,MAAM,MAAM,SAAS;AAC1D,sBAAgB,OAAO,OAAO,QAAQ;AAAA,IACxC;AAAA,EACF,GAAG;AACH,kBAAgB,IAAI,OAAO,UAAU,MAAM,OAAO;AACpD;AAEA,SAAS,qBAAiD;AACxD,aAAO,+CAAoB,iCAAiC,oBAAI,IAA2B,CAAC,EAAE;AAChG;AAEA,eAAe,iBAAiB,QAAsD;AACpF,MAAI;AACF,UAAM,OAAO,QAAQ;AAAA,EACvB,SAAS,OAAO;AACd,iCAAW,IAAI,MAAM,2BAA2B,OAAO,QAAQ,WAAW,EAAE,OAAO,MAAM,CAAC,CAAC;AAAA,EAC7F;AACF;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/plugin-async-cleanup.ts"],"sourcesContent":["/**\n * @file\n *\n * Async cleanup that outlives a plugin instance, so the next instance of the same plugin can await it.\n *\n * Obsidian's `onunload` is synchronous and nothing awaits what it starts. Read from Obsidian `1.15.1`:\n * `Plugins.unloadPlugin` calls the old instance's `unload()` and returns, and `enablePlugin` then constructs the new\n * instance and awaits its `load()`. So on a disable / enable, a reload or an update while enabled, work like closing\n * an IndexedDB connection is still in flight when the new instance starts, and the new instance can open a database\n * the old one still holds.\n *\n * The registry here closes that gap without owning the reload lifecycle: a cleanup starts when the component it is\n * registered on unloads, its promise is kept realm-wide under the plugin id, and the next instance awaits it, bounded\n * by a timeout, before it starts. `PluginBase` does both halves itself.\n *\n * The registry lives in the realm-global shared-state bag under the versioned key `pluginAsyncCleanupsV1`, because the\n * old instance and the new one may bundle different copies of this library. It is a wire format between those copies:\n * a plain `Map` from plugin id to a `Promise<void>` that never rejects. A change of meaning moves to a new key.\n */\n\nimport type { Component } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { printError } from '@mnaoumov/typescript-lib/error';\n\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\n\n/**\n * The shared-state key of the pending cleanups. Versioned, because it is a wire format between copies of this library.\n */\nexport const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = 'pluginAsyncCleanupsV1';\n\n/**\n * How long a new plugin instance waits for the previous instance's cleanups by default.\n */\nexport const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * How long a new plugin instance waits for the previous instance's cleanups, by default, before it shows a notice that\n * its load is paused. Shorter waits show nothing, so the usual few milliseconds never flash a notice.\n */\nexport const DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS = 500;\n\n/**\n * Parameters for {@link didPluginAsyncCleanupsSettle}.\n */\nexport interface DidPluginAsyncCleanupsSettleParams {\n  /**\n   * The id of the plugin whose pending cleanups to await.\n   */\n  readonly pluginId: string;\n\n  /**\n   * How long to wait before giving up. Defaults to {@link DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS}.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * An async cleanup.\n */\nexport type PluginAsyncCleanup = () => Promisable<void>;\n\n/**\n * Parameters for {@link registerPluginAsyncCleanup}.\n */\nexport interface RegisterPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The component whose unload starts the cleanup.\n   */\n  readonly component: Component;\n\n  /**\n   * The id of the plugin the cleanup belongs to, which the next instance waits under.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link trackPluginAsyncCleanup}.\n */\nexport interface TrackPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run now.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The id of the plugin the cleanup belongs to.\n   */\n  readonly pluginId: string;\n}\n\ninterface TrackedCleanupEntry {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Assigned once the self-removing promise exists.\n  promise?: Promise<void>;\n}\n\n/**\n * Awaits every cleanup still in flight for the plugin, bounded by a timeout.\n *\n * Resolves at once when nothing is pending. Never rejects.\n *\n * @param params - The parameters.\n * @returns `true` if every pending cleanup settled in time, `false` if the timeout was reached first.\n */\nexport async function didPluginAsyncCleanupsSettle(params: DidPluginAsyncCleanupsSettleParams): Promise<boolean> {\n  const promise = getPendingCleanups().get(params.pluginId);\n  if (!promise) {\n    return true;\n  }\n\n  let timeoutId: number | undefined;\n  const timeoutPromise = new Promise<false>((resolve) => {\n    timeoutId = window.setTimeout(() => {\n      resolve(false);\n    }, params.timeoutInMilliseconds ?? DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS);\n  });\n\n  try {\n    return await Promise.race([promise.then(() => true), timeoutPromise]);\n  } finally {\n    window.clearTimeout(timeoutId);\n  }\n}\n\n/**\n * Checks whether a plugin has cleanups still in flight.\n *\n * @param pluginId - The plugin id.\n * @returns Whether any cleanup registered under the id has not settled yet.\n */\nexport function hasPendingPluginAsyncCleanups(pluginId: string): boolean {\n  return getPendingCleanups().has(pluginId);\n}\n\n/**\n * Registers an async cleanup that starts when the component unloads and that the next instance of the plugin awaits.\n *\n * The cleanup runs exactly once, on the component's unload. Register it on the component whose lifetime matches the\n * resource: a `PluginBase` subclass calls `registerAsyncCleanup` instead, which scopes it to the feature surface.\n *\n * @param params - The parameters.\n */\nexport function registerPluginAsyncCleanup(params: RegisterPluginAsyncCleanupParams): void {\n  params.component.register(() => {\n    trackPluginAsyncCleanup({\n      cleanup: params.cleanup,\n      pluginId: params.pluginId\n    });\n  });\n}\n\n/**\n * Runs an async cleanup now and tracks it under the plugin id until it settles.\n *\n * A cleanup that throws or rejects is printed and counts as settled, so a failing cleanup never stops the next\n * instance from loading.\n *\n * @param params - The parameters.\n */\nexport function trackPluginAsyncCleanup(params: TrackPluginAsyncCleanupParams): void {\n  const pendingCleanups = getPendingCleanups();\n  const previousPromise = pendingCleanups.get(params.pluginId);\n  const cleanupPromise = runCleanupSafely(params);\n  // Never rejects: `runCleanupSafely` catches, and so did whichever call tracked `previousPromise`.\n  const entry: TrackedCleanupEntry = {};\n  entry.promise = (async (): Promise<void> => {\n    await Promise.all([previousPromise, cleanupPromise]);\n    // A later call may have chained onto this entry already; only the latest entry removes itself.\n    if (pendingCleanups.get(params.pluginId) === entry.promise) {\n      pendingCleanups.delete(params.pluginId);\n    }\n  })();\n  pendingCleanups.set(params.pluginId, entry.promise);\n}\n\nfunction getPendingCleanups(): Map<string, Promise<void>> {\n  return getObsidianLibState(PLUGIN_ASYNC_CLEANUPS_STATE_KEY, new Map<string, Promise<void>>()).value;\n}\n\nasync function runCleanupSafely(params: TrackPluginAsyncCleanupParams): Promise<void> {\n  try {\n    await params.cleanup();\n  } catch (error) {\n    printError(new Error(`Async cleanup of plugin ${params.pluginId} failed`, { cause: error }));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,mBAA2B;AAE3B,gCAAoC;AAK7B,MAAM,kCAAkC;AAKxC,MAAM,uDAAuD;AAM7D,MAAM,4DAA4D;AAsEzE,eAAsB,6BAA6B,QAA8D;AAC/G,QAAM,UAAU,mBAAmB,EAAE,IAAI,OAAO,QAAQ;AACxD,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAe,CAAC,YAAY;AACrD,gBAAY,OAAO,WAAW,MAAM;AAClC,cAAQ,KAAK;AAAA,IACf,GAAG,OAAO,yBAAyB,oDAAoD;AAAA,EACzF,CAAC;AAED,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,QAAQ,KAAK,MAAM,IAAI,GAAG,cAAc,CAAC;AAAA,EACtE,UAAE;AACA,WAAO,aAAa,SAAS;AAAA,EAC/B;AACF;AAQO,SAAS,8BAA8B,UAA2B;AACvE,SAAO,mBAAmB,EAAE,IAAI,QAAQ;AAC1C;AAUO,SAAS,2BAA2B,QAAgD;AACzF,SAAO,UAAU,SAAS,MAAM;AAC9B,4BAAwB;AAAA,MACtB,SAAS,OAAO;AAAA,MAChB,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH,CAAC;AACH;AAUO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,kBAAkB,mBAAmB;AAC3C,QAAM,kBAAkB,gBAAgB,IAAI,OAAO,QAAQ;AAC3D,QAAM,iBAAiB,iBAAiB,MAAM;AAE9C,QAAM,QAA6B,CAAC;AACpC,QAAM,WAAW,YAA2B;AAC1C,UAAM,QAAQ,IAAI,CAAC,iBAAiB,cAAc,CAAC;AAEnD,QAAI,gBAAgB,IAAI,OAAO,QAAQ,MAAM,MAAM,SAAS;AAC1D,sBAAgB,OAAO,OAAO,QAAQ;AAAA,IACxC;AAAA,EACF,GAAG;AACH,kBAAgB,IAAI,OAAO,UAAU,MAAM,OAAO;AACpD;AAEA,SAAS,qBAAiD;AACxD,aAAO,+CAAoB,iCAAiC,oBAAI,IAA2B,CAAC,EAAE;AAChG;AAEA,eAAe,iBAAiB,QAAsD;AACpF,MAAI;AACF,UAAM,OAAO,QAAQ;AAAA,EACvB,SAAS,OAAO;AACd,iCAAW,IAAI,MAAM,2BAA2B,OAAO,QAAQ,WAAW,EAAE,OAAO,MAAM,CAAC,CAAC;AAAA,EAC7F;AACF;","names":[]}

package/dist/lib/cjs/plugin/plugin-async-cleanup.d.cts

@@ -28,6 +28,11 @@ export declare const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = "pluginAsyncCleanupsV1";
  * How long a new plugin instance waits for the previous instance's cleanups by default.
  */
 export declare const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 10000;
+/**
+ * How long a new plugin instance waits for the previous instance's cleanups, by default, before it shows a notice that
+ * its load is paused. Shorter waits show nothing, so the usual few milliseconds never flash a notice.
+ */
+export declare const DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS = 500;
 /**
  * Parameters for {@link didPluginAsyncCleanupsSettle}.
  */

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

@@ -119,14 +119,14 @@ __export(plugin_context_exports, {
   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_debug2 = require('../debug.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_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_debug2 = require("../debug.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");
 const DEBUG_GUIDE_URL = "https://mnaoumov.dev/obsidian-lib/guides/debugging/";
 function addPluginCssClasses(element, cssClasses) {
   const extraCssClasses = typeof cssClasses === "string" ? [cssClasses] : cssClasses ?? [];
@@ -158,6 +158,7 @@ function initPluginContext(pluginId) {
   (0, import_debug2.showInitialDebugMessage)(pluginId);
   (0, import_abort_controller.getSharedAbortController)();
   (0, import_library_styles.injectLibraryStyles)({
+    // eslint-disable-next-line obsidianmd/prefer-active-doc -- The shared library styles belong to the main window; `activeDocument` would put them in whichever popout has focus.
     doc: document,
     libraryStyles: import_generated_during_build.LIBRARY_STYLES,
     libraryVersion: import_generated_during_build.LIBRARY_VERSION
@@ -169,4 +170,4 @@ function initPluginContext(pluginId) {
   initDebugController,
   initPluginContext
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/plugin/plugin-event-source.cjs

@@ -178,4 +178,4 @@ class PluginEventSourceImpl {
 0 && (module.exports = {
   PluginEventSourceImpl
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/plugin/plugin-event-source.d.cts

@@ -4,7 +4,7 @@
  *
  * Contains the implementation of the plugin event source.
  */
-import type { AsyncEventRef, AsyncEventSource } from '@mnaoumov/typescript-lib/async-events' with { 'resolution-mode': 'import' };
+import type { AsyncEventRef, AsyncEventSource, CallbackArguments } from '@mnaoumov/typescript-lib/async-events' with { 'resolution-mode': 'import' };
 import type { StringKeys } from '@mnaoumov/typescript-lib/type' with { 'resolution-mode': 'import' };
 import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { PluginBase } from './plugin.cjs';
@@ -45,7 +45,7 @@ export declare class PluginEventSourceImpl implements PluginEventSource {
      * events.off('my-event', myListener);
      * ```
      */
-    off<EventName extends StringKeys<PluginEventMap>, Arguments extends EventName extends StringKeys<PluginEventMap> ? PluginEventMap[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void;
+    off<EventName extends StringKeys<PluginEventMap>, Arguments extends CallbackArguments<PluginEventMap, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void;
     /**
      * Remove an event listener by reference.
      *
@@ -72,7 +72,7 @@ export declare class PluginEventSourceImpl implements PluginEventSource {
      * });
      * ```
      */
-    on<EventName extends StringKeys<PluginEventMap>, Arguments extends EventName extends StringKeys<PluginEventMap> ? PluginEventMap[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
+    on<EventName extends StringKeys<PluginEventMap>, Arguments extends CallbackArguments<PluginEventMap, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
     /**
      * Add an event listener that will be triggered only once.
      *
@@ -93,5 +93,5 @@ export declare class PluginEventSourceImpl implements PluginEventSource {
      * });
      * ```
      */
-    once<EventName extends StringKeys<PluginEventMap>, Arguments extends EventName extends StringKeys<PluginEventMap> ? PluginEventMap[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
+    once<EventName extends StringKeys<PluginEventMap>, Arguments extends CallbackArguments<PluginEventMap, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
 }

package/dist/lib/cjs/plugin/plugin-install-state.cjs

@@ -123,10 +123,10 @@ __export(plugin_install_state_exports, {
   updatePlugin: () => updatePlugin
 });
 module.exports = __toCommonJS(plugin_install_state_exports);
-var import_compare_versions = require('compare-versions');
-var import_community_plugins = require('../community-plugins.cjs');
-var import_html_element = require('../html-element.cjs');
-var import_i18n = require('../i18n/i18n.cjs');
+var import_compare_versions = require("compare-versions");
+var import_community_plugins = require("../community-plugins.cjs");
+var import_html_element = require("../html-element.cjs");
+var import_i18n = require("../i18n/i18n.cjs");
 var InstalledPluginState = /* @__PURE__ */ ((InstalledPluginState2) => {
   InstalledPluginState2["Enabled"] = "enabled";
   InstalledPluginState2["InstalledButDisabled"] = "installedButDisabled";