@mnaoumov/obsidian-lib 10.5.1 → 10.6.0

package/dist/lib/cjs/components/settings-facet-component.cjs

@@ -0,0 +1,136 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function 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 settings_facet_component_exports = {};
+__export(settings_facet_component_exports, {
+  SettingsFacetComponent: () => SettingsFacetComponent
+});
+module.exports = __toCommonJS(settings_facet_component_exports);
+var import_reconfigurable_editor_extension_component = require('./reconfigurable-editor-extension-component.cjs');
+class SettingsFacetComponent extends import_reconfigurable_editor_extension_component.ReconfigurableEditorExtensionComponent {
+  /**
+   * The settings the editors currently read.
+   *
+   * @returns The current settings.
+   */
+  get settings() {
+    return this._settings;
+  }
+  /**
+   * The facet the settings are provided to.
+   */
+  facet;
+  _settings;
+  /**
+   * Creates a new instance of the {@link SettingsFacetComponent} class.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super({
+      app: params.app,
+      editorExtensionRegistrar: params.editorExtensionRegistrar,
+      extension: params.facet.of(params.settings)
+    });
+    this.facet = params.facet;
+    this._settings = params.settings;
+  }
+  /**
+   * Provides new settings to every open editor and to every editor opened later.
+   *
+   * @param settings - The new settings.
+   */
+  setSettings(settings) {
+    this._settings = settings;
+    this.reconfigure(this.facet.of(settings));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SettingsFacetComponent
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/components/settings-facet-component.d.cts

@@ -0,0 +1,68 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Contains class {@link SettingsFacetComponent}: a plugin's settings provided to a settings facet in every editor,
+ * swapped at runtime.
+ */
+import type { Facet } from '@codemirror/state' with { 'resolution-mode': 'import' };
+import type { ReconfigurableEditorExtensionComponentConstructorParams } from './reconfigurable-editor-extension-component.cjs';
+import { ReconfigurableEditorExtensionComponent } from './reconfigurable-editor-extension-component.cjs';
+/**
+ * Parameters for the {@link SettingsFacetComponent} constructor.
+ *
+ * @typeParam T - The settings type.
+ */
+export interface SettingsFacetComponentConstructorParams<T> extends Pick<ReconfigurableEditorExtensionComponentConstructorParams, 'app' | 'editorExtensionRegistrar'> {
+    /**
+     * The facet the settings are provided to, usually made by `createSettingsFacet`.
+     */
+    readonly facet: Facet<T, T>;
+    /**
+     * The settings the editors start with.
+     */
+    readonly settings: T;
+}
+/**
+ * Provides a plugin's settings to a settings facet in every open editor and in every editor opened later.
+ *
+ * @typeParam T - The settings type.
+ *
+ * @example
+ * ```ts
+ * const settingsFacet = createSettingsFacet<MySettings>(DEFAULT_SETTINGS);
+ * const settingsFacetComponent = this.addChild(new SettingsFacetComponent({
+ *   app: this.app,
+ *   editorExtensionRegistrar: new PluginEditorExtensionRegistrar(this),
+ *   facet: settingsFacet,
+ *   settings: this.settings
+ * }));
+ * // After the settings change:
+ * settingsFacetComponent.setSettings(this.settings);
+ * ```
+ */
+export declare class SettingsFacetComponent<T> extends ReconfigurableEditorExtensionComponent {
+    /**
+     * The settings the editors currently read.
+     *
+     * @returns The current settings.
+     */
+    get settings(): T;
+    /**
+     * The facet the settings are provided to.
+     */
+    protected readonly facet: Facet<T, T>;
+    private _settings;
+    /**
+     * Creates a new instance of the {@link SettingsFacetComponent} class.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: SettingsFacetComponentConstructorParams<T>);
+    /**
+     * Provides new settings to every open editor and to every editor opened later.
+     *
+     * @param settings - The new settings.
+     */
+    setSettings(settings: T): void;
+}

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

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

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

@@ -52,6 +52,22 @@ export declare enum CssClass {
      * A CSS class for the file component.
      */
     FileComponent = "file-component",
+    /**
+     * A CSS class for rendered markdown whose headings and lists `registerFoldHandlers` made foldable.
+     */
+    FoldableMarkdown = "foldable-markdown",
+    /**
+     * A CSS class for the folder list component.
+     */
+    FolderListComponent = "folder-list-component",
+    /**
+     * A CSS class for the hotkey component.
+     */
+    HotkeyComponent = "hotkey-component",
+    /**
+     * A CSS class for the element an inline token renders into, in Reading view and in Live Preview.
+     */
+    InlineToken = "inline-token",
     /**
      * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the
      * app's own toggled controls.
@@ -65,6 +81,10 @@ export declare enum CssClass {
      * A CSS class for the library name, set on every element the library builds.
      */
     LibraryName = "obsidian-lib",
+    /**
+     * A CSS class for the reorderable list component.
+     */
+    ListComponent = "list-component",
     /**
      * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).
      */
@@ -231,6 +251,14 @@ export declare enum CssClass {
      * A CSS class for the setting component wrapper.
      */
     SettingComponentWrapper = "setting-component-wrapper",
+    /**
+     * A CSS class for the settings tabs.
+     */
+    SettingsTabs = "settings-tabs",
+    /**
+     * A CSS class for the tag list component.
+     */
+    TagListComponent = "tag-list-component",
     /**
      * A CSS class for the telephone component.
      */

package/dist/lib/cjs/desktop-request-url-stream.cjs

@@ -0,0 +1,258 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+ensureDisposeSymbols();
+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 desktop_request_url_stream_exports = {};
+__export(desktop_request_url_stream_exports, {
+  openDesktopRequestUrlStream: () => openDesktopRequestUrlStream
+});
+module.exports = __toCommonJS(desktop_request_url_stream_exports);
+var import_abort_controller = require('@mnaoumov/typescript-lib/abort-controller');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_node_http = require('node:http');
+var import_node_https = require('node:https');
+const MAX_REDIRECT_COUNT = 20;
+const HTTP_MOVED_PERMANENTLY_STATUS = 301;
+const HTTP_FOUND_STATUS = 302;
+const HTTP_SEE_OTHER_STATUS = 303;
+const HTTP_TEMPORARY_REDIRECT_STATUS = 307;
+const HTTP_PERMANENT_REDIRECT_STATUS = 308;
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
+  HTTP_FOUND_STATUS,
+  HTTP_MOVED_PERMANENTLY_STATUS,
+  HTTP_PERMANENT_REDIRECT_STATUS,
+  HTTP_SEE_OTHER_STATUS,
+  HTTP_TEMPORARY_REDIRECT_STATUS
+]);
+const BODY_HEADERS = /* @__PURE__ */ new Set(["content-length", "content-type"]);
+async function openDesktopRequestUrlStream(request) {
+  let currentRequest = {
+    abortSignal: request.abortSignal,
+    body: request.body,
+    headers: request.headers,
+    method: request.method,
+    url: request.url
+  };
+  for (let redirectCount = 0; ; redirectCount++) {
+    const incomingMessage = await sendRequest(currentRequest);
+    const status = (0, import_type_guards.ensureNonNullable)(incomingMessage.statusCode);
+    const location = incomingMessage.headers.location;
+    if (!REDIRECT_STATUSES.has(status) || location === void 0) {
+      return {
+        body: createIncomingMessageStream(incomingMessage, request.abortSignal),
+        headers: flattenHeaders(incomingMessage.headers),
+        status,
+        url: currentRequest.url
+      };
+    }
+    incomingMessage.resume();
+    if (redirectCount >= MAX_REDIRECT_COUNT) {
+      throw new TypeError(`Too many redirects requesting ${request.url}`);
+    }
+    const nextUrl = new URL(location, currentRequest.url);
+    if (nextUrl.protocol !== "http:" && nextUrl.protocol !== "https:") {
+      throw new TypeError(`Unsupported protocol ${nextUrl.protocol} in the redirect to ${nextUrl.href}`);
+    }
+    currentRequest = getRedirectedRequest(currentRequest, status, nextUrl.href);
+  }
+}
+function createIncomingMessageStream(incomingMessage, abortSignal) {
+  let isSettled = false;
+  let abortListener;
+  return new ReadableStream({
+    cancel() {
+      isSettled = true;
+      abortListener[Symbol.dispose]();
+      incomingMessage.destroy();
+    },
+    pull() {
+      incomingMessage.resume();
+    },
+    start(controller) {
+      function settle(error) {
+        if (isSettled) {
+          return;
+        }
+        isSettled = true;
+        if (error === void 0) {
+          controller.close();
+        } else {
+          controller.error(error);
+        }
+      }
+      incomingMessage.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+        if (Number(controller.desiredSize) <= 0) {
+          incomingMessage.pause();
+        }
+      });
+      incomingMessage.on("end", () => {
+        abortListener[Symbol.dispose]();
+        settle();
+      });
+      incomingMessage.on("error", (error) => {
+        abortListener[Symbol.dispose]();
+        settle(error);
+      });
+      abortListener = (0, import_abort_controller.onAbort)(abortSignal, () => {
+        settle(abortSignal.reason);
+        incomingMessage.destroy(abortSignal.reason);
+      });
+    }
+  });
+}
+function flattenHeaders(headers) {
+  const flatHeaders = {};
+  for (const [name, value] of Object.entries(headers)) {
+    flatHeaders[name] = [value].flat().join(", ");
+  }
+  return flatHeaders;
+}
+function getRedirectedRequest(request, status, url) {
+  const shouldSwitchToGet = status === HTTP_SEE_OTHER_STATUS || request.method === "POST" && (status === HTTP_MOVED_PERMANENTLY_STATUS || status === HTTP_FOUND_STATUS);
+  if (!shouldSwitchToGet) {
+    return { ...request, url };
+  }
+  return {
+    abortSignal: request.abortSignal,
+    body: void 0,
+    headers: Object.fromEntries(Object.entries(request.headers).filter(([name]) => !BODY_HEADERS.has(name.toLowerCase()))),
+    method: "GET",
+    url
+  };
+}
+async function sendRequest(params) {
+  const request = params.url.startsWith("https:") ? import_node_https.request : import_node_http.request;
+  return await new Promise((resolve, reject) => {
+    const clientRequest = request(params.url, {
+      headers: { ...params.headers },
+      method: params.method,
+      signal: params.abortSignal
+    }, resolve);
+    clientRequest.on("error", (error) => {
+      reject(params.abortSignal.aborted ? params.abortSignal.reason : error);
+    });
+    clientRequest.end(typeof params.body === "string" ? params.body : params.body && new Uint8Array(params.body));
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDesktopRequestUrlStream
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/desktop-request-url-stream.ts"],"sourcesContent":["/**\n * @file\n *\n * The desktop arm of {@link ./request-url.ts | requestUrlStream}: requests a URL through `node:http` /\n * `node:https`, so the response body streams as it arrives and an abort really cancels the request.\n *\n * Desktop only: it reads `node:http` and `node:https`. Reach it through `requestUrlStream`, which imports it\n * dynamically on desktop.\n *\n * Unlike Chromium's network stack, Node does not read the system proxy settings or certificate store, so a machine\n * that reaches the internet only through a proxy, or that intercepts TLS with its own root certificate, needs the\n * buffered `requestUrlEx` instead.\n */\n\n/* eslint-disable n/no-unsupported-features/node-builtins -- ReadableStream is the Obsidian renderer's Web API, not a Node builtin. */\n\nimport type {\n  IncomingHttpHeaders,\n  IncomingMessage\n} from 'node:http';\n\nimport { onAbort } from '@mnaoumov/typescript-lib/abort-controller';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { request as requestHttp } from 'node:http';\nimport { request as requestHttps } from 'node:https';\n\nimport type {\n  EncodedRequestUrlRequest,\n  RequestUrlStreamResponse\n} from './request-url.ts';\n\nconst MAX_REDIRECT_COUNT = 20;\nconst HTTP_MOVED_PERMANENTLY_STATUS = 301;\nconst HTTP_FOUND_STATUS = 302;\nconst HTTP_SEE_OTHER_STATUS = 303;\nconst HTTP_TEMPORARY_REDIRECT_STATUS = 307;\nconst HTTP_PERMANENT_REDIRECT_STATUS = 308;\nconst REDIRECT_STATUSES = new Set([\n  HTTP_FOUND_STATUS,\n  HTTP_MOVED_PERMANENTLY_STATUS,\n  HTTP_PERMANENT_REDIRECT_STATUS,\n  HTTP_SEE_OTHER_STATUS,\n  HTTP_TEMPORARY_REDIRECT_STATUS\n]);\nconst BODY_HEADERS = new Set(['content-length', 'content-type']);\n\ninterface SendRequestParams {\n  readonly abortSignal: AbortSignal;\n  readonly body: ArrayBuffer | string | undefined;\n  readonly headers: Readonly<Record<string, string>>;\n  readonly method: string;\n  readonly url: string;\n}\n\n/**\n * Requests a URL through `node:http` / `node:https` and returns its body as a stream, following redirects.\n *\n * @param request - The encoded request.\n * @returns The response, with a streamed body.\n */\nexport async function openDesktopRequestUrlStream(request: EncodedRequestUrlRequest): Promise<RequestUrlStreamResponse> {\n  let currentRequest: SendRequestParams = {\n    abortSignal: request.abortSignal,\n    body: request.body,\n    headers: request.headers,\n    method: request.method,\n    url: request.url\n  };\n\n  for (let redirectCount = 0;; redirectCount++) {\n    const incomingMessage = await sendRequest(currentRequest);\n    // A response to a client request always carries its status code.\n    const status = ensureNonNullable(incomingMessage.statusCode);\n    const location = incomingMessage.headers.location;\n    if (!REDIRECT_STATUSES.has(status) || location === undefined) {\n      return {\n        body: createIncomingMessageStream(incomingMessage, request.abortSignal),\n        headers: flattenHeaders(incomingMessage.headers),\n        status,\n        url: currentRequest.url\n      };\n    }\n\n    incomingMessage.resume();\n    if (redirectCount >= MAX_REDIRECT_COUNT) {\n      throw new TypeError(`Too many redirects requesting ${request.url}`);\n    }\n    const nextUrl = new URL(location, currentRequest.url);\n    if (nextUrl.protocol !== 'http:' && nextUrl.protocol !== 'https:') {\n      throw new TypeError(`Unsupported protocol ${nextUrl.protocol} in the redirect to ${nextUrl.href}`);\n    }\n    currentRequest = getRedirectedRequest(currentRequest, status, nextUrl.href);\n  }\n}\n\nfunction createIncomingMessageStream(incomingMessage: IncomingMessage, abortSignal: AbortSignal): ReadableStream<Uint8Array> {\n  let isSettled = false;\n  // Assigned in `start`, which runs inside the constructor, so it is in place before `cancel` can run.\n  let abortListener: Disposable;\n  return new ReadableStream<Uint8Array>({\n    cancel(): void {\n      isSettled = true;\n      abortListener[Symbol.dispose]();\n      incomingMessage.destroy();\n    },\n    pull(): void {\n      incomingMessage.resume();\n    },\n    start(controller): void {\n      function settle(error?: unknown): void {\n        if (isSettled) {\n          return;\n        }\n        isSettled = true;\n        if (error === undefined) {\n          controller.close();\n        } else {\n          controller.error(error);\n        }\n      }\n\n      incomingMessage.on('data', (chunk: Buffer) => {\n        // A copy, so the chunk belongs to the renderer's realm whatever Node does with its buffer afterwards.\n        controller.enqueue(new Uint8Array(chunk));\n        if (Number(controller.desiredSize) <= 0) {\n          incomingMessage.pause();\n        }\n      });\n      incomingMessage.on('end', () => {\n        abortListener[Symbol.dispose]();\n        settle();\n      });\n      incomingMessage.on('error', (error) => {\n        abortListener[Symbol.dispose]();\n        settle(error);\n      });\n      abortListener = onAbort(abortSignal, () => {\n        settle(abortSignal.reason);\n        // The `error` event this raises finds the stream settled already.\n        incomingMessage.destroy(abortSignal.reason as Error);\n      });\n    }\n  });\n}\nfunction flattenHeaders(headers: IncomingHttpHeaders): Record<string, string> {\n  const flatHeaders: Record<string, string> = {};\n  for (const [name, value] of Object.entries(headers)) {\n    // Node joins every repeated header but `set-cookie`, which arrives as an array.\n    flatHeaders[name] = [value].flat().join(', ');\n  }\n  return flatHeaders;\n}\n\nfunction getRedirectedRequest(request: SendRequestParams, status: number, url: string): SendRequestParams {\n  // What `fetch` does: a 303, and a 301 or 302 answering a POST, become a GET without a body.\n  const shouldSwitchToGet = status === HTTP_SEE_OTHER_STATUS\n    || (request.method === 'POST' && (status === HTTP_MOVED_PERMANENTLY_STATUS || status === HTTP_FOUND_STATUS));\n  if (!shouldSwitchToGet) {\n    return { ...request, url };\n  }\n  return {\n    abortSignal: request.abortSignal,\n    body: undefined,\n    headers: Object.fromEntries(Object.entries(request.headers).filter(([name]) => !BODY_HEADERS.has(name.toLowerCase()))),\n    method: 'GET',\n    url\n  };\n}\n\nasync function sendRequest(params: SendRequestParams): Promise<IncomingMessage> {\n  const request = params.url.startsWith('https:') ? requestHttps : requestHttp;\n  return await new Promise((resolve, reject) => {\n    const clientRequest = request(params.url, {\n      headers: { ...params.headers },\n      method: params.method,\n      signal: params.abortSignal\n    }, resolve);\n    clientRequest.on('error', (error) => {\n      reject(params.abortSignal.aborted ? params.abortSignal.reason as Error : error);\n    });\n    clientRequest.end(typeof params.body === 'string' ? params.body : params.body && new Uint8Array(params.body));\n  });\n}\n/* eslint-enable n/no-unsupported-features/node-builtins -- ReadableStream is the Obsidian renderer's Web API, not a Node builtin. */\n"],"mappings":"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","names":["requestHttps","requestHttp"]}

package/dist/lib/cjs/desktop-request-url-stream.d.cts

@@ -0,0 +1,22 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * The desktop arm of {@link ./request-url.ts | requestUrlStream}: requests a URL through `node:http` /
+ * `node:https`, so the response body streams as it arrives and an abort really cancels the request.
+ *
+ * Desktop only: it reads `node:http` and `node:https`. Reach it through `requestUrlStream`, which imports it
+ * dynamically on desktop.
+ *
+ * Unlike Chromium's network stack, Node does not read the system proxy settings or certificate store, so a machine
+ * that reaches the internet only through a proxy, or that intercepts TLS with its own root certificate, needs the
+ * buffered `requestUrlEx` instead.
+ */
+import type { EncodedRequestUrlRequest, RequestUrlStreamResponse } from './request-url.cjs';
+/**
+ * Requests a URL through `node:http` / `node:https` and returns its body as a stream, following redirects.
+ *
+ * @param request - The encoded request.
+ * @returns The response, with a streamed body.
+ */
+export declare function openDesktopRequestUrlStream(request: EncodedRequestUrlRequest): Promise<RequestUrlStreamResponse>;