@mnaoumov/obsidian-lib 10.9.0 → 10.11.0

package/dist/lib/cjs/link.d.cts

@@ -7,7 +7,7 @@
  * functions to split paths, update links in files, and generate markdown links with various options.
  */
 import type { MaybeReturn } from '@mnaoumov/typescript-lib/type' with { 'resolution-mode': 'import' };
-import type { App, Reference, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { App, Reference, ReferenceLinkCache, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
 import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { PathOrFile } from './file-system.cjs';
 import type { LinkUpdateProgressReporter } from './link-update-progress.cjs';
@@ -392,6 +392,24 @@ export interface EditReferencesInContentParams {
      * The function that converts each reference.
      */
     readonly referenceConverter: (reference: Reference) => Promisable<MaybeReturn<string>>;
+    /**
+     * The function that returns the new destination of each reference-style link definition
+     * (`[id]: destination "title"`). Obsidian reports those in `CachedMetadata.referenceLinks`, not among the
+     * references {@link EditReferencesInContentParams.referenceConverter} receives, so without this function they
+     * are never edited.
+     *
+     * It returns the destination unescaped, in the form of `ReferenceLinkCache.link`, or `undefined` to leave the
+     * definition unchanged. Only the destination is rewritten: the id, the title, the angle brackets and every use
+     * of the definition (`[text][id]`, `[id]`) stay as written. A definition whose content no longer matches its
+     * metadata is left unchanged. See {@link referenceDefinitionToFileChange}.
+     *
+     * The offset range applies to the definition's whole position. The heading skip and
+     * {@link EditReferencesInContentParams.shouldSkipReference} do not apply, since a definition is never in a
+     * heading and is not a `Reference`.
+     *
+     * @default `undefined`, which leaves every definition unchanged
+     */
+    readonly referenceDefinitionConverter?: (definition: ReferenceLinkCache) => Promisable<MaybeReturn<string>>;
     /**
      * Whether to also edit external links parsed from the note body. When `true`, the converter also
      * receives references for external links.
@@ -476,6 +494,24 @@ export interface EditReferencesParams extends EditReferencesOptions {
      * The function that converts each reference.
      */
     readonly referenceConverter: (reference: Reference) => Promisable<MaybeReturn<string>>;
+    /**
+     * The function that returns the new destination of each reference-style link definition
+     * (`[id]: destination "title"`). Obsidian reports those in `CachedMetadata.referenceLinks`, not among the
+     * references {@link EditReferencesParams.referenceConverter} receives, so without this function they are never
+     * edited.
+     *
+     * It returns the destination unescaped, in the form of `ReferenceLinkCache.link`, or `undefined` to leave the
+     * definition unchanged. Only the destination is rewritten: the id, the title, the angle brackets and every use
+     * of the definition (`[text][id]`, `[id]`) stay as written. A definition whose content no longer matches its
+     * metadata is left unchanged. See {@link referenceDefinitionToFileChange}. A canvas file has no definitions.
+     *
+     * The offset range applies to the definition's whole position. The heading skip and
+     * {@link EditReferencesParams.shouldSkipReference} do not apply, since a definition is never in a heading and is
+     * not a `Reference`.
+     *
+     * @default `undefined`, which leaves every definition unchanged
+     */
+    readonly referenceDefinitionConverter?: (definition: ReferenceLinkCache) => Promisable<MaybeReturn<string>>;
     /**
      * Whether to also edit external links parsed from the note body. When `true`, the converter also
      * receives references for external links.

package/dist/lib/cjs/modals/code-block-builder.cjs

@@ -0,0 +1,486 @@
+/*
+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 code_block_builder_exports = {};
+__export(code_block_builder_exports, {
+  formatCodeBlock: () => formatCodeBlock,
+  showCodeBlockBuilder: () => showCodeBlockBuilder
+});
+module.exports = __toCommonJS(code_block_builder_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_obsidian = require('obsidian');
+var import_css_class = require('../css-class.cjs');
+var import_i18n = require('../i18n/i18n.cjs');
+var import_multiple_dropdown_component = require('../setting-components/multiple-dropdown-component.cjs');
+var import_modal = require('./modal.cjs');
+const DEFAULT_SEPARATOR = ",";
+const MIN_FENCE_LENGTH = 3;
+const ROOT_FOLDER_PATH = "/";
+class CodeBlockBuilderModal extends import_modal.ModalBase {
+  codeBlock = "";
+  editor;
+  fields;
+  groupStates = [];
+  insertedCodeBlock = null;
+  language;
+  onUpdatePreview;
+  outputComponent = null;
+  previewEl = null;
+  title;
+  values = /* @__PURE__ */ new Map();
+  constructor(params) {
+    super(params);
+    this.addCssClasses(import_css_class.CssClass.CodeBlockBuilderModal);
+    this.editor = params.editor === void 0 ? params.app.workspace.activeEditor?.editor ?? null : params.editor;
+    this.fields = params.fields;
+    this.language = params.language;
+    this.onUpdatePreview = params.onUpdatePreview;
+    this.title = params.title ?? (0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.title);
+    for (const field of flattenFields(this.fields)) {
+      this.values.set(field.key, field.defaultValue);
+    }
+  }
+  onClose() {
+    this.promiseResolve(this.insertedCodeBlock);
+  }
+  onOpen() {
+    this.titleEl.setText(this.title);
+    for (const input of this.fields) {
+      if (input.type !== "group" && input.isRequired) {
+        this.renderField(this.contentEl, input);
+      }
+    }
+    for (const input of this.fields) {
+      if (input.type === "group") {
+        this.renderGroup(input);
+      } else if (!input.isRequired) {
+        this.renderField(this.contentEl, input);
+      }
+    }
+    this.previewEl = this.contentEl.createDiv({ cls: import_css_class.CssClass.CodeBlockBuilderPreview });
+    this.renderOutput();
+    this.update();
+  }
+  addResetButton(setting, field, reset) {
+    if (field.isRequired) {
+      return;
+    }
+    setting.addExtraButton((button) => {
+      button.setIcon("lucide-rotate-ccw").setTooltip((0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.reset, { value: formatValue(field, field.defaultValue) || '""' })).onClick(() => {
+        reset();
+        this.setValue(field.key, field.defaultValue);
+      });
+    });
+  }
+  async copy() {
+    try {
+      await this.containerEl.win.navigator.clipboard.writeText(this.codeBlock);
+      new import_obsidian.Notice((0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.copied));
+    } catch {
+      new import_obsidian.Notice((0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.copyFailed));
+    }
+  }
+  insert() {
+    if (!this.editor) {
+      new import_obsidian.Notice((0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.insertUnavailable));
+      return;
+    }
+    const cursor = this.editor.getCursor("from");
+    const textBeforeCursor = this.editor.getLine(cursor.line).slice(0, cursor.ch);
+    const prefix = textBeforeCursor === "" ? "" : "\n";
+    this.editor.replaceSelection(`${prefix}${this.codeBlock}
+`);
+    this.insertedCodeBlock = this.codeBlock;
+    this.close();
+  }
+  renderBooleanField(setting, field) {
+    setting.addToggle((toggle) => {
+      toggle.setValue(field.defaultValue).onChange((value) => {
+        this.setValue(field.key, value);
+      });
+      this.addResetButton(setting, field, () => {
+        toggle.setValue(field.defaultValue);
+      });
+    });
+  }
+  renderColorField(setting, field) {
+    setting.addColorPicker((colorPicker) => {
+      colorPicker.setValue(field.defaultValue).onChange((value) => {
+        this.setValue(field.key, value);
+      });
+      this.addResetButton(setting, field, () => {
+        colorPicker.setValue(field.defaultValue);
+      });
+    });
+  }
+  renderConditionalDropdownField(setting, field) {
+    const initialGroupIndex = Math.max(0, field.groups.findIndex((group) => Object.hasOwn(toRecord(group.options), field.defaultValue)));
+    const groupDropdown = new import_obsidian.DropdownComponent(setting.controlEl);
+    for (const [index, group] of field.groups.entries()) {
+      groupDropdown.addOption(String(index), group.name);
+    }
+    groupDropdown.setValue(String(initialGroupIndex));
+    const optionDropdown = new import_obsidian.DropdownComponent(setting.controlEl);
+    function fillOptions(groupIndex, value) {
+      const options = toRecord(field.groups[groupIndex]?.options ?? []);
+      const selectedValue = value ?? Object.keys(options)[0] ?? "";
+      optionDropdown.selectEl.empty();
+      optionDropdown.addOptions(options);
+      optionDropdown.setValue(selectedValue);
+      return selectedValue;
+    }
+    fillOptions(initialGroupIndex, field.defaultValue);
+    optionDropdown.onChange((value) => {
+      this.setValue(field.key, value);
+    });
+    groupDropdown.onChange((value) => {
+      this.setValue(field.key, fillOptions(Number(value)));
+    });
+    this.addResetButton(setting, field, () => {
+      groupDropdown.setValue(String(initialGroupIndex));
+      fillOptions(initialGroupIndex, field.defaultValue);
+    });
+  }
+  renderDropdownField(setting, field) {
+    setting.addDropdown((dropdown) => {
+      dropdown.addOptions(toRecord(field.options)).setValue(field.defaultValue).onChange((value) => {
+        this.setValue(field.key, value);
+      });
+      this.addResetButton(setting, field, () => {
+        dropdown.setValue(field.defaultValue);
+      });
+    });
+  }
+  renderField(containerEl, field) {
+    const setting = new import_obsidian.Setting(containerEl).setName(field.name);
+    if (field.description !== void 0) {
+      setting.setDesc(field.description);
+    }
+    switch (field.type) {
+      case "boolean": {
+        this.renderBooleanField(setting, field);
+        break;
+      }
+      case "color": {
+        this.renderColorField(setting, field);
+        break;
+      }
+      case "conditionalDropdown": {
+        this.renderConditionalDropdownField(setting, field);
+        break;
+      }
+      case "dropdown": {
+        this.renderDropdownField(setting, field);
+        break;
+      }
+      case "folder": {
+        this.renderFolderField(setting, field);
+        break;
+      }
+      case "multipleDropdown": {
+        this.renderMultipleDropdownField(setting, field);
+        break;
+      }
+      case "slider": {
+        this.renderSliderField(setting, field);
+        break;
+      }
+      case "text": {
+        this.renderTextField(setting, field);
+        break;
+      }
+      default: {
+        (0, import_type_guards.assertNever)(field);
+      }
+    }
+  }
+  renderFolderField(setting, field) {
+    const options = {
+      [ROOT_FOLDER_PATH]: (0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.rootFolder)
+    };
+    const folderPaths = this.app.vault.getAllFolders(false).map((folder) => folder.path).sort((a, b) => a.localeCompare(b));
+    for (const folderPath of folderPaths) {
+      options[folderPath] = folderPath;
+    }
+    options[field.defaultValue] ??= field.defaultValue;
+    setting.addDropdown((dropdown) => {
+      dropdown.addOptions(options).setValue(field.defaultValue).onChange((value) => {
+        this.setValue(field.key, value);
+      });
+      this.addResetButton(setting, field, () => {
+        dropdown.setValue(field.defaultValue);
+      });
+    });
+  }
+  renderGroup(group) {
+    const groupEl = this.contentEl.createDiv({ cls: import_css_class.CssClass.CodeBlockBuilderGroup });
+    const headingSetting = new import_obsidian.Setting(groupEl).setName(group.name).setHeading();
+    const bodyEl = groupEl.createDiv({ cls: import_css_class.CssClass.CodeBlockBuilderGroupBody });
+    groupEl.addClass(import_css_class.CssClass.IsCollapsed);
+    headingSetting.addExtraButton((button) => {
+      const groupState = { button, groupEl };
+      this.groupStates.push(groupState);
+      updateGroupIcon(groupState);
+      button.onClick(() => {
+        this.setGroupExpanded(groupEl, groupEl.hasClass(import_css_class.CssClass.IsCollapsed));
+      });
+    });
+    for (const field of group.fields) {
+      this.renderField(bodyEl, field);
+    }
+    if (group.isInitiallyExpanded) {
+      this.setGroupExpanded(groupEl, true);
+    }
+  }
+  renderMultipleDropdownField(setting, field) {
+    const dropdown = new import_multiple_dropdown_component.MultipleDropdownComponent(setting.controlEl).addOptions(toRecord(field.options)).setValue(field.defaultValue).onChange((value) => {
+      this.setValue(field.key, value);
+    });
+    setting.addComponent(() => dropdown);
+    this.addResetButton(setting, field, () => {
+      dropdown.setValue(field.defaultValue);
+    });
+  }
+  renderOutput() {
+    const setting = new import_obsidian.Setting(this.contentEl).setName((0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.output));
+    setting.settingEl.addClass(import_css_class.CssClass.CodeBlockBuilderOutput);
+    setting.addTextArea((textArea) => {
+      this.outputComponent = textArea;
+      textArea.inputEl.readOnly = true;
+    });
+    setting.addExtraButton((button) => {
+      button.setIcon("lucide-copy").setTooltip((0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.copy)).onClick(() => {
+        (0, import_async.invokeAsyncSafely)(() => this.copy());
+      });
+    });
+    setting.addExtraButton((button) => {
+      button.setIcon("lucide-file-input").setTooltip((0, import_i18n.t)(($) => this.editor ? $.obsidianLib.codeBlockBuilder.insert : $.obsidianLib.codeBlockBuilder.insertUnavailable)).onClick(() => {
+        this.insert();
+      });
+    });
+  }
+  renderSliderField(setting, field) {
+    setting.addSlider((slider) => {
+      slider.setLimits(Math.min(field.min, field.defaultValue), Math.max(field.max, field.defaultValue), field.step).setValue(field.defaultValue).onChange((value) => {
+        this.setValue(field.key, value);
+      });
+      this.addResetButton(setting, field, () => {
+        slider.setValue(field.defaultValue);
+      });
+    });
+  }
+  renderTextField(setting, field) {
+    setting.addText((text) => {
+      text.setPlaceholder(field.placeholder ?? "").setValue(field.defaultValue).onChange((value) => {
+        if (field.validationPattern && !doesMatchPattern(field.validationPattern, value)) {
+          text.inputEl.setCustomValidity((0, import_i18n.t)(($) => $.obsidianLib.codeBlockBuilder.invalidValue));
+          return;
+        }
+        text.inputEl.setCustomValidity("");
+        this.setValue(field.key, value);
+      });
+      this.addResetButton(setting, field, () => {
+        text.setValue(field.defaultValue);
+        text.inputEl.setCustomValidity("");
+      });
+    });
+  }
+  setGroupExpanded(groupEl, isExpanded) {
+    for (const groupState of this.groupStates) {
+      const shouldExpand = isExpanded && groupState.groupEl === groupEl;
+      groupState.groupEl.toggleClass(import_css_class.CssClass.IsCollapsed, !shouldExpand);
+      updateGroupIcon(groupState);
+    }
+  }
+  setValue(key, value) {
+    this.values.set(key, value);
+    this.update();
+  }
+  update() {
+    this.codeBlock = formatCodeBlock({
+      fields: this.fields,
+      language: this.language,
+      values: this.values
+    });
+    const outputComponent = (0, import_type_guards.ensureNonNullable)(this.outputComponent);
+    outputComponent.setValue(this.codeBlock);
+    outputComponent.inputEl.rows = this.codeBlock.split("\n").length;
+    if (this.onUpdatePreview) {
+      this.onUpdatePreview({
+        codeBlock: this.codeBlock,
+        previewEl: (0, import_type_guards.ensureNonNullable)(this.previewEl),
+        values: this.values
+      });
+    }
+  }
+}
+function formatCodeBlock(params) {
+  const lines = [];
+  for (const field of flattenFields(params.fields)) {
+    const value = params.values.get(field.key) ?? field.defaultValue;
+    const formattedValue = formatValue(field, value);
+    if (formattedValue === "") {
+      continue;
+    }
+    if (!field.isRequired && isSameValue(value, field.defaultValue)) {
+      continue;
+    }
+    lines.push(field.shouldOmitKey ? formattedValue : `${field.key}: ${formattedValue}`);
+  }
+  const body = lines.join("\n");
+  const longestBacktickRun = Math.max(0, ...Array.from(body.matchAll(/`+/g), (match) => match[0].length));
+  const fence = "`".repeat(Math.max(MIN_FENCE_LENGTH, longestBacktickRun + 1));
+  return lines.length === 0 ? `${fence}${params.language}
+${fence}` : `${fence}${params.language}
+${body}
+${fence}`;
+}
+async function showCodeBlockBuilder(params) {
+  return await (0, import_modal.showModal)(
+    (promiseResolve) => new CodeBlockBuilderModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+function doesMatchPattern(pattern, value) {
+  pattern.lastIndex = 0;
+  return pattern.test(value);
+}
+function flattenFields(inputs) {
+  return inputs.flatMap((input) => input.type === "group" ? input.fields : [input]);
+}
+function formatValue(field, value) {
+  const separator = field.type === "multipleDropdown" ? field.separator ?? DEFAULT_SEPARATOR : DEFAULT_SEPARATOR;
+  return isStringArray(value) ? value.join(separator) : String(value);
+}
+function isSameValue(a, b) {
+  return isStringArray(a) && isStringArray(b) ? a.length === b.length && a.every((item, index) => item === b[index]) : a === b;
+}
+function isStringArray(value) {
+  return Array.isArray(value);
+}
+function toRecord(options) {
+  return isStringArray(options) ? Object.fromEntries(options.map((option) => [option, option])) : { ...options };
+}
+function updateGroupIcon(groupState) {
+  groupState.button.setIcon(groupState.groupEl.hasClass(import_css_class.CssClass.IsCollapsed) ? "lucide-chevron-down" : "lucide-chevron-up");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatCodeBlock,
+  showCodeBlockBuilder
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/modals/code-block-builder.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains {@link showCodeBlockBuilder}, a modal that builds a plugin's code block from a declarative list of fields, and\n * {@link formatCodeBlock}, the pure formatter behind it.\n *\n * Every field renders as one settings row. A field whose value differs from its default writes one `key: value` line\n * into the block (a required field always does), the block is shown live with an optional preview the plugin draws, and\n * the user copies it or inserts it into the note being edited.\n *\n * Adapted from the code block creator modal of altarok's `obsidian-dev-utils`\n * (https://github.com/altarok/obsidian-dev-utils, `src/code-block-creator/`), under the MIT license below. The port\n * takes the app from the caller, moves the styles into the library stylesheet, reuses this library's setting\n * components, and picks a fence longer than any backtick run in the values.\n *\n * Copyright (c) 2026 Altarok\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 altarok Altarok rrggbb -- The author's handle, as the license notice above names it, and the hex color notation.\n\nimport type {\n  Editor,\n  ExtraButtonComponent\n} from 'obsidian';\n\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport {\n  assertNever,\n  ensureNonNullable\n} from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  DropdownComponent,\n  Notice,\n  Setting,\n  TextAreaComponent\n} from 'obsidian';\n\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { MultipleDropdownComponent } from '../setting-components/multiple-dropdown-component.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * A boolean field, rendered as a toggle.\n */\nexport interface CodeBlockBuilderBooleanField extends CodeBlockBuilderFieldBase<boolean> {\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'boolean';\n}\n\n/**\n * A color field, rendered as a color picker. The value is the color as `#rrggbb`.\n */\nexport interface CodeBlockBuilderColorField extends CodeBlockBuilderFieldBase<string> {\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'color';\n}\n\n/**\n * A pair of cascading dropdowns: the first picks a group, the second one of that group's options. Only the second\n * dropdown's value is written into the code block.\n */\nexport interface CodeBlockBuilderConditionalDropdownField extends CodeBlockBuilderFieldBase<string> {\n  /**\n   * The groups of options. The group containing {@link CodeBlockBuilderFieldBase.defaultValue} is selected first, else\n   * the first group.\n   */\n  readonly groups: readonly CodeBlockBuilderOptionGroup[];\n\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'conditionalDropdown';\n}\n\n/**\n * A single-choice dropdown field.\n */\nexport interface CodeBlockBuilderDropdownField extends CodeBlockBuilderFieldBase<string> {\n  /**\n   * The options of the dropdown.\n   */\n  readonly options: CodeBlockBuilderOptions;\n\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'dropdown';\n}\n\n/**\n * A field of the code block builder, other than a {@link CodeBlockBuilderGroup}.\n */\nexport type CodeBlockBuilderField =\n  | CodeBlockBuilderBooleanField\n  | CodeBlockBuilderColorField\n  | CodeBlockBuilderConditionalDropdownField\n  | CodeBlockBuilderDropdownField\n  | CodeBlockBuilderFolderField\n  | CodeBlockBuilderMultipleDropdownField\n  | CodeBlockBuilderSliderField\n  | CodeBlockBuilderTextField;\n\n/**\n * The members every {@link CodeBlockBuilderField} has.\n *\n * @typeParam Value - The type of the field's value.\n */\nexport interface CodeBlockBuilderFieldBase<Value extends CodeBlockBuilderValue> {\n  /**\n   * The value the field starts with. While the field holds it, the field writes nothing into the code block, unless it\n   * is {@link CodeBlockBuilderFieldBase.isRequired}.\n   */\n  readonly defaultValue: Value;\n\n  /**\n   * A description shown under the field's name.\n   */\n  readonly description?: string;\n\n  /**\n   * Whether the field is always written into the code block. A required field is shown above the optional ones and has\n   * no reset button.\n   *\n   * @default `false`\n   */\n  readonly isRequired?: boolean;\n\n  /**\n   * The key the field's line is written with, and the key of its value in the values the preview receives. Unique across\n   * all fields.\n   */\n  readonly key: string;\n\n  /**\n   * The name of the field, shown to the user.\n   */\n  readonly name: string;\n\n  /**\n   * Whether the field's line holds its value alone, without the `key: ` prefix.\n   *\n   * @default `false`\n   */\n  readonly shouldOmitKey?: boolean;\n}\n\n/**\n * A folder field: a dropdown of every folder of the vault. The value is the folder path, `/` for the vault root.\n */\nexport interface CodeBlockBuilderFolderField extends CodeBlockBuilderFieldBase<string> {\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'folder';\n}\n\n/**\n * A collapsible group of fields. One group is expanded at a time: expanding a group collapses the others.\n */\nexport interface CodeBlockBuilderGroup {\n  /**\n   * The fields of the group. A required field inside a group is still written into the code block.\n   */\n  readonly fields: readonly CodeBlockBuilderField[];\n\n  /**\n   * Whether the group starts expanded.\n   *\n   * @default `false`\n   */\n  readonly isInitiallyExpanded?: boolean;\n\n  /**\n   * The heading of the group.\n   */\n  readonly name: string;\n\n  /**\n   * The kind of the entry.\n   */\n  readonly type: 'group';\n}\n\n/**\n * An entry of {@link ShowCodeBlockBuilderParams.fields}: a field, or a group of fields.\n */\nexport type CodeBlockBuilderInput = CodeBlockBuilderField | CodeBlockBuilderGroup;\n\n/**\n * A multiple-choice dropdown field. Its line holds the selected options joined by\n * {@link CodeBlockBuilderMultipleDropdownField.separator}.\n */\nexport interface CodeBlockBuilderMultipleDropdownField extends CodeBlockBuilderFieldBase<readonly string[]> {\n  /**\n   * The options of the dropdown.\n   */\n  readonly options: CodeBlockBuilderOptions;\n\n  /**\n   * The text the selected options are joined with.\n   *\n   * @default `','`\n   */\n  readonly separator?: string;\n\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'multipleDropdown';\n}\n\n/**\n * A named group of options of a {@link CodeBlockBuilderConditionalDropdownField}.\n */\nexport interface CodeBlockBuilderOptionGroup {\n  /**\n   * The name of the group, shown in the first dropdown.\n   */\n  readonly name: string;\n\n  /**\n   * The options of the group, shown in the second dropdown.\n   */\n  readonly options: CodeBlockBuilderOptions;\n}\n\n/**\n * The options of a dropdown: a list of values shown as they are, or a map from each value to its display text.\n */\nexport type CodeBlockBuilderOptions = Readonly<Record<string, string>> | readonly string[];\n\n/**\n * The parameters of {@link ShowCodeBlockBuilderParams.onUpdatePreview}.\n */\nexport interface CodeBlockBuilderPreviewParams {\n  /**\n   * The code block as it stands.\n   */\n  readonly codeBlock: string;\n\n  /**\n   * The element to draw the preview into. The modal never clears it.\n   */\n  readonly previewEl: HTMLElement;\n\n  /**\n   * The current value of every field, by its key.\n   */\n  readonly values: ReadonlyMap<string, CodeBlockBuilderValue>;\n}\n\n/**\n * A slider field. A {@link CodeBlockBuilderFieldBase.defaultValue} outside the bounds widens them.\n */\nexport interface CodeBlockBuilderSliderField extends CodeBlockBuilderFieldBase<number> {\n  /**\n   * The upper bound.\n   */\n  readonly max: number;\n\n  /**\n   * The lower bound.\n   */\n  readonly min: number;\n\n  /**\n   * The step.\n   */\n  readonly step: number;\n\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'slider';\n}\n\n/**\n * A text field.\n */\nexport interface CodeBlockBuilderTextField extends CodeBlockBuilderFieldBase<string> {\n  /**\n   * A placeholder shown while the field is empty.\n   */\n  readonly placeholder?: string;\n\n  /**\n   * The kind of the field.\n   */\n  readonly type: 'text';\n\n  /**\n   * A pattern the value must match. While it does not, the field is marked invalid and keeps its last valid value.\n   */\n  readonly validationPattern?: RegExp;\n}\n\n/**\n * The value of a {@link CodeBlockBuilderField}.\n */\nexport type CodeBlockBuilderValue = boolean | number | readonly string[] | string;\n\n/**\n * The parameters of {@link formatCodeBlock}.\n */\nexport interface FormatCodeBlockParams {\n  /**\n   * The fields of the code block.\n   */\n  readonly fields: readonly CodeBlockBuilderInput[];\n\n  /**\n   * The language of the code block.\n   */\n  readonly language: string;\n\n  /**\n   * The value of each field, by its key. A field missing from it holds its default value.\n   */\n  readonly values: ReadonlyMap<string, CodeBlockBuilderValue>;\n}\n\n/**\n * The parameters of {@link showCodeBlockBuilder}.\n */\nexport interface ShowCodeBlockBuilderParams extends ModalParamsBase {\n  /**\n   * The editor the Insert button writes into.\n   *\n   * @default The active editor when the modal opens.\n   */\n  readonly editor?: Editor | null;\n\n  /**\n   * The fields of the code block, in the order they are written into it. Required fields are shown first.\n   */\n  readonly fields: readonly CodeBlockBuilderInput[];\n\n  /**\n   * The language of the code block: the text after its opening fence.\n   */\n  readonly language: string;\n\n  /**\n   * Draws a live preview of the code block. Called once when the modal opens and again after every change.\n   *\n   * @param params - The preview element, the code block and the current values.\n   */\n  readonly onUpdatePreview?: (params: CodeBlockBuilderPreviewParams) => void;\n\n  /**\n   * The title of the modal.\n   *\n   * @default `'Code block builder'`\n   */\n  readonly title?: string;\n}\n\nconst DEFAULT_SEPARATOR = ',';\nconst MIN_FENCE_LENGTH = 3;\nconst ROOT_FOLDER_PATH = '/';\n\ntype CodeBlockBuilderModalConstructorParams = ModalBaseConstructorParams<null | string> & ShowCodeBlockBuilderParams;\n\ninterface GroupState {\n  readonly button: ExtraButtonComponent;\n  readonly groupEl: HTMLElement;\n}\n\nclass CodeBlockBuilderModal extends ModalBase<null | string> {\n  private codeBlock = '';\n  private readonly editor: Editor | null;\n  private readonly fields: readonly CodeBlockBuilderInput[];\n  private readonly groupStates: GroupState[] = [];\n  private insertedCodeBlock: null | string = null;\n  private readonly language: string;\n  private readonly onUpdatePreview: ((params: CodeBlockBuilderPreviewParams) => void) | undefined;\n  private outputComponent: null | TextAreaComponent = null;\n  private previewEl: HTMLElement | null = null;\n  private readonly title: string;\n  private readonly values = new Map<string, CodeBlockBuilderValue>();\n\n  public constructor(params: CodeBlockBuilderModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.CodeBlockBuilderModal);\n    this.editor = params.editor === undefined ? params.app.workspace.activeEditor?.editor ?? null : params.editor;\n    this.fields = params.fields;\n    this.language = params.language;\n    this.onUpdatePreview = params.onUpdatePreview;\n    this.title = params.title ?? t(($) => $.obsidianLib.codeBlockBuilder.title);\n    for (const field of flattenFields(this.fields)) {\n      this.values.set(field.key, field.defaultValue);\n    }\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.insertedCodeBlock);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n\n    for (const input of this.fields) {\n      if (input.type !== 'group' && input.isRequired) {\n        this.renderField(this.contentEl, input);\n      }\n    }\n\n    for (const input of this.fields) {\n      if (input.type === 'group') {\n        this.renderGroup(input);\n      } else if (!input.isRequired) {\n        this.renderField(this.contentEl, input);\n      }\n    }\n\n    this.previewEl = this.contentEl.createDiv({ cls: CssClass.CodeBlockBuilderPreview });\n    this.renderOutput();\n    this.update();\n  }\n\n  private addResetButton(setting: Setting, field: CodeBlockBuilderField, reset: () => void): void {\n    if (field.isRequired) {\n      return;\n    }\n\n    setting.addExtraButton((button) => {\n      button\n        .setIcon('lucide-rotate-ccw')\n        .setTooltip(t(($) => $.obsidianLib.codeBlockBuilder.reset, { value: formatValue(field, field.defaultValue) || '\"\"' }))\n        .onClick(() => {\n          reset();\n          this.setValue(field.key, field.defaultValue);\n        });\n    });\n  }\n\n  private async copy(): Promise<void> {\n    try {\n      await this.containerEl.win.navigator.clipboard.writeText(this.codeBlock);\n      new Notice(t(($) => $.obsidianLib.codeBlockBuilder.copied));\n    } catch {\n      new Notice(t(($) => $.obsidianLib.codeBlockBuilder.copyFailed));\n    }\n  }\n\n  private insert(): void {\n    if (!this.editor) {\n      new Notice(t(($) => $.obsidianLib.codeBlockBuilder.insertUnavailable));\n      return;\n    }\n\n    const cursor = this.editor.getCursor('from');\n    const textBeforeCursor = this.editor.getLine(cursor.line).slice(0, cursor.ch);\n    const prefix = textBeforeCursor === '' ? '' : '\\n';\n    this.editor.replaceSelection(`${prefix}${this.codeBlock}\\n`);\n    this.insertedCodeBlock = this.codeBlock;\n    this.close();\n  }\n\n  private renderBooleanField(setting: Setting, field: CodeBlockBuilderBooleanField): void {\n    setting.addToggle((toggle) => {\n      toggle\n        .setValue(field.defaultValue)\n        .onChange((value) => {\n          this.setValue(field.key, value);\n        });\n      this.addResetButton(setting, field, () => {\n        toggle.setValue(field.defaultValue);\n      });\n    });\n  }\n\n  private renderColorField(setting: Setting, field: CodeBlockBuilderColorField): void {\n    setting.addColorPicker((colorPicker) => {\n      colorPicker\n        .setValue(field.defaultValue)\n        .onChange((value) => {\n          this.setValue(field.key, value);\n        });\n      this.addResetButton(setting, field, () => {\n        colorPicker.setValue(field.defaultValue);\n      });\n    });\n  }\n\n  private renderConditionalDropdownField(setting: Setting, field: CodeBlockBuilderConditionalDropdownField): void {\n    const initialGroupIndex = Math.max(0, field.groups.findIndex((group) => Object.hasOwn(toRecord(group.options), field.defaultValue)));\n    const groupDropdown = new DropdownComponent(setting.controlEl);\n    for (const [index, group] of field.groups.entries()) {\n      groupDropdown.addOption(String(index), group.name);\n    }\n    groupDropdown.setValue(String(initialGroupIndex));\n\n    const optionDropdown = new DropdownComponent(setting.controlEl);\n\n    function fillOptions(groupIndex: number, value?: string): string {\n      const options = toRecord(field.groups[groupIndex]?.options ?? []);\n      const selectedValue = value ?? Object.keys(options)[0] ?? '';\n      optionDropdown.selectEl.empty();\n      optionDropdown.addOptions(options);\n      optionDropdown.setValue(selectedValue);\n      return selectedValue;\n    }\n\n    fillOptions(initialGroupIndex, field.defaultValue);\n    optionDropdown.onChange((value) => {\n      this.setValue(field.key, value);\n    });\n\n    groupDropdown.onChange((value) => {\n      this.setValue(field.key, fillOptions(Number(value)));\n    });\n\n    this.addResetButton(setting, field, () => {\n      groupDropdown.setValue(String(initialGroupIndex));\n      fillOptions(initialGroupIndex, field.defaultValue);\n    });\n  }\n\n  private renderDropdownField(setting: Setting, field: CodeBlockBuilderDropdownField): void {\n    setting.addDropdown((dropdown) => {\n      dropdown\n        .addOptions(toRecord(field.options))\n        .setValue(field.defaultValue)\n        .onChange((value) => {\n          this.setValue(field.key, value);\n        });\n      this.addResetButton(setting, field, () => {\n        dropdown.setValue(field.defaultValue);\n      });\n    });\n  }\n\n  private renderField(containerEl: HTMLElement, field: CodeBlockBuilderField): void {\n    const setting = new Setting(containerEl).setName(field.name);\n    if (field.description !== undefined) {\n      setting.setDesc(field.description);\n    }\n\n    switch (field.type) {\n      case 'boolean': {\n        this.renderBooleanField(setting, field);\n        break;\n      }\n      case 'color': {\n        this.renderColorField(setting, field);\n        break;\n      }\n      case 'conditionalDropdown': {\n        this.renderConditionalDropdownField(setting, field);\n        break;\n      }\n      case 'dropdown': {\n        this.renderDropdownField(setting, field);\n        break;\n      }\n      case 'folder': {\n        this.renderFolderField(setting, field);\n        break;\n      }\n      case 'multipleDropdown': {\n        this.renderMultipleDropdownField(setting, field);\n        break;\n      }\n      case 'slider': {\n        this.renderSliderField(setting, field);\n        break;\n      }\n      case 'text': {\n        this.renderTextField(setting, field);\n        break;\n      }\n      default: {\n        assertNever(field);\n      }\n    }\n  }\n\n  private renderFolderField(setting: Setting, field: CodeBlockBuilderFolderField): void {\n    const options: Record<string, string> = {\n      [ROOT_FOLDER_PATH]: t(($) => $.obsidianLib.codeBlockBuilder.rootFolder)\n    };\n    const folderPaths = this.app.vault.getAllFolders(false).map((folder) => folder.path).sort((a, b) => a.localeCompare(b));\n    for (const folderPath of folderPaths) {\n      options[folderPath] = folderPath;\n    }\n\n    options[field.defaultValue] ??= field.defaultValue;\n\n    setting.addDropdown((dropdown) => {\n      dropdown\n        .addOptions(options)\n        .setValue(field.defaultValue)\n        .onChange((value) => {\n          this.setValue(field.key, value);\n        });\n      this.addResetButton(setting, field, () => {\n        dropdown.setValue(field.defaultValue);\n      });\n    });\n  }\n\n  private renderGroup(group: CodeBlockBuilderGroup): void {\n    const groupEl = this.contentEl.createDiv({ cls: CssClass.CodeBlockBuilderGroup });\n    const headingSetting = new Setting(groupEl).setName(group.name).setHeading();\n    const bodyEl = groupEl.createDiv({ cls: CssClass.CodeBlockBuilderGroupBody });\n\n    groupEl.addClass(CssClass.IsCollapsed);\n    headingSetting.addExtraButton((button) => {\n      const groupState = { button, groupEl };\n      this.groupStates.push(groupState);\n      updateGroupIcon(groupState);\n      button.onClick(() => {\n        this.setGroupExpanded(groupEl, groupEl.hasClass(CssClass.IsCollapsed));\n      });\n    });\n\n    for (const field of group.fields) {\n      this.renderField(bodyEl, field);\n    }\n\n    if (group.isInitiallyExpanded) {\n      this.setGroupExpanded(groupEl, true);\n    }\n  }\n\n  private renderMultipleDropdownField(setting: Setting, field: CodeBlockBuilderMultipleDropdownField): void {\n    const dropdown = new MultipleDropdownComponent(setting.controlEl)\n      .addOptions(toRecord(field.options))\n      .setValue(field.defaultValue)\n      .onChange((value) => {\n        this.setValue(field.key, value);\n      });\n    setting.addComponent(() => dropdown);\n    this.addResetButton(setting, field, () => {\n      dropdown.setValue(field.defaultValue);\n    });\n  }\n\n  private renderOutput(): void {\n    const setting = new Setting(this.contentEl).setName(t(($) => $.obsidianLib.codeBlockBuilder.output));\n    setting.settingEl.addClass(CssClass.CodeBlockBuilderOutput);\n    setting.addTextArea((textArea) => {\n      this.outputComponent = textArea;\n      textArea.inputEl.readOnly = true;\n    });\n    setting.addExtraButton((button) => {\n      button\n        .setIcon('lucide-copy')\n        .setTooltip(t(($) => $.obsidianLib.codeBlockBuilder.copy))\n        .onClick(() => {\n          invokeAsyncSafely(() => this.copy());\n        });\n    });\n    setting.addExtraButton((button) => {\n      button\n        .setIcon('lucide-file-input')\n        .setTooltip(t(($) => this.editor ? $.obsidianLib.codeBlockBuilder.insert : $.obsidianLib.codeBlockBuilder.insertUnavailable))\n        .onClick(() => {\n          this.insert();\n        });\n    });\n  }\n\n  private renderSliderField(setting: Setting, field: CodeBlockBuilderSliderField): void {\n    setting.addSlider((slider) => {\n      slider\n        .setLimits(Math.min(field.min, field.defaultValue), Math.max(field.max, field.defaultValue), field.step)\n        .setValue(field.defaultValue)\n        .onChange((value) => {\n          this.setValue(field.key, value);\n        });\n      this.addResetButton(setting, field, () => {\n        slider.setValue(field.defaultValue);\n      });\n    });\n  }\n\n  private renderTextField(setting: Setting, field: CodeBlockBuilderTextField): void {\n    setting.addText((text) => {\n      text\n        .setPlaceholder(field.placeholder ?? '')\n        .setValue(field.defaultValue)\n        .onChange((value) => {\n          if (field.validationPattern && !doesMatchPattern(field.validationPattern, value)) {\n            text.inputEl.setCustomValidity(t(($) => $.obsidianLib.codeBlockBuilder.invalidValue));\n            return;\n          }\n\n          text.inputEl.setCustomValidity('');\n          this.setValue(field.key, value);\n        });\n      this.addResetButton(setting, field, () => {\n        text.setValue(field.defaultValue);\n        text.inputEl.setCustomValidity('');\n      });\n    });\n  }\n\n  private setGroupExpanded(groupEl: HTMLElement, isExpanded: boolean): void {\n    for (const groupState of this.groupStates) {\n      const shouldExpand = isExpanded && groupState.groupEl === groupEl;\n      groupState.groupEl.toggleClass(CssClass.IsCollapsed, !shouldExpand);\n      updateGroupIcon(groupState);\n    }\n  }\n\n  private setValue(key: string, value: CodeBlockBuilderValue): void {\n    this.values.set(key, value);\n    this.update();\n  }\n\n  private update(): void {\n    this.codeBlock = formatCodeBlock({\n      fields: this.fields,\n      language: this.language,\n      values: this.values\n    });\n\n    // Only reached once `onOpen` has rendered the output and the preview element.\n    const outputComponent = ensureNonNullable(this.outputComponent);\n    outputComponent.setValue(this.codeBlock);\n    outputComponent.inputEl.rows = this.codeBlock.split('\\n').length;\n\n    if (this.onUpdatePreview) {\n      this.onUpdatePreview({\n        codeBlock: this.codeBlock,\n        previewEl: ensureNonNullable(this.previewEl),\n        values: this.values\n      });\n    }\n  }\n}\n\n/**\n * Formats a code block from its fields and their values.\n *\n * Each field holding a value other than its default, or marked {@link CodeBlockBuilderFieldBase.isRequired}, writes one\n * line, in the order of the fields; an empty value writes nothing. The fence is one backtick longer than the longest\n * backtick run in the lines, and never shorter than three.\n *\n * @param params - The fields, the language and the values.\n * @returns The code block, without a trailing newline.\n */\nexport function formatCodeBlock(params: FormatCodeBlockParams): string {\n  const lines: string[] = [];\n  for (const field of flattenFields(params.fields)) {\n    const value = params.values.get(field.key) ?? field.defaultValue;\n    const formattedValue = formatValue(field, value);\n    if (formattedValue === '') {\n      continue;\n    }\n\n    if (!field.isRequired && isSameValue(value, field.defaultValue)) {\n      continue;\n    }\n\n    lines.push(field.shouldOmitKey ? formattedValue : `${field.key}: ${formattedValue}`);\n  }\n\n  const body = lines.join('\\n');\n  const longestBacktickRun = Math.max(0, ...Array.from(body.matchAll(/`+/g), (match) => match[0].length));\n  const fence = '`'.repeat(Math.max(MIN_FENCE_LENGTH, longestBacktickRun + 1));\n  return lines.length === 0 ? `${fence}${params.language}\\n${fence}` : `${fence}${params.language}\\n${body}\\n${fence}`;\n}\n\n/**\n * Opens the code block builder modal.\n *\n * @param params - The fields of the code block and how to present them.\n * @returns A {@link Promise} that resolves with the code block when the user inserted it into the note, or with `null`\n * when the modal was closed otherwise.\n */\nexport async function showCodeBlockBuilder(params: ShowCodeBlockBuilderParams): Promise<null | string> {\n  return await showModal<null | string>((promiseResolve) =>\n    new CodeBlockBuilderModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n\nfunction doesMatchPattern(pattern: RegExp, value: string): boolean {\n  pattern.lastIndex = 0;\n  return pattern.test(value);\n}\n\nfunction flattenFields(inputs: readonly CodeBlockBuilderInput[]): CodeBlockBuilderField[] {\n  return inputs.flatMap((input) => input.type === 'group' ? input.fields : [input]);\n}\n\nfunction formatValue(field: CodeBlockBuilderField, value: CodeBlockBuilderValue): string {\n  const separator = field.type === 'multipleDropdown' ? field.separator ?? DEFAULT_SEPARATOR : DEFAULT_SEPARATOR;\n  return isStringArray(value) ? value.join(separator) : String(value);\n}\n\nfunction isSameValue(a: CodeBlockBuilderValue, b: CodeBlockBuilderValue): boolean {\n  return isStringArray(a) && isStringArray(b) ? a.length === b.length && a.every((item, index) => item === b[index]) : a === b;\n}\n\nfunction isStringArray(value: unknown): value is readonly string[] {\n  return Array.isArray(value);\n}\n\nfunction toRecord(options: CodeBlockBuilderOptions): Record<string, string> {\n  return isStringArray(options) ? Object.fromEntries(options.map((option) => [option, option])) : { ...options };\n}\n\nfunction updateGroupIcon(groupState: GroupState): void {\n  groupState.button.setIcon(groupState.groupEl.hasClass(CssClass.IsCollapsed) ? 'lucide-chevron-down' : 'lucide-chevron-up');\n}\n"],"mappings":"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","names":[]}