@mnaoumov/obsidian-lib 10.4.0 → 10.5.0

package/dist/lib/cjs/components/embeddable-markdown-editor-component.cjs

@@ -0,0 +1,374 @@
+/*
+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();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var embeddable_markdown_editor_component_exports = {};
+__export(embeddable_markdown_editor_component_exports, {
+  EmbeddableMarkdownEditorComponent: () => EmbeddableMarkdownEditorComponent
+});
+module.exports = __toCommonJS(embeddable_markdown_editor_component_exports);
+var import_state = require('@codemirror/state');
+var import_view = require('@codemirror/view');
+var import_function = require('@mnaoumov/typescript-lib/function');
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_obsidian = require('obsidian');
+var import_component_ex = require('./component-ex.cjs');
+var import_monkey_around_component = require('./monkey-around-component.cjs');
+const scrollableMarkdownEditorConstructorCache = { value: null };
+class EmbeddableMarkdownEditorComponent extends import_component_ex.ComponentEx {
+  /**
+   * The Obsidian editor, as in a note.
+   *
+   * @returns The editor.
+   */
+  get editor() {
+    return (0, import_type_guards.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 import_obsidian.Scope(params.app.scope);
+    this.owner = {
+      app: params.app,
+      editMode: null,
+      file: null,
+      getMode: () => "source",
+      hoverPopover: null,
+      syncScroll: import_function.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 = (0, import_type_guards.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: import_state.EditorSelection.range(this.cursorLocation.anchor, this.cursorLocation.head)
+      });
+    }
+    const focusGuardPatchComponent = this.addChild(new import_monkey_around_component.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 = [
+      import_view.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);
+        }
+      }),
+      import_state.Prec.highest(import_view.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((0, import_view.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 (0, import_type_guards.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 = (0, import_object_utils.castTo)(app.embedRegistry.embedByExtension.md({ app, containerEl: createDiv() }, (0, import_object_utils.castTo)(null), ""));
+  try {
+    widgetEditorView.editable = true;
+    widgetEditorView.showEditor();
+    const iframedEditor = (0, import_type_guards.ensureNonNullable)(widgetEditorView.editMode, "The Markdown embed built no editor.");
+    const scrollableEditorPrototype = (0, import_object_utils.castTo)(Object.getPrototypeOf(Object.getPrototypeOf(iframedEditor)));
+    scrollableMarkdownEditorConstructorCache.value = scrollableEditorPrototype.constructor;
+    return scrollableEditorPrototype.constructor;
+  } finally {
+    widgetEditorView.unload();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/cjs/components/embeddable-markdown-editor-component.d.cts

@@ -0,0 +1,221 @@
+/// <reference path="../library-references.d.cts" />
+/// <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' with { 'resolution-mode': 'import' };
+import type { ViewUpdate } from '@codemirror/view' with { 'resolution-mode': 'import' };
+import type { App, Editor } from 'obsidian' with { 'resolution-mode': 'import' };
+import { EditorView } from '@codemirror/view';
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * 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;
+}