@mnaoumov/obsidian-lib 10.4.0 → 10.5.0

package/dist/lib/esm/components/embeddable-markdown-editor-component.d.mts

@@ -0,0 +1,221 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Contains class {@link EmbeddableMarkdownEditorComponent}: a full Obsidian Markdown editor (Live Preview, editor
+ * commands, hotkeys) mounted in any element and owned as a component.
+ *
+ * Obsidian does not export its editor class, so the component borrows it from a throwaway Markdown embed: an editable
+ * embed builds an iframed editor whose grandparent prototype is the scrollable Markdown editor every embed and table
+ * cell editor uses. The probe opens no leaf and fires no workspace event (`embeddable-markdown-editor-component
+ * .obsidian.integration.test.ts` measures that), and it runs once per copy of this library, on first use rather than at
+ * module load. The class is cached per copy and never in the shared-state bag, because a constructor is not plain data.
+ *
+ * Adapted from the "Embeddable CM Markdown Editor" gist
+ * (https://gist.github.com/Fevol/caa478ce303e69eabede7b12b2323838), itself a rework of the `Kanban` plugin's
+ * `src/components/Editor/MarkdownEditor.tsx`, under the MIT license below.
+ *
+ * Copyright 2024 Matthew Meyers, Fevol
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the “Software”), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import type { Extension } from '@codemirror/state';
+import type { ViewUpdate } from '@codemirror/view';
+import type { App, Editor } from 'obsidian';
+import { EditorView } from '@codemirror/view';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * The parameters of the {@link EmbeddableMarkdownEditorComponent} constructor.
+ */
+export interface EmbeddableMarkdownEditorComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * A CSS class added to the editor element.
+     */
+    readonly cls?: string;
+    /**
+     * The element the editor is mounted in. The editor appends its own element to it and removes only that element when
+     * it unloads.
+     */
+    readonly containerEl: HTMLElement;
+    /**
+     * The initial selection, as document offsets. The cursor starts at the beginning of the document otherwise.
+     */
+    readonly cursorLocation?: EmbeddableMarkdownEditorComponentSelection;
+    /**
+     * Called when the editor loses focus, while the component is still loaded.
+     */
+    readonly onBlur?: (component: EmbeddableMarkdownEditorComponent) => void;
+    /**
+     * Called after every change to the document.
+     */
+    readonly onChange?: (update: ViewUpdate, component: EmbeddableMarkdownEditorComponent) => void;
+    /**
+     * Called on `Enter`, `Shift+Enter`, `Mod+Enter` and `Mod+Shift+Enter`.
+     *
+     * When given, `Mod+Enter` no longer runs the Obsidian hotkey bound to it (by default, opening the link under the
+     * cursor in a new tab) while the editor has the focus, so a form can use it to submit.
+     *
+     * @returns `true` when the key was handled, which stops the editor inserting a line break; `false` otherwise.
+     */
+    readonly onEnter?: (params: EmbeddableMarkdownEditorComponentEnterParams) => boolean;
+    /**
+     * Called on `Escape`. When given, the key goes no further.
+     */
+    readonly onEscape?: (component: EmbeddableMarkdownEditorComponent) => void;
+    /**
+     * Called on a paste into the editor, before the editor handles it.
+     */
+    readonly onPaste?: ($event: ClipboardEvent, component: EmbeddableMarkdownEditorComponent) => void;
+    /**
+     * The text shown while the document is empty.
+     */
+    readonly placeholder?: string;
+    /**
+     * The initial document.
+     */
+    readonly value?: string;
+}
+/**
+ * The parameters of {@link EmbeddableMarkdownEditorComponentConstructorParams.onEnter}.
+ */
+export interface EmbeddableMarkdownEditorComponentEnterParams {
+    /**
+     * The editor component the key was pressed in.
+     */
+    readonly component: EmbeddableMarkdownEditorComponent;
+    /**
+     * Whether the platform modifier (`Ctrl`, or `Cmd` on macOS) was held.
+     */
+    readonly isModifierPressed: boolean;
+    /**
+     * Whether `Shift` was held.
+     */
+    readonly isShiftPressed: boolean;
+}
+/**
+ * A selection in an {@link EmbeddableMarkdownEditorComponent}, as document offsets.
+ */
+export interface EmbeddableMarkdownEditorComponentSelection {
+    /**
+     * The offset the selection starts from.
+     */
+    readonly anchor: number;
+    /**
+     * The offset the selection extends to, where the cursor is.
+     */
+    readonly head: number;
+}
+/**
+ * A full Obsidian Markdown editor mounted in any element: Live Preview, editor commands, hotkeys and the editor
+ * suggesters all work in it as they do in a note.
+ *
+ * Add it as a child of the component that owns its element; unloading it destroys the editor and removes the editor's
+ * element. It works on desktop and mobile.
+ *
+ * @example
+ * ```ts
+ * const editorComponent = this.addChild(new EmbeddableMarkdownEditorComponent({
+ *   app: this.app,
+ *   containerEl,
+ *   onEnter: ({ component, isModifierPressed }) => {
+ *     if (!isModifierPressed) {
+ *       return false;
+ *     }
+ *     save(component.value);
+ *     return true;
+ *   },
+ *   value: 'Initial text'
+ * }));
+ * ```
+ */
+export declare class EmbeddableMarkdownEditorComponent extends ComponentEx {
+    /**
+     * The Obsidian editor, as in a note.
+     *
+     * @returns The editor.
+     */
+    get editor(): Editor;
+    /**
+     * The CodeMirror view behind the editor.
+     *
+     * @returns The CodeMirror view.
+     */
+    get editorView(): EditorView;
+    /**
+     * The current document.
+     *
+     * @returns The document text.
+     */
+    get value(): string;
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The element the editor is mounted in.
+     */
+    protected readonly containerEl: HTMLElement;
+    private readonly cls;
+    private readonly cursorLocation;
+    private readonly initialValue;
+    private readonly keymapScope;
+    private readonly onBlur;
+    private readonly onChange;
+    private readonly onEnter;
+    private readonly onEscape;
+    private readonly onPaste;
+    private readonly owner;
+    private readonly placeholderText;
+    private scrollableEditor;
+    /**
+     * Creates the component. The editor is built when the component loads.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: EmbeddableMarkdownEditorComponentConstructorParams);
+    /**
+     * Focuses the editor.
+     */
+    focus(): void;
+    /**
+     * Builds the editor and mounts it in the container.
+     */
+    onload(): void;
+    /**
+     * Replaces the document.
+     *
+     * @param value - The new document.
+     */
+    setValue(value: string): void;
+    /**
+     * Builds the editor's own extensions: the placeholder, the focus and paste handlers, and the key handlers.
+     *
+     * @returns The extensions.
+     */
+    protected buildExtensions(): Extension[];
+    /**
+     * Called after every update of the editor, with whether the document changed.
+     *
+     * @param update - The CodeMirror update.
+     * @param isChanged - Whether the document changed.
+     */
+    protected handleUpdate(update: ViewUpdate, isChanged: boolean): void;
+    private getScrollableEditor;
+    private isEnterHandled;
+}

package/dist/lib/esm/components/embeddable-markdown-editor-component.mjs

@@ -0,0 +1,293 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import {
+  EditorSelection,
+  Prec
+} from "@codemirror/state";
+import {
+  EditorView,
+  keymap,
+  placeholder
+} from "@codemirror/view";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { castTo } from "@mnaoumov/typescript-lib/object-utils";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { Scope } from "obsidian";
+import { ComponentEx } from "./component-ex.mjs";
+import { MonkeyAroundComponent } from "./monkey-around-component.mjs";
+const scrollableMarkdownEditorConstructorCache = { value: null };
+class EmbeddableMarkdownEditorComponent extends ComponentEx {
+  /**
+   * The Obsidian editor, as in a note.
+   *
+   * @returns The editor.
+   */
+  get editor() {
+    return ensureNonNullable(this.getScrollableEditor().editor);
+  }
+  /**
+   * The CodeMirror view behind the editor.
+   *
+   * @returns The CodeMirror view.
+   */
+  get editorView() {
+    return this.getScrollableEditor().cm;
+  }
+  /**
+   * The current document.
+   *
+   * @returns The document text.
+   */
+  get value() {
+    return this.getScrollableEditor().cm.state.doc.toString();
+  }
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The element the editor is mounted in.
+   */
+  containerEl;
+  cls;
+  cursorLocation;
+  initialValue;
+  keymapScope;
+  onBlur;
+  onChange;
+  onEnter;
+  onEscape;
+  onPaste;
+  owner;
+  placeholderText;
+  scrollableEditor = null;
+  /**
+   * Creates the component. The editor is built when the component loads.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.containerEl = params.containerEl;
+    this.cls = params.cls ?? "";
+    this.cursorLocation = params.cursorLocation ?? null;
+    this.initialValue = params.value ?? "";
+    this.onBlur = params.onBlur ?? null;
+    this.onChange = params.onChange ?? null;
+    this.onEnter = params.onEnter ?? null;
+    this.onEscape = params.onEscape ?? null;
+    this.onPaste = params.onPaste ?? null;
+    this.placeholderText = params.placeholder ?? "";
+    this.keymapScope = new Scope(params.app.scope);
+    this.owner = {
+      app: params.app,
+      editMode: null,
+      file: null,
+      getMode: () => "source",
+      hoverPopover: null,
+      syncScroll: noop
+    };
+  }
+  /**
+   * Focuses the editor.
+   */
+  focus() {
+    this.getScrollableEditor().focus();
+  }
+  /**
+   * Builds the editor and mounts it in the container.
+   */
+  onload() {
+    super.onload();
+    const EditorConstructor = createEditorClass(getScrollableMarkdownEditorConstructor(this.app));
+    const scrollableEditor = new EditorConstructor(this.app, this.containerEl, this.owner, {
+      buildExtensions: () => this.buildExtensions(),
+      handleUpdate: (update, isChanged) => {
+        this.handleUpdate(update, isChanged);
+      }
+    });
+    this.scrollableEditor = scrollableEditor;
+    this.owner.editMode = scrollableEditor;
+    this.owner.editor = ensureNonNullable(scrollableEditor.editor);
+    this.addChild(scrollableEditor);
+    if (this.onEnter) {
+      const submitHotkeyHandler = this.keymapScope.register(["Mod"], "Enter", () => true);
+      this.register(() => {
+        this.keymapScope.unregister(submitHotkeyHandler);
+      });
+    }
+    if (this.cls) {
+      scrollableEditor.editorEl.addClass(this.cls);
+    }
+    scrollableEditor.set(this.initialValue, false);
+    if (this.cursorLocation) {
+      scrollableEditor.cm.dispatch({
+        selection: EditorSelection.range(this.cursorLocation.anchor, this.cursorLocation.head)
+      });
+    }
+    const focusGuardPatchComponent = this.addChild(new MonkeyAroundComponent());
+    focusGuardPatchComponent.registerMethodPatch({
+      $object: this.app.workspace,
+      methodName: "setActiveLeaf",
+      patchHandler: ({ fallback }) => {
+        if (scrollableEditor.activeCM.hasFocus) {
+          return;
+        }
+        fallback();
+      }
+    });
+    this.register(() => {
+      this.app.keymap.popScope(this.keymapScope);
+      if (this.app.workspace.activeEditor === this.owner) {
+        this.app.workspace.activeEditor = null;
+      }
+      scrollableEditor.destroy();
+      scrollableEditor.editorEl.remove();
+      this.owner.editMode = null;
+      delete this.owner.editor;
+      this.scrollableEditor = null;
+    });
+  }
+  /**
+   * Replaces the document.
+   *
+   * @param value - The new document.
+   */
+  setValue(value) {
+    this.getScrollableEditor().set(value, false);
+  }
+  /**
+   * Builds the editor's own extensions: the placeholder, the focus and paste handlers, and the key handlers.
+   *
+   * @returns The extensions.
+   */
+  buildExtensions() {
+    const extensions = [
+      EditorView.domEventHandlers({
+        blur: () => {
+          this.app.keymap.popScope(this.keymapScope);
+          if (this._loaded) {
+            this.onBlur?.(this);
+          }
+        },
+        focus: () => {
+          this.app.keymap.pushScope(this.keymapScope);
+        },
+        paste: ($event) => {
+          this.onPaste?.($event, this);
+        }
+      }),
+      Prec.highest(keymap.of([
+        {
+          key: "Enter",
+          run: () => this.isEnterHandled(false, false),
+          shift: () => this.isEnterHandled(false, true)
+        },
+        {
+          key: "Mod-Enter",
+          run: () => this.isEnterHandled(true, false),
+          shift: () => this.isEnterHandled(true, true)
+        },
+        {
+          key: "Escape",
+          preventDefault: true,
+          run: () => {
+            if (!this.onEscape) {
+              return false;
+            }
+            this.onEscape(this);
+            return true;
+          }
+        }
+      ]))
+    ];
+    if (this.placeholderText) {
+      extensions.push(placeholder(this.placeholderText));
+    }
+    return extensions;
+  }
+  /**
+   * Called after every update of the editor, with whether the document changed.
+   *
+   * @param update - The CodeMirror update.
+   * @param isChanged - Whether the document changed.
+   */
+  handleUpdate(update, isChanged) {
+    if (isChanged) {
+      this.onChange?.(update, this);
+    }
+  }
+  getScrollableEditor() {
+    return ensureNonNullable(this.scrollableEditor, "The editor is built when the component loads.");
+  }
+  isEnterHandled(isModifierPressed, isShiftPressed) {
+    return this.onEnter?.({ component: this, isModifierPressed, isShiftPressed }) ?? false;
+  }
+}
+function createEditorClass(BaseConstructor) {
+  return class EmbeddedScrollableMarkdownEditor extends BaseConstructor {
+    constructor(app, containerEl, owner, hooks) {
+      super(app, containerEl, owner);
+      this.hooks = hooks;
+    }
+    hooks;
+    buildLocalExtensions() {
+      return [...super.buildLocalExtensions(), ...this.hooks.buildExtensions()];
+    }
+    onUpdate(update, isChanged) {
+      super.onUpdate(update, isChanged);
+      this.hooks.handleUpdate(update, isChanged);
+    }
+  };
+}
+function getScrollableMarkdownEditorConstructor(app) {
+  if (scrollableMarkdownEditorConstructorCache.value) {
+    return scrollableMarkdownEditorConstructorCache.value;
+  }
+  const widgetEditorView = castTo(app.embedRegistry.embedByExtension.md({ app, containerEl: createDiv() }, castTo(null), ""));
+  try {
+    widgetEditorView.editable = true;
+    widgetEditorView.showEditor();
+    const iframedEditor = ensureNonNullable(widgetEditorView.editMode, "The Markdown embed built no editor.");
+    const scrollableEditorPrototype = castTo(Object.getPrototypeOf(Object.getPrototypeOf(iframedEditor)));
+    scrollableMarkdownEditorConstructorCache.value = scrollableEditorPrototype.constructor;
+    return scrollableEditorPrototype.constructor;
+  } finally {
+    widgetEditorView.unload();
+  }
+}
+export {
+  EmbeddableMarkdownEditorComponent
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/embeddable-markdown-editor-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains class {@link EmbeddableMarkdownEditorComponent}: a full Obsidian Markdown editor (Live Preview, editor\n * commands, hotkeys) mounted in any element and owned as a component.\n *\n * Obsidian does not export its editor class, so the component borrows it from a throwaway Markdown embed: an editable\n * embed builds an iframed editor whose grandparent prototype is the scrollable Markdown editor every embed and table\n * cell editor uses. The probe opens no leaf and fires no workspace event (`embeddable-markdown-editor-component\n * .obsidian.integration.test.ts` measures that), and it runs once per copy of this library, on first use rather than at\n * module load. The class is cached per copy and never in the shared-state bag, because a constructor is not plain data.\n *\n * Adapted from the \"Embeddable CM Markdown Editor\" gist\n * (https://gist.github.com/Fevol/caa478ce303e69eabede7b12b2323838), itself a rework of the `Kanban` plugin's\n * `src/components/Editor/MarkdownEditor.tsx`, under the MIT license below.\n *\n * Copyright 2024 Matthew Meyers, Fevol\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated\n * documentation files (the “Software”), to deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the\n * Software.\n *\n * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE\n * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n\n// cspell:words Fevol -- The gist author's handle, as the license notice above names it.\n\n/* v8 ignore start -- Builds on Obsidian's unexported editor class, which only a running Obsidian has; covered by its integration test. */\n\nimport type { Extension } from '@codemirror/state';\nimport type { ViewUpdate } from '@codemirror/view';\nimport type {\n  ExtractConstructor,\n  MarkdownScrollableEditView,\n  MarkdownScrollableEditViewOwner,\n  WidgetEditorView\n} from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  Editor,\n  TFile\n} from 'obsidian';\n\nimport {\n  EditorSelection,\n  Prec\n} from '@codemirror/state';\nimport {\n  EditorView,\n  keymap,\n  placeholder\n} from '@codemirror/view';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { castTo } from '@mnaoumov/typescript-lib/object-utils';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { Scope } from 'obsidian';\n\nimport { ComponentEx } from './component-ex.ts';\nimport { MonkeyAroundComponent } from './monkey-around-component.ts';\n\n/**\n * The parameters of the {@link EmbeddableMarkdownEditorComponent} constructor.\n */\nexport interface EmbeddableMarkdownEditorComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * A CSS class added to the editor element.\n   */\n  readonly cls?: string;\n\n  /**\n   * The element the editor is mounted in. The editor appends its own element to it and removes only that element when\n   * it unloads.\n   */\n  readonly containerEl: HTMLElement;\n\n  /**\n   * The initial selection, as document offsets. The cursor starts at the beginning of the document otherwise.\n   */\n  readonly cursorLocation?: EmbeddableMarkdownEditorComponentSelection;\n\n  /**\n   * Called when the editor loses focus, while the component is still loaded.\n   */\n  readonly onBlur?: (component: EmbeddableMarkdownEditorComponent) => void;\n\n  /**\n   * Called after every change to the document.\n   */\n  readonly onChange?: (update: ViewUpdate, component: EmbeddableMarkdownEditorComponent) => void;\n\n  /**\n   * Called on `Enter`, `Shift+Enter`, `Mod+Enter` and `Mod+Shift+Enter`.\n   *\n   * When given, `Mod+Enter` no longer runs the Obsidian hotkey bound to it (by default, opening the link under the\n   * cursor in a new tab) while the editor has the focus, so a form can use it to submit.\n   *\n   * @returns `true` when the key was handled, which stops the editor inserting a line break; `false` otherwise.\n   */\n  readonly onEnter?: (params: EmbeddableMarkdownEditorComponentEnterParams) => boolean;\n\n  /**\n   * Called on `Escape`. When given, the key goes no further.\n   */\n  readonly onEscape?: (component: EmbeddableMarkdownEditorComponent) => void;\n\n  /**\n   * Called on a paste into the editor, before the editor handles it.\n   */\n  readonly onPaste?: ($event: ClipboardEvent, component: EmbeddableMarkdownEditorComponent) => void;\n\n  /**\n   * The text shown while the document is empty.\n   */\n  readonly placeholder?: string;\n\n  /**\n   * The initial document.\n   */\n  readonly value?: string;\n}\n\n/**\n * The parameters of {@link EmbeddableMarkdownEditorComponentConstructorParams.onEnter}.\n */\nexport interface EmbeddableMarkdownEditorComponentEnterParams {\n  /**\n   * The editor component the key was pressed in.\n   */\n  readonly component: EmbeddableMarkdownEditorComponent;\n\n  /**\n   * Whether the platform modifier (`Ctrl`, or `Cmd` on macOS) was held.\n   */\n  readonly isModifierPressed: boolean;\n\n  /**\n   * Whether `Shift` was held.\n   */\n  readonly isShiftPressed: boolean;\n}\n\n/**\n * A selection in an {@link EmbeddableMarkdownEditorComponent}, as document offsets.\n */\nexport interface EmbeddableMarkdownEditorComponentSelection {\n  /**\n   * The offset the selection starts from.\n   */\n  readonly anchor: number;\n\n  /**\n   * The offset the selection extends to, where the cursor is.\n   */\n  readonly head: number;\n}\n\ninterface EditorHooks {\n  readonly buildExtensions: () => Extension[];\n  readonly handleUpdate: (update: ViewUpdate, isChanged: boolean) => void;\n}\n\ntype EmbeddedScrollableMarkdownEditorConstructor = new (\n  app: App,\n  containerEl: HTMLElement,\n  owner: MarkdownScrollableEditViewOwner,\n  hooks: EditorHooks\n) => MarkdownScrollableEditView;\n\ntype ScrollableMarkdownEditorConstructor = ExtractConstructor<MarkdownScrollableEditView>;\n\ninterface ScrollableMarkdownEditorConstructorCache {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Filled on first use.\n  value: null | ScrollableMarkdownEditorConstructor;\n}\n\n/* eslint-disable typescript-dev-toolkit/readonly-interface-members -- The owner learns its editor after the editor, which needs the owner, is built. */\ninterface ScrollableMarkdownEditorOwner extends MarkdownScrollableEditViewOwner {\n  editMode: MarkdownScrollableEditView | null;\n  readonly getMode: () => 'source';\n}\n/* eslint-enable typescript-dev-toolkit/readonly-interface-members -- Restore the rule after the owner. */\n\ninterface ScrollableMarkdownEditorPrototype {\n  readonly constructor: ScrollableMarkdownEditorConstructor;\n}\n\nconst scrollableMarkdownEditorConstructorCache: ScrollableMarkdownEditorConstructorCache = { value: null };\n\n/**\n * A full Obsidian Markdown editor mounted in any element: Live Preview, editor commands, hotkeys and the editor\n * suggesters all work in it as they do in a note.\n *\n * Add it as a child of the component that owns its element; unloading it destroys the editor and removes the editor's\n * element. It works on desktop and mobile.\n *\n * @example\n * ```ts\n * const editorComponent = this.addChild(new EmbeddableMarkdownEditorComponent({\n *   app: this.app,\n *   containerEl,\n *   onEnter: ({ component, isModifierPressed }) => {\n *     if (!isModifierPressed) {\n *       return false;\n *     }\n *     save(component.value);\n *     return true;\n *   },\n *   value: 'Initial text'\n * }));\n * ```\n */\nexport class EmbeddableMarkdownEditorComponent extends ComponentEx {\n  /**\n   * The Obsidian editor, as in a note.\n   *\n   * @returns The editor.\n   */\n  public get editor(): Editor {\n    return ensureNonNullable(this.getScrollableEditor().editor);\n  }\n\n  /**\n   * The CodeMirror view behind the editor.\n   *\n   * @returns The CodeMirror view.\n   */\n  public get editorView(): EditorView {\n    return this.getScrollableEditor().cm;\n  }\n\n  /**\n   * The current document.\n   *\n   * @returns The document text.\n   */\n  public get value(): string {\n    return this.getScrollableEditor().cm.state.doc.toString();\n  }\n\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The element the editor is mounted in.\n   */\n  protected readonly containerEl: HTMLElement;\n\n  private readonly cls: string;\n  private readonly cursorLocation: EmbeddableMarkdownEditorComponentSelection | null;\n  private readonly initialValue: string;\n  private readonly keymapScope: Scope;\n  private readonly onBlur: ((component: EmbeddableMarkdownEditorComponent) => void) | null;\n  private readonly onChange: ((update: ViewUpdate, component: EmbeddableMarkdownEditorComponent) => void) | null;\n  private readonly onEnter: ((params: EmbeddableMarkdownEditorComponentEnterParams) => boolean) | null;\n  private readonly onEscape: ((component: EmbeddableMarkdownEditorComponent) => void) | null;\n  private readonly onPaste: (($event: ClipboardEvent, component: EmbeddableMarkdownEditorComponent) => void) | null;\n  private readonly owner: ScrollableMarkdownEditorOwner;\n  private readonly placeholderText: string;\n  private scrollableEditor: MarkdownScrollableEditView | null = null;\n\n  /**\n   * Creates the component. The editor is built when the component loads.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: EmbeddableMarkdownEditorComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.containerEl = params.containerEl;\n    this.cls = params.cls ?? '';\n    this.cursorLocation = params.cursorLocation ?? null;\n    this.initialValue = params.value ?? '';\n    this.onBlur = params.onBlur ?? null;\n    this.onChange = params.onChange ?? null;\n    this.onEnter = params.onEnter ?? null;\n    this.onEscape = params.onEscape ?? null;\n    this.onPaste = params.onPaste ?? null;\n    this.placeholderText = params.placeholder ?? '';\n    this.keymapScope = new Scope(params.app.scope);\n    // The editor's owner stands in for a `MarkdownView`. The editor commands reach the editor through\n    // `activeEditor.editMode` and `activeEditor.editor`, and scrolling calls back into the owner.\n    this.owner = {\n      app: params.app,\n      editMode: null,\n      file: null,\n      getMode: (): 'source' => 'source',\n      hoverPopover: null,\n      syncScroll: noop\n    };\n  }\n\n  /**\n   * Focuses the editor.\n   */\n  public focus(): void {\n    this.getScrollableEditor().focus();\n  }\n\n  /**\n   * Builds the editor and mounts it in the container.\n   */\n  public override onload(): void {\n    super.onload();\n    const EditorConstructor = createEditorClass(getScrollableMarkdownEditorConstructor(this.app));\n    const scrollableEditor = new EditorConstructor(this.app, this.containerEl, this.owner, {\n      buildExtensions: (): Extension[] => this.buildExtensions(),\n      handleUpdate: (update: ViewUpdate, isChanged: boolean): void => {\n        this.handleUpdate(update, isChanged);\n      }\n    });\n    this.scrollableEditor = scrollableEditor;\n    this.owner.editMode = scrollableEditor;\n    this.owner.editor = ensureNonNullable(scrollableEditor.editor);\n    this.addChild(scrollableEditor);\n\n    if (this.onEnter) {\n      // Obsidian's hotkeys run before CodeMirror's keymap, and `Mod+Enter` opens the link under the cursor. A handler\n      // returning `true` stops that hotkey without stopping the event, so the editor keymap still sees the key.\n      const submitHotkeyHandler = this.keymapScope.register(['Mod'], 'Enter', () => true);\n      this.register(() => {\n        this.keymapScope.unregister(submitHotkeyHandler);\n      });\n    }\n\n    if (this.cls) {\n      scrollableEditor.editorEl.addClass(this.cls);\n    }\n\n    scrollableEditor.set(this.initialValue, false);\n\n    if (this.cursorLocation) {\n      scrollableEditor.cm.dispatch({\n        selection: EditorSelection.range(this.cursorLocation.anchor, this.cursorLocation.head)\n      });\n    }\n\n    const focusGuardPatchComponent = this.addChild(new MonkeyAroundComponent());\n    focusGuardPatchComponent.registerMethodPatch({\n      $object: this.app.workspace,\n      methodName: 'setActiveLeaf',\n      patchHandler: ({ fallback }) => {\n        // A focused editor that belongs to no leaf would otherwise lose its focus to the leaf the workspace activates.\n        if (scrollableEditor.activeCM.hasFocus) {\n          return;\n        }\n        fallback();\n      }\n    });\n\n    this.register(() => {\n      this.app.keymap.popScope(this.keymapScope);\n      if (this.app.workspace.activeEditor === this.owner) {\n        this.app.workspace.activeEditor = null;\n      }\n      scrollableEditor.destroy();\n      scrollableEditor.editorEl.remove();\n      this.owner.editMode = null;\n      delete this.owner.editor;\n      this.scrollableEditor = null;\n    });\n  }\n\n  /**\n   * Replaces the document.\n   *\n   * @param value - The new document.\n   */\n  public setValue(value: string): void {\n    this.getScrollableEditor().set(value, false);\n  }\n\n  /**\n   * Builds the editor's own extensions: the placeholder, the focus and paste handlers, and the key handlers.\n   *\n   * @returns The extensions.\n   */\n  protected buildExtensions(): Extension[] {\n    const extensions: Extension[] = [\n      EditorView.domEventHandlers({\n        blur: (): void => {\n          this.app.keymap.popScope(this.keymapScope);\n          if (this._loaded) {\n            this.onBlur?.(this);\n          }\n        },\n        focus: (): void => {\n          this.app.keymap.pushScope(this.keymapScope);\n        },\n        paste: ($event: ClipboardEvent): void => {\n          this.onPaste?.($event, this);\n        }\n      }),\n      Prec.highest(keymap.of([\n        {\n          key: 'Enter',\n          run: (): boolean => this.isEnterHandled(false, false),\n          shift: (): boolean => this.isEnterHandled(false, true)\n        },\n        {\n          key: 'Mod-Enter',\n          run: (): boolean => this.isEnterHandled(true, false),\n          shift: (): boolean => this.isEnterHandled(true, true)\n        },\n        {\n          key: 'Escape',\n          preventDefault: true,\n          run: (): boolean => {\n            if (!this.onEscape) {\n              return false;\n            }\n            this.onEscape(this);\n            return true;\n          }\n        }\n      ]))\n    ];\n\n    if (this.placeholderText) {\n      extensions.push(placeholder(this.placeholderText));\n    }\n\n    return extensions;\n  }\n\n  /**\n   * Called after every update of the editor, with whether the document changed.\n   *\n   * @param update - The CodeMirror update.\n   * @param isChanged - Whether the document changed.\n   */\n  protected handleUpdate(update: ViewUpdate, isChanged: boolean): void {\n    if (isChanged) {\n      this.onChange?.(update, this);\n    }\n  }\n\n  private getScrollableEditor(): MarkdownScrollableEditView {\n    return ensureNonNullable(this.scrollableEditor, 'The editor is built when the component loads.');\n  }\n\n  private isEnterHandled(isModifierPressed: boolean, isShiftPressed: boolean): boolean {\n    return this.onEnter?.({ component: this, isModifierPressed, isShiftPressed }) ?? false;\n  }\n}\n\nfunction createEditorClass(BaseConstructor: ScrollableMarkdownEditorConstructor): EmbeddedScrollableMarkdownEditorConstructor {\n  return class EmbeddedScrollableMarkdownEditor extends BaseConstructor {\n    public constructor(app: App, containerEl: HTMLElement, owner: MarkdownScrollableEditViewOwner, private readonly hooks: EditorHooks) {\n      // The base builds its extensions lazily, on the first `set()`, so the hooks are not needed during `super()`.\n      super(app, containerEl, owner);\n    }\n\n    public override buildLocalExtensions(): Extension[] {\n      return [...super.buildLocalExtensions(), ...this.hooks.buildExtensions()];\n    }\n\n    public override onUpdate(update: ViewUpdate, isChanged: boolean): void {\n      super.onUpdate(update, isChanged);\n      this.hooks.handleUpdate(update, isChanged);\n    }\n  };\n}\n\nfunction getScrollableMarkdownEditorConstructor(app: App): ScrollableMarkdownEditorConstructor {\n  if (scrollableMarkdownEditorConstructorCache.value) {\n    return scrollableMarkdownEditorConstructorCache.value;\n  }\n\n  // An editable Markdown embed builds an iframed editor whose base class is the scrollable editor. The embed is given\n  // no file, which is what keeps it from reading or watching one.\n  const widgetEditorView = castTo<WidgetEditorView>(app.embedRegistry.embedByExtension.md({ app, containerEl: createDiv() }, castTo<TFile>(null), ''));\n\n  try {\n    widgetEditorView.editable = true;\n    widgetEditorView.showEditor();\n    const iframedEditor = ensureNonNullable(widgetEditorView.editMode, 'The Markdown embed built no editor.');\n    const scrollableEditorPrototype = castTo<ScrollableMarkdownEditorPrototype>(Object.getPrototypeOf(Object.getPrototypeOf(iframedEditor) as object));\n    scrollableMarkdownEditorConstructorCache.value = scrollableEditorPrototype.constructor;\n    return scrollableEditorPrototype.constructor;\n  } finally {\n    widgetEditorView.unload();\n  }\n}\n\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}

package/dist/lib/esm/components/index.d.mts

@@ -10,6 +10,7 @@ export * as 'console-debug-component' from './console-debug-component.mjs';
 export * as 'core-plugin-toggle-component' from './core-plugin-toggle-component.mjs';
 export * as 'disposable-component' from './disposable-component.mjs';
 export * as 'embed-extensions-component' from './embed-extensions-component.mjs';
+export * as 'embeddable-markdown-editor-component' from './embeddable-markdown-editor-component.mjs';
 export * as 'file-explorer-root-menu-component' from './file-explorer-root-menu-component.mjs';
 export * as 'generate-markdown-link-default-params-component' from './generate-markdown-link-default-params-component.mjs';
 export * as 'incremental-file-index-component' from './incremental-file-index-component.mjs';
@@ -24,6 +25,7 @@ export * as 'plugin-settings-component' from './plugin-settings-component.mjs';
 export * as 'plugin-settings-tab-component' from './plugin-settings-tab-component.mjs';
 export * as 'plugin-suggestion-component' from './plugin-suggestion-component.mjs';
 export * as 'pointer-position-component' from './pointer-position-component.mjs';
+export * as 'reconfigurable-editor-extension-component' from './reconfigurable-editor-extension-component.mjs';
 export * as 'registry-component' from './registry-component.mjs';
 export * as 'release-notes-component' from './release-notes-component.mjs';
 export * as 'rename-delete-handler-component' from './rename-delete-handler-component.mjs';

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

@@ -14,6 +14,7 @@ import * as console_debug_component from "./console-debug-component.mjs";
 import * as core_plugin_toggle_component from "./core-plugin-toggle-component.mjs";
 import * as disposable_component from "./disposable-component.mjs";
 import * as embed_extensions_component from "./embed-extensions-component.mjs";
+import * as embeddable_markdown_editor_component from "./embeddable-markdown-editor-component.mjs";
 import * as file_explorer_root_menu_component from "./file-explorer-root-menu-component.mjs";
 import * as generate_markdown_link_default_params_component from "./generate-markdown-link-default-params-component.mjs";
 import * as incremental_file_index_component from "./incremental-file-index-component.mjs";
@@ -28,6 +29,7 @@ import * as plugin_settings_component from "./plugin-settings-component.mjs";
 import * as plugin_settings_tab_component from "./plugin-settings-tab-component.mjs";
 import * as plugin_suggestion_component from "./plugin-suggestion-component.mjs";
 import * as pointer_position_component from "./pointer-position-component.mjs";
+import * as reconfigurable_editor_extension_component from "./reconfigurable-editor-extension-component.mjs";
 import * as registry_component from "./registry-component.mjs";
 import * as release_notes_component from "./release-notes-component.mjs";
 import * as rename_delete_handler_component from "./rename-delete-handler-component.mjs";
@@ -47,6 +49,7 @@ export {
   core_plugin_toggle_component as "core-plugin-toggle-component",
   disposable_component as "disposable-component",
   embed_extensions_component as "embed-extensions-component",
+  embeddable_markdown_editor_component as "embeddable-markdown-editor-component",
   file_explorer_root_menu_component as "file-explorer-root-menu-component",
   generate_markdown_link_default_params_component as "generate-markdown-link-default-params-component",
   incremental_file_index_component as "incremental-file-index-component",
@@ -61,6 +64,7 @@ export {
   plugin_settings_tab_component as "plugin-settings-tab-component",
   plugin_suggestion_component as "plugin-suggestion-component",
   pointer_position_component as "pointer-position-component",
+  reconfigurable_editor_extension_component as "reconfigurable-editor-extension-component",
   registry_component as "registry-component",
   release_notes_component as "release-notes-component",
   rename_delete_handler_component as "rename-delete-handler-component",
@@ -69,4 +73,4 @@ export {
   syntax_highlighting_component as "syntax-highlighting-component",
   templates_language_component as "templates-language-component"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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