@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/cjs/components/workspace-layout-state-component.d.cts

@@ -0,0 +1,239 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Keeps a plugin's layout-scoped state in the workspace layout itself, so each saved workspace remembers its own value
+ * and switching workspaces restores it, instead of one global value in `data.json`.
+ *
+ * Read from Obsidian `1.15.1`: `Workspace.getLayout()` builds a fresh object (`main`, `left`, `right`, `left-ribbon`,
+ * `floating`, `active`) and `Workspace.setLayout()` ignores every other top-level key. `deserializeLayout` keeps each
+ * item's `id`, popout leaves included. The Workspaces core plugin saves through `getLayout()` and loads through
+ * `changeLayout()`, which calls `setLayout()`. Startup goes through `loadLayout()`, `readWorkspaceFile()` and
+ * `setLayout()`, after the plugins enabled at startup have loaded. So two patches on the `app.workspace` instance carry
+ * the whole thing: `getLayout` writes the records under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}, and `setLayout`
+ * replaces them from the layout it is handed before any view is restored. Per-leaf state is keyed by leaf id at the
+ * layout level, so no `WorkspaceItem.serialize` or `deserializeLayout` patch is needed.
+ *
+ * A view the plugin owns needs none of this: `View.getState` / `setState` already ride in each leaf's state. This
+ * component is for the scope those methods cannot represent: the whole layout, and leaves of views the plugin does not
+ * own.
+ *
+ * Every plugin bundles its own copy of this library, so the records, the subscriptions and ONE installation of the
+ * patches live in the shared-state bag under a versioned key, owned by one subscriber. When the owner unloads while
+ * others remain, the next subscriber installs again from its own copy. What crosses that boundary is a wire format
+ * between copies of different versions: plain objects and plain functions only, fields only ever added, and a change of
+ * meaning moves to a new key. The layout record is a wire format too, persisted in `workspace.json` and in every saved
+ * workspace.
+ */
+import type { App, WorkspaceLeaf } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { JsonValue } from 'type-fest' with { 'resolution-mode': 'import' };
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * The top-level key of a serialized layout that holds the records.
+ */
+export declare const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = "obsidianLibLayoutStateV1";
+/**
+ * A change of one key's value, in one scope.
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateChange<T> {
+    /**
+     * The leaf whose value changed, or `null` for the workspace scope or a leaf no longer in the layout.
+     */
+    readonly leaf: null | WorkspaceLeaf;
+    /**
+     * The id of the leaf whose value changed, or `null` for the workspace scope.
+     */
+    readonly leafId: null | string;
+    /**
+     * The value before the change, as {@link WorkspaceLayoutStateKey.get} read it.
+     */
+    readonly oldValue: T;
+    /**
+     * The value after the change, as {@link WorkspaceLayoutStateKey.get} reads it.
+     */
+    readonly value: T;
+}
+/**
+ * Parameters for {@link WorkspaceLayoutStateComponent}.
+ */
+export interface WorkspaceLayoutStateComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The id of the plugin the values belong to. Every value is namespaced by it.
+     */
+    readonly pluginId: string;
+}
+/**
+ * A typed handle to one layout-scoped key.
+ *
+ * Every method takes an optional leaf. Without one, the value belongs to the whole layout (the workspace scope).
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateKey<T> {
+    /**
+     * Reads the value: a clone of the stored one, or of the default when nothing is stored or the stored value fails the
+     * key's guard.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @returns The value.
+     */
+    readonly get: (leaf?: WorkspaceLeaf) => T;
+    /**
+     * Checks whether a value is stored, valid or not.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @returns Whether a value is stored.
+     */
+    readonly has: (leaf?: WorkspaceLeaf) => boolean;
+    /**
+     * The key name, unique within the plugin.
+     */
+    readonly key: string;
+    /**
+     * Subscribes to changes of this key made through `set` or `unset`, in any scope and from any copy of the library. A
+     * layout load is reported through {@link WorkspaceLayoutStateComponent.onLayoutLoad} instead.
+     *
+     * @param callback - Called after each change.
+     * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+     */
+    readonly onChange: (callback: (change: WorkspaceLayoutStateChange<T>) => void) => () => void;
+    /**
+     * Stores a clone of the value and requests a layout save. Storing a value equal to the stored one does nothing.
+     *
+     * @param value - The value. It must be JSON-safe; `null` is stored as `null`.
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @throws A `TypeError` if the value is not JSON-safe.
+     */
+    readonly set: (value: T, leaf?: WorkspaceLeaf) => void;
+    /**
+     * Removes the stored value, so `get` reads the default again, and requests a layout save.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     */
+    readonly unset: (leaf?: WorkspaceLeaf) => void;
+}
+/**
+ * Defines a layout-scoped key.
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateKeyDefinition<T> {
+    /**
+     * The value read when nothing valid is stored.
+     */
+    readonly defaultValue: T;
+    /**
+     * Checks a stored value. A value that fails reads as the default and stays stored until it is replaced or unset.
+     *
+     * @default Accepts every JSON value.
+     */
+    readonly isValid?: (value: unknown) => value is T;
+    /**
+     * The key name, unique within the plugin.
+     */
+    readonly key: string;
+}
+/**
+ * One plugin's records. Fields a newer copy adds are preserved.
+ */
+export interface WorkspaceLayoutStatePluginRecord {
+    /**
+     * The values by leaf id, then by key.
+     */
+    readonly leaves: Record<string, JsonRecord>;
+    /**
+     * Fields a newer copy of the library added.
+     */
+    readonly [field: string]: unknown;
+    /**
+     * The workspace-scope values by key.
+     */
+    readonly workspace: JsonRecord;
+}
+/**
+ * The record persisted under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}. Fields a newer copy adds are preserved.
+ */
+export interface WorkspaceLayoutStateRecord {
+    /**
+     * The records by plugin id.
+     */
+    readonly plugins: Record<string, WorkspaceLayoutStatePluginRecord>;
+    /**
+     * Fields a newer copy of the library added.
+     */
+    readonly [field: string]: unknown;
+}
+type JsonRecord = Record<string, JsonValue>;
+/**
+ * Keeps a plugin's layout-scoped values in the workspace layout, so saved workspaces each restore their own.
+ *
+ * Any number of these, in any number of plugins, share one installation per {@link App}. Values are restored when a
+ * layout loads, which REPLACES every value: write them after {@link Workspace.onLayoutReady}, and re-read them in
+ * {@link onLayoutLoad}.
+ */
+export declare class WorkspaceLayoutStateComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The id of the plugin the values belong to.
+     */
+    protected readonly pluginId: string;
+    private readonly layoutLoadListeners;
+    private readonly recordChangeListeners;
+    /**
+     * Creates a new workspace layout state component.
+     *
+     * @param params - The parameters.
+     * @throws A `TypeError` if the plugin id is empty.
+     */
+    constructor(params: WorkspaceLayoutStateComponentConstructorParams);
+    /**
+     * Defines a typed key.
+     *
+     * @typeParam T - The value type.
+     * @param definition - The key definition.
+     * @returns The key handle.
+     * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.
+     */
+    defineKey<T>(definition: WorkspaceLayoutStateKeyDefinition<T>): WorkspaceLayoutStateKey<T>;
+    /**
+     * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when
+     * the component is first loaded after layout-ready. Every value may have changed.
+     *
+     * @param callback - Called after the layout is loaded, once its leaves exist.
+     * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+     */
+    onLayoutLoad(callback: () => void): () => void;
+    /**
+     * Subscribes to the shared installation, installing it when nobody has yet.
+     */
+    onload(): void;
+    private subscribeToRecordChanges;
+}
+/**
+ * Parses a persisted record. A part that is malformed is dropped one level at a time: a malformed record reads as
+ * empty, a malformed plugin record drops only that plugin, and a malformed leaf bucket drops only that leaf. Fields this
+ * copy does not know are kept.
+ *
+ * @param value - The value found under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}.
+ * @returns The parsed record, sharing nothing with the input.
+ */
+export declare function parseWorkspaceLayoutStateRecord(value: unknown): WorkspaceLayoutStateRecord;
+/**
+ * Builds the record to persist into a serialized layout: leaf buckets for leaves absent from the layout are left out,
+ * and so are plugins with nothing left.
+ *
+ * @param record - The current record.
+ * @param layout - The serialized layout.
+ * @returns The record to persist, or `null` when there is nothing to persist.
+ */
+export declare function serializeWorkspaceLayoutStateRecord(record: WorkspaceLayoutStateRecord, layout: unknown): null | WorkspaceLayoutStateRecord;
+export {};

package/dist/lib/cjs/constructors/get-dom-events-handlers-constructor.cjs

@@ -168,11 +168,11 @@ __export(get_dom_events_handlers_constructor_exports, {
   getDomEventsHandlersConstructor: () => getDomEventsHandlersConstructor
 });
 module.exports = __toCommonJS(get_dom_events_handlers_constructor_exports);
-var import_async = require('@mnaoumov/typescript-lib/async');
-var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
-var import_obsidian = require('obsidian');
-var import_monkey_around_component = require('../components/monkey-around-component.cjs');
-var import_vault = require('../vault.cjs');
+var import_async = require("@mnaoumov/typescript-lib/async");
+var import_type_guards = require("@mnaoumov/typescript-lib/type-guards");
+var import_obsidian = require("obsidian");
+var import_monkey_around_component = require("../components/monkey-around-component.cjs");
+var import_vault = require("../vault.cjs");
 class MarkdownPreviewRendererRegisterDomEventsPatchComponent extends import_monkey_around_component.MonkeyAroundComponent {
   domEventsHandlersConstructor = null;
   onload() {

package/dist/lib/cjs/constructors/index.cjs

@@ -100,7 +100,7 @@ __export(constructors_exports, {
   "get-dom-events-handlers-constructor": () => get_dom_events_handlers_constructor
 });
 module.exports = __toCommonJS(constructors_exports);
-var get_dom_events_handlers_constructor = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./get-dom-events-handlers-constructor.cjs')), 1);
+var get_dom_events_handlers_constructor = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./get-dom-events-handlers-constructor.cjs")), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "get-dom-events-handlers-constructor": null

package/dist/lib/cjs/css-class.cjs

@@ -92,6 +92,8 @@ __export(css_class_exports, {
 module.exports = __toCommonJS(css_class_exports);
 var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["AlertModal"] = "alert-modal";
+  CssClass2["BugReportPreview"] = "bug-report-preview";
+  CssClass2["BugReportReviewModal"] = "bug-report-review-modal";
   CssClass2["CancelButton"] = "cancel-button";
   CssClass2["CheckboxComponent"] = "checkbox-component";
   CssClass2["ClickableIcon"] = "clickable-icon";
@@ -103,6 +105,8 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["CodeBlockBuilderPreview"] = "code-block-builder-preview";
   CssClass2["CodeHighlighterComponent"] = "code-highlighter-component";
   CssClass2["ConfirmModal"] = "confirm-modal";
+  CssClass2["CopyTextManuallyModal"] = "copy-text-manually-modal";
+  CssClass2["CopyTextManuallyText"] = "copy-text-manually-text";
   CssClass2["DateComponent"] = "date-component";
   CssClass2["DateTimeComponent"] = "datetime-component";
   CssClass2["EmailComponent"] = "email-component";
@@ -174,4 +178,4 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
 0 && (module.exports = {
   CssClass
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/css-class.ts"],"sourcesContent":["/**\n * @file\n *\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\n\n/**\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for a collapsible field group of the code block builder modal.\n   */\n  CodeBlockBuilderGroup = 'code-block-builder-group',\n\n  /**\n   * A CSS class for the field container of a collapsible group of the code block builder modal.\n   */\n  CodeBlockBuilderGroupBody = 'code-block-builder-group-body',\n\n  /**\n   * A CSS class for the code block builder modal.\n   */\n  CodeBlockBuilderModal = 'code-block-builder-modal',\n\n  /**\n   * A CSS class for the output row of the code block builder modal.\n   */\n  CodeBlockBuilderOutput = 'code-block-builder-output',\n\n  /**\n   * A CSS class for the live preview container of the code block builder modal.\n   */\n  CodeBlockBuilderPreview = 'code-block-builder-preview',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for rendered markdown whose headings and lists `registerFoldHandlers` made foldable.\n   */\n  FoldableMarkdown = 'foldable-markdown',\n\n  /**\n   * A CSS class for the folder list component.\n   */\n  FolderListComponent = 'folder-list-component',\n  /**\n   * A CSS class for the hotkey component.\n   */\n  HotkeyComponent = 'hotkey-component',\n\n  /**\n   * A CSS class for the element an inline token renders into, in Reading view and in Live Preview.\n   */\n  InlineToken = 'inline-token',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * Obsidian's class for a collapsed element, reused for a collapsed group of the code block builder modal.\n   */\n  IsCollapsed = 'is-collapsed',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name, set on every element the library builds.\n   */\n  LibraryName = 'obsidian-lib',\n\n  /**\n   * A CSS class for the reorderable list component.\n   */\n  ListComponent = 'list-component',\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text — a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.\n   */\n  PluginConflictBanner = 'plugin-conflict-banner',\n\n  /**\n   * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory\n   * dependency it is waiting for.\n   */\n  PluginDependencyBanner = 'plugin-dependency-banner',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the row of buttons in a plugin-suggestion notice, which spaces the action button apart from\n   * the decline button.\n   */\n  PluginSuggestionNoticeButtons = 'plugin-suggestion-notice-buttons',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the settings tabs.\n   */\n  SettingsTabs = 'settings-tabs',\n  /**\n   * A CSS class for the tag list component.\n   */\n  TagListComponent = 'tag-list-component',\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,yBAAsB;AAItB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,iBAAc;AAMd,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAIhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,kBAAe;AAOf,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,0BAAuB;AAMvB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,uCAAoC;AAKpC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,4BAAyB;AAMzB,EAAAA,UAAA,mCAAgC;AAKhC,EAAAA,UAAA,aAAU;AAMV,EAAAA,UAAA,uBAAoB;AASpB,EAAAA,UAAA,8BAA2B;AAM3B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,kBAAe;AAIf,EAAAA,UAAA,sBAAmB;AAInB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAMjC,EAAAA,UAAA,eAAY;AAKZ,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AA5YN,SAAAA;AAAA,GAAA;","names":["CssClass"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/css-class.ts"],"sourcesContent":["/**\n * @file\n *\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\n\n/**\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the preview of the bug-report diagnostics review modal.\n   */\n  BugReportPreview = 'bug-report-preview',\n\n  /**\n   * A CSS class for the bug-report diagnostics review modal.\n   */\n  BugReportReviewModal = 'bug-report-review-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for a collapsible field group of the code block builder modal.\n   */\n  CodeBlockBuilderGroup = 'code-block-builder-group',\n\n  /**\n   * A CSS class for the field container of a collapsible group of the code block builder modal.\n   */\n  CodeBlockBuilderGroupBody = 'code-block-builder-group-body',\n\n  /**\n   * A CSS class for the code block builder modal.\n   */\n  CodeBlockBuilderModal = 'code-block-builder-modal',\n\n  /**\n   * A CSS class for the output row of the code block builder modal.\n   */\n  CodeBlockBuilderOutput = 'code-block-builder-output',\n\n  /**\n   * A CSS class for the live preview container of the code block builder modal.\n   */\n  CodeBlockBuilderPreview = 'code-block-builder-preview',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the copy-text-manually modal.\n   */\n  CopyTextManuallyModal = 'copy-text-manually-modal',\n\n  /**\n   * A CSS class for the text area of the copy-text-manually modal.\n   */\n  CopyTextManuallyText = 'copy-text-manually-text',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for rendered markdown whose headings and lists `registerFoldHandlers` made foldable.\n   */\n  FoldableMarkdown = 'foldable-markdown',\n\n  /**\n   * A CSS class for the folder list component.\n   */\n  FolderListComponent = 'folder-list-component',\n  /**\n   * A CSS class for the hotkey component.\n   */\n  HotkeyComponent = 'hotkey-component',\n\n  /**\n   * A CSS class for the element an inline token renders into, in Reading view and in Live Preview.\n   */\n  InlineToken = 'inline-token',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * Obsidian's class for a collapsed element, reused for a collapsed group of the code block builder modal.\n   */\n  IsCollapsed = 'is-collapsed',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name, set on every element the library builds.\n   */\n  LibraryName = 'obsidian-lib',\n\n  /**\n   * A CSS class for the reorderable list component.\n   */\n  ListComponent = 'list-component',\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text — a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.\n   */\n  PluginConflictBanner = 'plugin-conflict-banner',\n\n  /**\n   * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory\n   * dependency it is waiting for.\n   */\n  PluginDependencyBanner = 'plugin-dependency-banner',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the row of buttons in a plugin-suggestion notice, which spaces the action button apart from\n   * the decline button.\n   */\n  PluginSuggestionNoticeButtons = 'plugin-suggestion-notice-buttons',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the settings tabs.\n   */\n  SettingsTabs = 'settings-tabs',\n  /**\n   * A CSS class for the tag list component.\n   */\n  TagListComponent = 'tag-list-component',\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],"mappings":"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","names":["CssClass"]}

package/dist/lib/cjs/css-class.d.cts

@@ -12,6 +12,14 @@ export declare enum CssClass {
      * A CSS class for the alert modal.
      */
     AlertModal = "alert-modal",
+    /**
+     * A CSS class for the preview of the bug-report diagnostics review modal.
+     */
+    BugReportPreview = "bug-report-preview",
+    /**
+     * A CSS class for the bug-report diagnostics review modal.
+     */
+    BugReportReviewModal = "bug-report-review-modal",
     /**
      * A CSS class for the cancel button.
      */
@@ -56,6 +64,14 @@ export declare enum CssClass {
      * A CSS class for the confirm modal.
      */
     ConfirmModal = "confirm-modal",
+    /**
+     * A CSS class for the copy-text-manually modal.
+     */
+    CopyTextManuallyModal = "copy-text-manually-modal",
+    /**
+     * A CSS class for the text area of the copy-text-manually modal.
+     */
+    CopyTextManuallyText = "copy-text-manually-text",
     /**
      * A CSS class for the date component.
      */