obsidian-dev-utils 88.5.0 → 88.7.0

package/dist/lib/esm/obsidian/components/index.mjs

@@ -41,6 +41,7 @@ import * as plugin_settings_tab_component from "./plugin-settings-tab-component.
 import * as pointer_position_component from "./pointer-position-component.mjs";
 import * as registry_component from "./registry-component.mjs";
 import * as rename_delete_handler_component from "./rename-delete-handler-component.mjs";
+import * as syntax_highlighting_component from "./syntax-highlighting-component.mjs";
 export {
   abort_signal_component as "abort-signal-component",
   all_windows_event_component as "all-windows-event-component",
@@ -61,6 +62,7 @@ export {
   plugin_settings_tab_component as "plugin-settings-tab-component",
   pointer_position_component as "pointer-position-component",
   registry_component as "registry-component",
-  rename_delete_handler_component as "rename-delete-handler-component"
+  rename_delete_handler_component as "rename-delete-handler-component",
+  syntax_highlighting_component as "syntax-highlighting-component"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/syntax-highlighting-component.d.mts

@@ -0,0 +1,149 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * Contains class {@link SyntaxHighlightingComponent} that registers syntax highlighting languages.
+ *
+ * Obsidian highlights code in two independent places, through two separate registries, and a plugin adding
+ * its own language usually has to touch both:
+ *
+ * - **Prism** (`prism.languages[language]`) highlights code in reading view and in every `<pre><code>` the
+ *   library renders — including the {@link CodeHighlighterComponent} settings field.
+ * - **The CodeMirror 5 mode registry** (`window.CodeMirror.modes[language]`) highlights a fenced code block
+ *   inside the editor.
+ *
+ * The CodeMirror 5 half looks like legacy that should be migrated to CodeMirror 6. **It is not** — verified
+ * against the Obsidian 1.13.4 runtime:
+ *
+ * - Obsidian's own CodeMirror 6 editor language is a bridged CodeMirror 5 mode:
+ *   `StreamLanguage.define(CodeMirror.getMode({}, { name: 'hypermd' }))`.
+ * - Obsidian registers that `hypermd` mode through `window.CodeMirror.defineMode` with
+ *   `fencedCodeBlockHighlighting: true`, and that option resolves each fence's language through the
+ *   **CodeMirror 5 mode registry**.
+ * - There is no public or internal CodeMirror 6 language-registration API for fences.
+ *
+ * So `window.CodeMirror.defineMode` is the sanctioned extension point, not legacy debt. Do not reopen this
+ * as a migration.
+ *
+ * Teardown REMOVES the mode rather than redefining it to `null`. Plugins predating this component redefined
+ * the mode to `null` on unload, because it was unclear whether CodeMirror's `getMode` needs the entry to
+ * stay present. It does not — verified against a live Obsidian 1.13.4 by
+ * `syntax-highlighting-component.obsidian.integration.test.ts`: after the entry is deleted, the fence
+ * renders its text with no error and drops back to the exact token count it had before the language was
+ * ever registered.
+ */
+import type { Grammar, PrismModule } from '@obsidian-typings/obsidian-public-latest';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * The loaded Prism module, handed to a grammar factory.
+ */
+export interface SyntaxHighlightingComponentGrammarFactoryParams {
+    /**
+     * The loaded Prism module.
+     */
+    readonly prism: PrismModule;
+    /**
+     * Returns the grammar of an already registered Prism language, for nesting into the built grammar.
+     *
+     * @param language - The language to look up.
+     * @returns The grammar of the language.
+     * @throws An {@link Error} if the language is not registered.
+     */
+    requirePrismLanguage(language: string): Grammar;
+}
+/**
+ * A grammar, the name of an already registered language to alias, or a factory that builds the grammar from
+ * the loaded Prism module.
+ */
+export type SyntaxHighlightingComponentGrammarSource = ((params: SyntaxHighlightingComponentGrammarFactoryParams) => Grammar) | Grammar | string;
+/**
+ * Parameters for {@link SyntaxHighlightingComponent.registerCodeBlockLanguageAsync}.
+ */
+export interface SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams {
+    /**
+     * The CodeMirror 5 mode name or MIME type the editor highlights the fence as, e.g. `text/typescript`.
+     */
+    readonly editorMode: string;
+    /**
+     * The fence language, e.g. the `foo` in a ` ```foo ` code block.
+     */
+    readonly language: string;
+    /**
+     * The grammar highlighting the fence in reading view. Omit when the fence is replaced in reading view —
+     * e.g. a fence rendered as a button.
+     */
+    readonly prismGrammar?: SyntaxHighlightingComponentGrammarSource | undefined;
+}
+/**
+ * Parameters for {@link SyntaxHighlightingComponent.registerPrismLanguageAsync}.
+ */
+export interface SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams {
+    /**
+     * The grammar to register.
+     */
+    readonly grammar: SyntaxHighlightingComponentGrammarSource;
+    /**
+     * The language to register the grammar as.
+     */
+    readonly language: string;
+}
+/**
+ * A component that registers and unregisters syntax highlighting languages.
+ *
+ * @remarks
+ * Every registration is undone when the component is unloaded: the previous entry is restored if the
+ * language was already registered, otherwise the entry is removed.
+ */
+export declare class SyntaxHighlightingComponent extends ComponentEx {
+    /**
+     * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.
+     *
+     * @param params - The parameters for registering the language.
+     * @returns A {@link Promise} that resolves when the language is registered.
+     *
+     * @example
+     * ```ts
+     * await component.registerCodeBlockLanguageAsync({
+     *   editorMode: 'text/typescript',
+     *   language: 'my-language',
+     *   prismGrammar: 'typescript'
+     * });
+     * ```
+     */
+    registerCodeBlockLanguageAsync(params: SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams): Promise<void>;
+    /**
+     * Registers a Prism language, highlighting it everywhere Prism renders code — reading view and the
+     * {@link CodeHighlighterComponent} settings field.
+     *
+     * @param params - The parameters for registering the language.
+     * @returns A {@link Promise} that resolves when the language is registered.
+     *
+     * @example
+     * ```ts
+     * await component.registerPrismLanguageAsync({
+     *   grammar: {
+     *     keyword: /\bfoo\b/
+     *   },
+     *   language: 'my-language'
+     * });
+     * ```
+     */
+    registerPrismLanguageAsync(params: SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams): Promise<void>;
+    /**
+     * Returns the grammar of an already registered Prism language.
+     *
+     * @param prism - The loaded Prism module.
+     * @param language - The language to look up.
+     * @returns The grammar of the language.
+     * @throws An {@link Error} if the language is not registered.
+     */
+    private requirePrismLanguage;
+    /**
+     * Resolves a grammar source into the grammar to register.
+     *
+     * @param prism - The loaded Prism module.
+     * @param grammarSource - The grammar source to resolve.
+     * @returns The resolved grammar.
+     */
+    private resolveGrammar;
+}

package/dist/lib/esm/obsidian/components/syntax-highlighting-component.mjs

@@ -0,0 +1,136 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { loadPrism } from "@obsidian-typings/obsidian-public-latest/implementations";
+import { throwExpression } from "../../error.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+class SyntaxHighlightingComponent extends ComponentEx {
+  /**
+   * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.
+   *
+   * @param params - The parameters for registering the language.
+   * @returns A {@link Promise} that resolves when the language is registered.
+   *
+   * @example
+   * ```ts
+   * await component.registerCodeBlockLanguageAsync({
+   *   editorMode: 'text/typescript',
+   *   language: 'my-language',
+   *   prismGrammar: 'typescript'
+   * });
+   * ```
+   */
+  async registerCodeBlockLanguageAsync(params) {
+    const {
+      editorMode,
+      language,
+      prismGrammar
+    } = params;
+    this.ensureLoaded();
+    if (prismGrammar !== void 0) {
+      await this.registerPrismLanguageAsync({
+        grammar: prismGrammar,
+        language
+      });
+    }
+    this.ensureLoaded();
+    const previousModeFactory = window.CodeMirror.modes[language];
+    window.CodeMirror.defineMode(language, (config) => window.CodeMirror.getMode(config, editorMode));
+    this.register(() => {
+      if (previousModeFactory !== void 0) {
+        window.CodeMirror.modes[language] = previousModeFactory;
+        return;
+      }
+      delete window.CodeMirror.modes[language];
+    });
+  }
+  /**
+   * Registers a Prism language, highlighting it everywhere Prism renders code — reading view and the
+   * {@link CodeHighlighterComponent} settings field.
+   *
+   * @param params - The parameters for registering the language.
+   * @returns A {@link Promise} that resolves when the language is registered.
+   *
+   * @example
+   * ```ts
+   * await component.registerPrismLanguageAsync({
+   *   grammar: {
+   *     keyword: /\bfoo\b/
+   *   },
+   *   language: 'my-language'
+   * });
+   * ```
+   */
+  async registerPrismLanguageAsync(params) {
+    const {
+      grammar,
+      language
+    } = params;
+    this.ensureLoaded();
+    const prism = await loadPrism();
+    this.ensureLoaded();
+    const previousGrammar = prism.languages[language];
+    prism.languages[language] = this.resolveGrammar(prism, grammar);
+    this.register(() => {
+      if (previousGrammar !== void 0) {
+        prism.languages[language] = previousGrammar;
+        return;
+      }
+      delete prism.languages[language];
+    });
+  }
+  /**
+   * Returns the grammar of an already registered Prism language.
+   *
+   * @param prism - The loaded Prism module.
+   * @param language - The language to look up.
+   * @returns The grammar of the language.
+   * @throws An {@link Error} if the language is not registered.
+   */
+  requirePrismLanguage(prism, language) {
+    return prism.languages[language] ?? throwExpression(new Error(`Prism language "${language}" is not registered.`));
+  }
+  /**
+   * Resolves a grammar source into the grammar to register.
+   *
+   * @param prism - The loaded Prism module.
+   * @param grammarSource - The grammar source to resolve.
+   * @returns The resolved grammar.
+   */
+  resolveGrammar(prism, grammarSource) {
+    if (typeof grammarSource === "string") {
+      return this.requirePrismLanguage(prism, grammarSource);
+    }
+    if (typeof grammarSource === "function") {
+      return grammarSource({
+        prism,
+        requirePrismLanguage: (language) => this.requirePrismLanguage(prism, language)
+      });
+    }
+    return grammarSource;
+  }
+}
+export {
+  SyntaxHighlightingComponent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/syntax-highlighting-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains class {@link SyntaxHighlightingComponent} that registers syntax highlighting languages.\n *\n * Obsidian highlights code in two independent places, through two separate registries, and a plugin adding\n * its own language usually has to touch both:\n *\n * - **Prism** (`prism.languages[language]`) highlights code in reading view and in every `<pre><code>` the\n *   library renders \u2014 including the {@link CodeHighlighterComponent} settings field.\n * - **The CodeMirror 5 mode registry** (`window.CodeMirror.modes[language]`) highlights a fenced code block\n *   inside the editor.\n *\n * The CodeMirror 5 half looks like legacy that should be migrated to CodeMirror 6. **It is not** \u2014 verified\n * against the Obsidian 1.13.4 runtime:\n *\n * - Obsidian's own CodeMirror 6 editor language is a bridged CodeMirror 5 mode:\n *   `StreamLanguage.define(CodeMirror.getMode({}, { name: 'hypermd' }))`.\n * - Obsidian registers that `hypermd` mode through `window.CodeMirror.defineMode` with\n *   `fencedCodeBlockHighlighting: true`, and that option resolves each fence's language through the\n *   **CodeMirror 5 mode registry**.\n * - There is no public or internal CodeMirror 6 language-registration API for fences.\n *\n * So `window.CodeMirror.defineMode` is the sanctioned extension point, not legacy debt. Do not reopen this\n * as a migration.\n *\n * Teardown REMOVES the mode rather than redefining it to `null`. Plugins predating this component redefined\n * the mode to `null` on unload, because it was unclear whether CodeMirror's `getMode` needs the entry to\n * stay present. It does not \u2014 verified against a live Obsidian 1.13.4 by\n * `syntax-highlighting-component.obsidian.integration.test.ts`: after the entry is deleted, the fence\n * renders its text with no error and drops back to the exact token count it had before the language was\n * ever registered.\n */\n\nimport type {\n  Grammar,\n  PrismModule\n} from '@obsidian-typings/obsidian-public-latest';\n\nimport { loadPrism } from '@obsidian-typings/obsidian-public-latest/implementations';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `CodeHighlighterComponent` to use it in the tsdocs.\nimport type { CodeHighlighterComponent } from '../setting-components/code-highlighter-component.ts';\n\nimport { throwExpression } from '../../error.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * The loaded Prism module, handed to a grammar factory.\n */\nexport interface SyntaxHighlightingComponentGrammarFactoryParams {\n  /**\n   * The loaded Prism module.\n   */\n  readonly prism: PrismModule;\n\n  /**\n   * Returns the grammar of an already registered Prism language, for nesting into the built grammar.\n   *\n   * @param language - The language to look up.\n   * @returns The grammar of the language.\n   * @throws An {@link Error} if the language is not registered.\n   */\n  requirePrismLanguage(language: string): Grammar;\n}\n\n/**\n * A grammar, the name of an already registered language to alias, or a factory that builds the grammar from\n * the loaded Prism module.\n */\nexport type SyntaxHighlightingComponentGrammarSource = ((params: SyntaxHighlightingComponentGrammarFactoryParams) => Grammar) | Grammar | string;\n\n/**\n * Parameters for {@link SyntaxHighlightingComponent.registerCodeBlockLanguageAsync}.\n */\nexport interface SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams {\n  /**\n   * The CodeMirror 5 mode name or MIME type the editor highlights the fence as, e.g. `text/typescript`.\n   */\n  readonly editorMode: string;\n\n  /**\n   * The fence language, e.g. the `foo` in a ` ```foo ` code block.\n   */\n  readonly language: string;\n\n  /**\n   * The grammar highlighting the fence in reading view. Omit when the fence is replaced in reading view \u2014\n   * e.g. a fence rendered as a button.\n   */\n  readonly prismGrammar?: SyntaxHighlightingComponentGrammarSource | undefined;\n}\n\n/**\n * Parameters for {@link SyntaxHighlightingComponent.registerPrismLanguageAsync}.\n */\nexport interface SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams {\n  /**\n   * The grammar to register.\n   */\n  readonly grammar: SyntaxHighlightingComponentGrammarSource;\n\n  /**\n   * The language to register the grammar as.\n   */\n  readonly language: string;\n}\n\n/**\n * A component that registers and unregisters syntax highlighting languages.\n *\n * @remarks\n * Every registration is undone when the component is unloaded: the previous entry is restored if the\n * language was already registered, otherwise the entry is removed.\n */\nexport class SyntaxHighlightingComponent extends ComponentEx {\n  /**\n   * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.\n   *\n   * @param params - The parameters for registering the language.\n   * @returns A {@link Promise} that resolves when the language is registered.\n   *\n   * @example\n   * ```ts\n   * await component.registerCodeBlockLanguageAsync({\n   *   editorMode: 'text/typescript',\n   *   language: 'my-language',\n   *   prismGrammar: 'typescript'\n   * });\n   * ```\n   */\n  public async registerCodeBlockLanguageAsync(params: SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams): Promise<void> {\n    const {\n      editorMode,\n      language,\n      prismGrammar\n    } = params;\n\n    this.ensureLoaded();\n\n    if (prismGrammar !== undefined) {\n      await this.registerPrismLanguageAsync({\n        grammar: prismGrammar,\n        language\n      });\n    }\n\n    this.ensureLoaded();\n\n    const previousModeFactory = window.CodeMirror.modes[language];\n    window.CodeMirror.defineMode(language, (config) => window.CodeMirror.getMode(config, editorMode));\n\n    this.register(() => {\n      if (previousModeFactory !== undefined) {\n        window.CodeMirror.modes[language] = previousModeFactory;\n        return;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The language is only known at runtime.\n      delete window.CodeMirror.modes[language];\n    });\n  }\n\n  /**\n   * Registers a Prism language, highlighting it everywhere Prism renders code \u2014 reading view and the\n   * {@link CodeHighlighterComponent} settings field.\n   *\n   * @param params - The parameters for registering the language.\n   * @returns A {@link Promise} that resolves when the language is registered.\n   *\n   * @example\n   * ```ts\n   * await component.registerPrismLanguageAsync({\n   *   grammar: {\n   *     keyword: /\\bfoo\\b/\n   *   },\n   *   language: 'my-language'\n   * });\n   * ```\n   */\n  public async registerPrismLanguageAsync(params: SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams): Promise<void> {\n    const {\n      grammar,\n      language\n    } = params;\n\n    this.ensureLoaded();\n\n    const prism = await loadPrism();\n\n    // The component might have been unloaded while Prism was loading.\n    this.ensureLoaded();\n\n    const previousGrammar = prism.languages[language];\n    prism.languages[language] = this.resolveGrammar(prism, grammar);\n\n    this.register(() => {\n      if (previousGrammar !== undefined) {\n        prism.languages[language] = previousGrammar;\n        return;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The language is only known at runtime.\n      delete prism.languages[language];\n    });\n  }\n\n  /**\n   * Returns the grammar of an already registered Prism language.\n   *\n   * @param prism - The loaded Prism module.\n   * @param language - The language to look up.\n   * @returns The grammar of the language.\n   * @throws An {@link Error} if the language is not registered.\n   */\n  private requirePrismLanguage(prism: PrismModule, language: string): Grammar {\n    return prism.languages[language] ?? throwExpression(new Error(`Prism language \"${language}\" is not registered.`));\n  }\n\n  /**\n   * Resolves a grammar source into the grammar to register.\n   *\n   * @param prism - The loaded Prism module.\n   * @param grammarSource - The grammar source to resolve.\n   * @returns The resolved grammar.\n   */\n  private resolveGrammar(prism: PrismModule, grammarSource: SyntaxHighlightingComponentGrammarSource): Grammar {\n    if (typeof grammarSource === 'string') {\n      return this.requirePrismLanguage(prism, grammarSource);\n    }\n\n    if (typeof grammarSource === 'function') {\n      return grammarSource({\n        prism,\n        requirePrismLanguage: (language) => this.requirePrismLanguage(prism, language)\n      });\n    }\n\n    return grammarSource;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAS,iBAAiB;AAK1B,SAAS,uBAAuB;AAChC,SAAS,mBAAmB;AAsErB,MAAM,oCAAoC,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgB3D,MAAa,+BAA+B,QAAwF;AAClI,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AAEJ,SAAK,aAAa;AAElB,QAAI,iBAAiB,QAAW;AAC9B,YAAM,KAAK,2BAA2B;AAAA,QACpC,SAAS;AAAA,QACT;AAAA,MACF,CAAC;AAAA,IACH;AAEA,SAAK,aAAa;AAElB,UAAM,sBAAsB,OAAO,WAAW,MAAM,QAAQ;AAC5D,WAAO,WAAW,WAAW,UAAU,CAAC,WAAW,OAAO,WAAW,QAAQ,QAAQ,UAAU,CAAC;AAEhG,SAAK,SAAS,MAAM;AAClB,UAAI,wBAAwB,QAAW;AACrC,eAAO,WAAW,MAAM,QAAQ,IAAI;AACpC;AAAA,MACF;AAGA,aAAO,OAAO,WAAW,MAAM,QAAQ;AAAA,IACzC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAa,2BAA2B,QAAoF;AAC1H,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,IACF,IAAI;AAEJ,SAAK,aAAa;AAElB,UAAM,QAAQ,MAAM,UAAU;AAG9B,SAAK,aAAa;AAElB,UAAM,kBAAkB,MAAM,UAAU,QAAQ;AAChD,UAAM,UAAU,QAAQ,IAAI,KAAK,eAAe,OAAO,OAAO;AAE9D,SAAK,SAAS,MAAM;AAClB,UAAI,oBAAoB,QAAW;AACjC,cAAM,UAAU,QAAQ,IAAI;AAC5B;AAAA,MACF;AAGA,aAAO,MAAM,UAAU,QAAQ;AAAA,IACjC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUQ,qBAAqB,OAAoB,UAA2B;AAC1E,WAAO,MAAM,UAAU,QAAQ,KAAK,gBAAgB,IAAI,MAAM,mBAAmB,QAAQ,sBAAsB,CAAC;AAAA,EAClH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,eAAe,OAAoB,eAAkE;AAC3G,QAAI,OAAO,kBAAkB,UAAU;AACrC,aAAO,KAAK,qBAAqB,OAAO,aAAa;AAAA,IACvD;AAEA,QAAI,OAAO,kBAAkB,YAAY;AACvC,aAAO,cAAc;AAAA,QACnB;AAAA,QACA,sBAAsB,CAAC,aAAa,KAAK,qBAAqB,OAAO,QAAQ;AAAA,MAC/E,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AACF;",
  "names": []
}


package/dist/lib/esm/obsidian/plugin/plugin-settings-tab.d.mts

@@ -5,12 +5,13 @@
  * This module defines a base class for creating plugin setting tabs in Obsidian.
  * It provides a utility method to bind value components to plugin settings and handle changes.
  */
-import type { Plugin } from 'obsidian';
-import type { ConditionalKeys, Promisable, ReadonlyDeep } from 'type-fest';
+import type { Plugin, SettingDefinitionGroup, SettingDefinitionItem, SettingDefinitionRender, SettingGroup } from 'obsidian';
+import type { ConditionalKeys, Except, Promisable, ReadonlyDeep } from 'type-fest';
 import { PluginSettingTab } from 'obsidian';
 import type { StringKeys } from '../../type.mjs';
 import type { PluginSettingsComponentBase, ReadonlyPluginSettingsState } from '../components/plugin-settings-component.mjs';
 import type { ValueComponentWithChangeTracking } from '../setting-components/value-component-with-change-tracking.mjs';
+import type { SettingEx } from '../setting-ex.mjs';
 import type { ValidationMessageHolder } from '../validation.mjs';
 /**
  * A context passed to the {@link PluginSettingsComponentBase.saveToFile} method.
@@ -120,6 +121,60 @@ export interface PluginSettingsTabBaseConstructorParams<PluginSettings extends o
      */
     readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;
 }
+/**
+ * Params for {@link PluginSettingsTabBase.settingEx}.
+ */
+export interface PluginSettingsTabBaseSettingExParams {
+    /**
+     * Additional search terms for the setting.
+     */
+    readonly aliases?: string[];
+    /**
+     * The description of the setting. Used for rendering; the text content of a fragment is used for search.
+     */
+    readonly desc?: DocumentFragment | string;
+    /**
+     * Whether the setting row is disabled.
+     *
+     * A function form is re-evaluated on every render AND on every {@link PluginSettingsTabBase.refreshDomState}
+     * call, so it can reflect runtime state. Obsidian applies it with `Setting.setDisabled`, which disables the
+     * row and every component registered on it.
+     */
+    readonly disabled?: (() => boolean) | boolean;
+    /**
+     * The display name of the setting. Used for rendering and search.
+     */
+    readonly name: string;
+    /**
+     * Renders the setting row imperatively, typically via the {@link SettingEx} adders and
+     * {@link PluginSettingsTabBase.bind}.
+     *
+     * The setting Obsidian creates for the row is adopted into a {@link SettingEx} before it is handed over, so
+     * an imperative row body carries over unchanged. May return a cleanup function, invoked before the row is
+     * torn down or re-rendered.
+     *
+     * @param setting - The setting to render into.
+     * @param group - The group the setting belongs to.
+     * @returns An optional cleanup function.
+     */
+    render(setting: SettingEx, group: SettingGroup): (() => void) | void;
+    /**
+     * Controls whether the setting is included in the settings search. Defaults to `true`.
+     */
+    readonly searchable?: (() => boolean) | boolean;
+    /**
+     * Controls whether the setting row is rendered. A function form is re-evaluated on every render and on
+     * every {@link PluginSettingsTabBase.refreshDomState} call. Defaults to `true`.
+     */
+    readonly visible?: (() => boolean) | boolean;
+}
+/**
+ * Params for {@link PluginSettingsTabBase.settingGroupEx}.
+ *
+ * Every member of {@link SettingDefinitionGroup} except its discriminator, which
+ * {@link PluginSettingsTabBase.settingGroupEx} sets.
+ */
+export type PluginSettingsTabBaseSettingGroupExParams = Except<SettingDefinitionGroup, 'type'>;
 interface PluginSettingsTabBaseEventMap {
     validationMessageChanged: [propertyName: string, validationMessage: string];
 }
@@ -149,6 +204,7 @@ export declare abstract class PluginSettingsTabBase<PluginSettings extends objec
     protected get saveSettingsDebounceTimeoutInMilliseconds(): number;
     private _isOpen;
     private readonly component;
+    private currentRenderComponent;
     private readonly saveSettingsDebounced;
     private get pluginSettings();
     /**
@@ -181,11 +237,33 @@ export declare abstract class PluginSettingsTabBase<PluginSettings extends objec
      */
     display(): void;
     /**
-     * Legacy way to render the plugin settings tab.
+     * Legacy way to render the plugin settings tab imperatively.
      *
-     * Temporary workaround to avoid dealing with `@deprecated`.
+     * The pre-declarative fallback: Obsidian only calls it when {@link getSettingDefinitions} returns an empty
+     * array, i.e. when the consumer has not overridden {@link getSettingDefinitionItems}. Such a consumer
+     * overrides this method and builds the UI with {@link SettingEx} and {@link bind}.
      */
     displayLegacy(): void;
+    /**
+     * Reads the value backing a native `control` setting definition.
+     *
+     * Obsidian calls it on every render of a `control`-type definition. The inherited implementation reads
+     * `plugin.settings`, which a plugin built on {@link PluginSettingsComponentBase} never populates, so it is
+     * routed to the settings component instead.
+     *
+     * @param key - The settings property name.
+     * @returns The current value.
+     */
+    getControlValue(key: string): unknown;
+    /**
+     * Returns the declarative setting definitions rendered by Obsidian 1.13+.
+     *
+     * Delegates to {@link getSettingDefinitionItems}. When a consumer has not overridden that hook it returns
+     * an empty array, and Obsidian falls back to the imperative {@link displayLegacy} path.
+     *
+     * @returns The setting definitions.
+     */
+    getSettingDefinitions(): SettingDefinitionItem[];
     /**
      * Hides the plugin settings tab.
      */
@@ -196,10 +274,50 @@ export declare abstract class PluginSettingsTabBase<PluginSettings extends objec
      * @returns A {@link Promise} that resolves when the settings tab is hidden.
      */
     hideAsync(): Promise<void>;
+    /**
+     * Re-renders the settings tab after the underlying state changed.
+     *
+     * Rebuilds the definitions and re-renders, which covers both paths: Obsidian renders the declarative
+     * definitions when {@link getSettingDefinitionItems} provides them, and falls back to
+     * {@link displayLegacy} when it does not. Nothing is rendered while the tab is not the one on screen.
+     *
+     * Use it only for changes that alter the STRUCTURE of the tab — rows added or removed. When only a
+     * {@link PluginSettingsTabBaseSettingExParams.disabled} / {@link PluginSettingsTabBaseSettingExParams.visible}
+     * predicate has to be re-evaluated, call the much cheaper {@link refreshDomState} instead, which toggles the
+     * rendered DOM in place.
+     */
+    refresh(): void;
+    /**
+     * Persists the value of a native `control` setting definition.
+     *
+     * The counterpart of {@link getControlValue}: it routes the write to the settings component instead of the
+     * inherited `plugin.saveData` path, so validation, transformers and the debounced save all apply as they do
+     * for a {@link bind}-ed component.
+     *
+     * @param key - The settings property name.
+     * @param value - The value to persist.
+     * @returns A {@link Promise} that resolves when the value is set.
+     */
+    setControlValue(key: string, value: unknown): Promise<void>;
     /**
      * Shows the plugin settings tab.
      */
     show(): void;
+    /**
+     * The declarative setting definitions for the tab (Obsidian 1.13+).
+     *
+     * Consumers override this, typically building each row with {@link settingEx} and {@link bind} and grouping
+     * them with `settingGroupEx`. Returning an empty array — the default — makes Obsidian fall back to the
+     * imperative {@link displayLegacy} path.
+     *
+     * MUST be a pure builder. Obsidian calls it when the tab is registered (`addSettingTab`), long before the
+     * tab is ever opened, in order to index the settings for search. Anything with a side effect belongs inside
+     * a row's {@link PluginSettingsTabBaseSettingExParams.render} callback, which runs only when the row is
+     * actually rendered.
+     *
+     * @returns The setting definitions.
+     */
+    protected getSettingDefinitionItems(): SettingDefinitionItem[];
     /**
      * Called when the plugin settings are loaded.
      *
@@ -214,8 +332,37 @@ export declare abstract class PluginSettingsTabBase<PluginSettings extends objec
      * @returns A {@link Promise} that resolves when the settings are revalidated.
      */
     protected revalidate(): Promise<void>;
+    /**
+     * Builds a search-indexable declarative row that is rendered imperatively.
+     *
+     * The bridge between the declarative API and ODU's imperative building blocks: Obsidian owns the row (so it
+     * indexes it for search and evaluates its {@link PluginSettingsTabBaseSettingExParams.visible} /
+     * {@link PluginSettingsTabBaseSettingExParams.disabled} predicates on every
+     * {@link refreshDomState}), while {@link PluginSettingsTabBaseSettingExParams.render} fills it in with
+     * {@link SettingEx} adders and {@link bind} exactly as an imperative tab would.
+     *
+     * @param params - The row params.
+     * @returns The setting definition.
+     */
+    protected settingEx(params: PluginSettingsTabBaseSettingExParams): SettingDefinitionRender;
+    /**
+     * Builds a declarative heading group.
+     *
+     * The declarative counterpart of `SettingGroupEx`: where that class appends a group to a container
+     * imperatively, this returns the definition Obsidian renders, so a group-structured tab keeps its shape
+     * after the migration.
+     *
+     * @param params - The group params.
+     * @returns The group definition.
+     */
+    protected settingGroupEx(params: PluginSettingsTabBaseSettingGroupExParams): SettingDefinitionGroup;
+    private beginRenderCycle;
+    private createRenderComponent;
+    private endRenderCycle;
     private getPluginSettingsProperty;
+    private getRenderComponent;
     private onSaveSettings;
+    private renderSettingEx;
     private updateValidations;
 }
 export {};