@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/templater.mjs

@@ -0,0 +1,181 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { AppActiveFileProvider } from "./active-file-provider.mjs";
+import { getFile } from "./file-system.mjs";
+const TEMPLATER_PLUGIN_ID = "templater-obsidian";
+var TemplaterRunMode = /* @__PURE__ */ ((TemplaterRunMode2) => {
+  TemplaterRunMode2[TemplaterRunMode2["CreateNewFromTemplate"] = 0] = "CreateNewFromTemplate";
+  TemplaterRunMode2[TemplaterRunMode2["AppendActiveFile"] = 1] = "AppendActiveFile";
+  TemplaterRunMode2[TemplaterRunMode2["OverwriteFile"] = 2] = "OverwriteFile";
+  TemplaterRunMode2[TemplaterRunMode2["OverwriteActiveFile"] = 3] = "OverwriteActiveFile";
+  TemplaterRunMode2[TemplaterRunMode2["DynamicProcessor"] = 4] = "DynamicProcessor";
+  TemplaterRunMode2[TemplaterRunMode2["StartupTemplate"] = 5] = "StartupTemplate";
+  return TemplaterRunMode2;
+})(TemplaterRunMode || {});
+var TemplaterUnavailabilityReason = /* @__PURE__ */ ((TemplaterUnavailabilityReason2) => {
+  TemplaterUnavailabilityReason2["NotLoaded"] = "notLoaded";
+  TemplaterUnavailabilityReason2["ShapeChanged"] = "shapeChanged";
+  return TemplaterUnavailabilityReason2;
+})(TemplaterUnavailabilityReason || {});
+class TemplaterActiveFileProvider extends AppActiveFileProvider {
+  /**
+   * Gets the file the innermost in-flight {@link parseTemplate} render is for, or the workspace's active
+   * file when there is no render in flight.
+   *
+   * @returns The active file, or `null` if there is none.
+   */
+  getActiveFile() {
+    return getTemplaterRenderTargetFile() ?? super.getActiveFile();
+  }
+}
+class TemplaterUnavailableError extends Error {
+  /**
+   * Which of the two failures occurred.
+   */
+  reason;
+  /**
+   * Creates a {@link TemplaterUnavailableError}.
+   *
+   * @param reason - Why the API is unavailable.
+   */
+  constructor(reason) {
+    super(`The internal API of the plugin "${TEMPLATER_PLUGIN_ID}" is unavailable: ${reason}.`);
+    this.name = "TemplaterUnavailableError";
+    this.reason = reason;
+  }
+}
+async function getTemplaterFunctions(params) {
+  const {
+    app,
+    shouldReuseCurrent = true,
+    targetPathOrFile
+  } = params;
+  const api = requireTemplaterApi(app);
+  if (shouldReuseCurrent && api.current_functions_object) {
+    return api.current_functions_object;
+  }
+  const targetFile = getFile({
+    app,
+    pathOrFile: targetPathOrFile
+  });
+  const config = api.create_running_config(void 0, targetFile, 5 /* StartupTemplate */);
+  return await api.functions_generator.generate_object(config);
+}
+function getTemplaterRenderTargetFile() {
+  return renderTargetFiles.at(-1) ?? null;
+}
+async function parseTemplate(params) {
+  const {
+    app,
+    targetPathOrFile,
+    templatePathOrFile
+  } = params;
+  const templateFile = getFile({
+    app,
+    pathOrFile: templatePathOrFile
+  });
+  const targetFile = getFile({
+    app,
+    pathOrFile: targetPathOrFile
+  });
+  const api = requireTemplaterApi(app);
+  renderTargetFiles.push(targetFile);
+  try {
+    return await api.read_and_parse_template({
+      // eslint-disable-next-line camelcase -- Templater API.
+      run_mode: 4 /* DynamicProcessor */,
+      // eslint-disable-next-line camelcase -- Templater API.
+      target_file: targetFile,
+      // eslint-disable-next-line camelcase -- Templater API.
+      template_file: templateFile
+    });
+  } finally {
+    renderTargetFiles.pop();
+  }
+}
+function requireTemplaterApi(app) {
+  if (!app.plugins.getPlugin(TEMPLATER_PLUGIN_ID)) {
+    throw new TemplaterUnavailableError("notLoaded" /* NotLoaded */);
+  }
+  const api = resolveTemplaterApi(app);
+  if (!api) {
+    throw new TemplaterUnavailableError("shapeChanged" /* ShapeChanged */);
+  }
+  return api;
+}
+function resolveTemplaterApi(app) {
+  const plugin = app.plugins.getPlugin(TEMPLATER_PLUGIN_ID);
+  if (!plugin || !("templater" in plugin)) {
+    return null;
+  }
+  const templater = plugin.templater;
+  return isTemplaterApi(templater) ? templater : null;
+}
+const renderTargetFiles = [];
+function isTemplaterApi(value) {
+  if (typeof value !== "object" || value === null || !("create_running_config" in value) || typeof value.create_running_config !== "function" || !("read_and_parse_template" in value) || typeof value.read_and_parse_template !== "function" || !("functions_generator" in value)) {
+    return false;
+  }
+  const functionsGenerator = value.functions_generator;
+  return typeof functionsGenerator === "object" && functionsGenerator !== null && "generate_object" in functionsGenerator && typeof functionsGenerator.generate_object === "function";
+}
+export {
+  TEMPLATER_PLUGIN_ID,
+  TemplaterActiveFileProvider,
+  TemplaterRunMode,
+  TemplaterUnavailabilityReason,
+  TemplaterUnavailableError,
+  getTemplaterFunctions,
+  getTemplaterRenderTargetFile,
+  parseTemplate,
+  requireTemplaterApi,
+  resolveTemplaterApi
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/templater.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The slice of Templater's INTERNAL API this library talks to, and the runtime narrowing that gets hold\n * of it.\n *\n * **Templater publishes no API.** Rendering a template against a file and getting the resulting string\n * back is only reachable through undocumented internals hanging off\n * `app.plugins.getPlugin('templater-obsidian').templater` \u2014 `create_running_config`,\n * `functions_generator.generate_object`, `read_and_parse_template`, and a `RunMode` enum. Every plugin\n * that wants it re-derives the same reverse engineering, which is why it lives here instead.\n *\n * **This module is explicitly BEST-EFFORT.** Nothing it binds to is documented or covered by Templater's\n * semantic versioning, so a Templater release may rename or reshape any of it without warning. The shapes\n * below were read from Templater `2.24.3`. Two deliberate consequences follow:\n *\n * - {@link resolveTemplaterApi} returns `null` \u2014 a Templater too old, too new or too broken to talk to\n *   reads as \"not there\" and the integration stays dormant.\n * - {@link requireTemplaterApi} throws a {@link TemplaterUnavailableError} that NAMES the plugin and the\n *   reason, rather than letting a `Cannot read properties of undefined` surface from somewhere inside\n *   Templater.\n *\n * The types are DECLARED HERE rather than imported, and narrowed to the members actually called: Templater\n * ships no npm types package, and depending on it would turn an optional integration into a build-time\n * dependency.\n *\n * The second thing this module supplies is an active-file answer. While a template renders,\n * `app.workspace.getActiveFile()` still points at whatever the user happens to have open \u2014 NOT at the file\n * the template is being rendered for \u2014 so a plugin's own helper called from inside a template resolves\n * links against the wrong note. {@link TemplaterActiveFileProvider} answers with the render target for the\n * duration of a {@link parseTemplate} call and falls back to the workspace otherwise. Note this is about\n * the CONSUMER's helpers: Templater's own `tp.file.*` already resolves through the running config's\n * `target_file` and needs no help.\n */\n\nimport type {\n  App,\n  TFile\n} from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport { AppActiveFileProvider } from './active-file-provider.ts';\nimport { getFile } from './file-system.ts';\n\n/**\n * Parameters for {@link getTemplaterFunctions}.\n */\nexport interface GetTemplaterFunctionsParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether to return Templater's `current_functions_object` when it already has one, instead of\n   * generating a fresh object. Reuse is cheaper and gives the object of the render currently in flight;\n   * pass `false` to force a new one built for `targetPathOrFile`.\n   *\n   * @default `true`\n   */\n  readonly shouldReuseCurrent?: boolean;\n\n  /**\n   * The file the generated functions should resolve against \u2014 what `tp.file.*` reports.\n   */\n  readonly targetPathOrFile: PathOrFile;\n}\n\n/**\n * Parameters for {@link parseTemplate}.\n */\nexport interface ParseTemplateParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The file the template is rendered FOR. It is what `tp.file.*` resolves to inside the template, and\n   * what {@link TemplaterActiveFileProvider} reports for the duration of the call.\n   */\n  readonly targetPathOrFile: PathOrFile;\n\n  /**\n   * The template file to render.\n   */\n  readonly templatePathOrFile: PathOrFile;\n}\n\n/**\n * Templater's internal API object, narrowed to the members this library calls.\n *\n * Its members are `snake_case` because Templater's are; they are transcribed rather than renamed so the\n * shape can be checked against Templater's source at a glance.\n */\nexport interface TemplaterApi {\n  /**\n   * Builds the {@link TemplaterRunningConfig} that describes one render.\n   *\n   * @param templateFile - The template being rendered, or `undefined` when there is none (as when only\n   * the functions object is wanted).\n   * @param targetFile - The file the render is for.\n   * @param runMode - Which {@link TemplaterRunMode} the render is.\n   * @returns The running config.\n   */\n  create_running_config: (templateFile: TFile | undefined, targetFile: TFile, runMode: TemplaterRunMode) => TemplaterRunningConfig;\n\n  /**\n   * The functions object (`tp`) of the render currently in flight, when there is one.\n   */\n  current_functions_object?: object | undefined;\n\n  /**\n   * Builds the functions object (`tp`) a template is evaluated against.\n   */\n  functions_generator: TemplaterFunctionsGenerator;\n\n  /**\n   * Reads the config's `template_file` and renders it, returning the resulting text.\n   *\n   * @param config - The {@link TemplaterRunningConfig} describing the render. Templater throws when its\n   * `template_file` is not a `TFile`.\n   * @returns A {@link Promise} resolving to the rendered text.\n   */\n  read_and_parse_template: (config: TemplaterRunningConfig) => Promise<string>;\n}\n\n/**\n * The `functions_generator` half of {@link TemplaterApi}.\n */\nexport interface TemplaterFunctionsGenerator {\n  /**\n   * Builds the functions object (`tp`) for a running config.\n   *\n   * @param config - The {@link TemplaterRunningConfig} to build for.\n   * @returns A {@link Promise} resolving to the functions object.\n   */\n  generate_object: (config: TemplaterRunningConfig) => Promise<object>;\n}\n\n/**\n * One Templater render, as Templater's `create_running_config` describes it.\n *\n * Its members are `snake_case` because Templater's are.\n */\nexport interface TemplaterRunningConfig {\n  /**\n   * The file Templater considers active. Templater fills this in itself from\n   * `workspace.activeEditor?.file ?? workspace.getActiveFile()`; it is optional here because a\n   * hand-built config may omit it.\n   */\n  active_file?: null | TFile | undefined;\n\n  /**\n   * Which {@link TemplaterRunMode} the render is.\n   */\n  run_mode: TemplaterRunMode;\n\n  /**\n   * The file the render is for \u2014 what `tp.file.*` resolves to.\n   */\n  target_file: TFile;\n\n  /**\n   * The template being rendered, when there is one.\n   */\n  template_file?: TFile | undefined;\n}\n\n/**\n * Templater's plugin id, as its manifest declares it.\n */\nexport const TEMPLATER_PLUGIN_ID = 'templater-obsidian';\n\n/* eslint-disable no-magic-numbers -- These are Templater's own `RunMode` values, transcribed. */\n/**\n * Templater's `RunMode` enum, which says what kind of render a {@link TemplaterRunningConfig} describes.\n *\n * The numeric values ARE Templater's, and the members are listed in its declaration order so the two can\n * be compared line for line. They are written out explicitly all the same, because they cross into\n * Templater as integers \u2014 never renumber them.\n */\nexport enum TemplaterRunMode {\n  /**\n   * Render the template into a newly created file.\n   */\n  CreateNewFromTemplate = 0,\n\n  /**\n   * Render the template and append the result to the active file.\n   */\n  AppendActiveFile = 1,\n\n  /**\n   * Render the template and overwrite a given file with the result.\n   */\n  OverwriteFile = 2,\n\n  /**\n   * Render the template and overwrite the active file with the result.\n   */\n  OverwriteActiveFile = 3,\n\n  /**\n   * Render the template on demand, for a caller that wants the resulting text rather than a file\n   * written. This is what {@link parseTemplate} uses.\n   */\n  DynamicProcessor = 4,\n\n  /**\n   * Render the template as a startup template. {@link getTemplaterFunctions} uses it for the throwaway\n   * config it builds, because that config renders nothing.\n   */\n  StartupTemplate = 5\n}\n/* eslint-enable no-magic-numbers -- These are Templater's own `RunMode` values, transcribed. */\n\n/**\n * Why Templater's internal API could not be handed over.\n */\nexport enum TemplaterUnavailabilityReason {\n  /**\n   * Templater is not installed, or is installed but disabled. Obsidian's `getPlugin` cannot tell the two\n   * apart \u2014 it returns nothing either way.\n   */\n  NotLoaded = 'notLoaded',\n\n  /**\n   * Templater is loaded, but does not expose the internals this library calls \u2014 it is too old, too new,\n   * or has been reshaped.\n   */\n  ShapeChanged = 'shapeChanged'\n}\n\n/**\n * Active-file provider that answers with the file a {@link parseTemplate} render is currently for,\n * falling back to the workspace's active file when no render is in flight.\n *\n * This is the piece that makes a consumer's own template helpers resolve against the right note: during a\n * render the workspace still has whatever the user was looking at open, which is rarely the target.\n */\nexport class TemplaterActiveFileProvider extends AppActiveFileProvider {\n  /**\n   * Gets the file the innermost in-flight {@link parseTemplate} render is for, or the workspace's active\n   * file when there is no render in flight.\n   *\n   * @returns The active file, or `null` if there is none.\n   */\n  public override getActiveFile(): null | TFile {\n    return getTemplaterRenderTargetFile() ?? super.getActiveFile();\n  }\n}\n\n/**\n * Thrown when Templater's internal API cannot be handed over, carrying the\n * {@link TemplaterUnavailabilityReason} that says why.\n */\nexport class TemplaterUnavailableError extends Error {\n  /**\n   * Which of the two failures occurred.\n   */\n  public readonly reason: TemplaterUnavailabilityReason;\n\n  /**\n   * Creates a {@link TemplaterUnavailableError}.\n   *\n   * @param reason - Why the API is unavailable.\n   */\n  public constructor(reason: TemplaterUnavailabilityReason) {\n    super(`The internal API of the plugin \"${TEMPLATER_PLUGIN_ID}\" is unavailable: ${reason}.`);\n    this.name = 'TemplaterUnavailableError';\n    this.reason = reason;\n  }\n}\n\n/**\n * Gets Templater's functions object \u2014 the `tp` a template is evaluated against \u2014 so a caller can invoke\n * `tp.date.now()`, `tp.file.title` and the rest outside a template.\n *\n * @param params - The {@link GetTemplaterFunctionsParams}.\n * @returns A {@link Promise} resolving to the functions object.\n * @throws A {@link TemplaterUnavailableError} when Templater is not loaded or its shape has changed.\n */\nexport async function getTemplaterFunctions(params: GetTemplaterFunctionsParams): Promise<object> {\n  const {\n    app,\n    shouldReuseCurrent = true,\n    targetPathOrFile\n  } = params;\n  const api = requireTemplaterApi(app);\n\n  if (shouldReuseCurrent && api.current_functions_object) {\n    return api.current_functions_object;\n  }\n\n  const targetFile = getFile({\n    app,\n    pathOrFile: targetPathOrFile\n  });\n  const config = api.create_running_config(undefined, targetFile, TemplaterRunMode.StartupTemplate);\n  return await api.functions_generator.generate_object(config);\n}\n\n/**\n * Gets the file the innermost in-flight {@link parseTemplate} render is for.\n *\n * Renders nest \u2014 a template may render another \u2014 so the calls form a stack and this reports the top of\n * it. Outside any render it is `null`.\n *\n * @returns The render target, or `null` when no render is in flight.\n */\nexport function getTemplaterRenderTargetFile(): null | TFile {\n  return renderTargetFiles.at(-1) ?? null;\n}\n\n/**\n * Renders a Templater template against a target file and returns the resulting text, without writing\n * anything.\n *\n * For the duration of the call {@link getTemplaterRenderTargetFile} and\n * {@link TemplaterActiveFileProvider} report `targetPathOrFile`, so a consumer's own helpers invoked from\n * inside the template resolve against it rather than against whatever the user has open.\n *\n * @param params - The {@link ParseTemplateParams}.\n * @returns A {@link Promise} resolving to the rendered text.\n * @throws A {@link TemplaterUnavailableError} when Templater is not loaded or its shape has changed.\n */\nexport async function parseTemplate(params: ParseTemplateParams): Promise<string> {\n  const {\n    app,\n    targetPathOrFile,\n    templatePathOrFile\n  } = params;\n  const templateFile = getFile({\n    app,\n    pathOrFile: templatePathOrFile\n  });\n  const targetFile = getFile({\n    app,\n    pathOrFile: targetPathOrFile\n  });\n  const api = requireTemplaterApi(app);\n\n  renderTargetFiles.push(targetFile);\n  try {\n    return await api.read_and_parse_template({\n      // eslint-disable-next-line camelcase -- Templater API.\n      run_mode: TemplaterRunMode.DynamicProcessor,\n      // eslint-disable-next-line camelcase -- Templater API.\n      target_file: targetFile,\n      // eslint-disable-next-line camelcase -- Templater API.\n      template_file: templateFile\n    });\n  } finally {\n    renderTargetFiles.pop();\n  }\n}\n\n/**\n * Gets Templater's internal API, throwing when it cannot be had.\n *\n * Use this where the caller cannot carry on without Templater \u2014 the error names the plugin and says which\n * of the two failures occurred. Use {@link resolveTemplaterApi} instead where the integration is optional.\n *\n * @param app - The Obsidian app instance.\n * @returns Templater's internal API.\n * @throws A {@link TemplaterUnavailableError} when Templater is not loaded or its shape has changed.\n */\nexport function requireTemplaterApi(app: App): TemplaterApi {\n  if (!app.plugins.getPlugin(TEMPLATER_PLUGIN_ID)) {\n    throw new TemplaterUnavailableError(TemplaterUnavailabilityReason.NotLoaded);\n  }\n\n  const api = resolveTemplaterApi(app);\n  if (!api) {\n    throw new TemplaterUnavailableError(TemplaterUnavailabilityReason.ShapeChanged);\n  }\n\n  return api;\n}\n\n/**\n * Gets Templater's internal API, when Templater is installed, enabled and still the shape this library\n * expects.\n *\n * @param app - The Obsidian app instance.\n * @returns The internal API, or `null` when Templater is not there to talk to.\n */\nexport function resolveTemplaterApi(app: App): null | TemplaterApi {\n  const plugin = app.plugins.getPlugin(TEMPLATER_PLUGIN_ID);\n  if (!plugin || !('templater' in plugin)) {\n    return null;\n  }\n\n  const templater: unknown = plugin.templater;\n  return isTemplaterApi(templater) ? templater : null;\n}\n\n/*\n * The stack of files in-flight `parseTemplate` calls are rendering for, innermost last. A stack rather\n * than a single slot because a template may render another, and an array rather than a reassigned\n * variable because pushing and popping a `const` needs no write to an outer binding across an `await`.\n */\nconst renderTargetFiles: TFile[] = [];\n\n/**\n * Checks that a value is Templater's internal API, by the members this library actually calls.\n *\n * A predicate rather than a cast on purpose: `templater` is not part of Obsidian's `Plugin` type, so the\n * value arrives as `unknown` and the only honest way to type it is to VERIFY it. A Templater that renames\n * one of these therefore reads as \"not there\", instead of throwing from inside a render.\n *\n * @param value - The candidate `templater` object.\n * @returns Whether it carries every member this library calls.\n */\nfunction isTemplaterApi(value: unknown): value is TemplaterApi {\n  if (typeof value !== 'object' || value === null || !('create_running_config' in value) || typeof value.create_running_config !== 'function' || !('read_and_parse_template' in value) || typeof value.read_and_parse_template !== 'function' || !('functions_generator' in value)) {\n    return false;\n  }\n\n  const functionsGenerator: unknown = value.functions_generator;\n  return typeof functionsGenerator === 'object' && functionsGenerator !== null && 'generate_object' in functionsGenerator && typeof functionsGenerator.generate_object === 'function';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAS,6BAA6B;AACtC,SAAS,eAAe;AAkIjB,MAAM,sBAAsB;AAU5B,IAAK,mBAAL,kBAAKA,sBAAL;AAIL,EAAAA,oCAAA,2BAAwB,KAAxB;AAKA,EAAAA,oCAAA,sBAAmB,KAAnB;AAKA,EAAAA,oCAAA,mBAAgB,KAAhB;AAKA,EAAAA,oCAAA,yBAAsB,KAAtB;AAMA,EAAAA,oCAAA,sBAAmB,KAAnB;AAMA,EAAAA,oCAAA,qBAAkB,KAAlB;AA/BU,SAAAA;AAAA,GAAA;AAsCL,IAAK,gCAAL,kBAAKC,mCAAL;AAKL,EAAAA,+BAAA,eAAY;AAMZ,EAAAA,+BAAA,kBAAe;AAXL,SAAAA;AAAA,GAAA;AAqBL,MAAM,oCAAoC,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrD,gBAA8B;AAC5C,WAAO,6BAA6B,KAAK,MAAM,cAAc;AAAA,EAC/D;AACF;AAMO,MAAM,kCAAkC,MAAM;AAAA;AAAA;AAAA;AAAA,EAInC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,YAAY,QAAuC;AACxD,UAAM,mCAAmC,mBAAmB,qBAAqB,MAAM,GAAG;AAC1F,SAAK,OAAO;AACZ,SAAK,SAAS;AAAA,EAChB;AACF;AAUA,eAAsB,sBAAsB,QAAsD;AAChG,QAAM;AAAA,IACJ;AAAA,IACA,qBAAqB;AAAA,IACrB;AAAA,EACF,IAAI;AACJ,QAAM,MAAM,oBAAoB,GAAG;AAEnC,MAAI,sBAAsB,IAAI,0BAA0B;AACtD,WAAO,IAAI;AAAA,EACb;AAEA,QAAM,aAAa,QAAQ;AAAA,IACzB;AAAA,IACA,YAAY;AAAA,EACd,CAAC;AACD,QAAM,SAAS,IAAI,sBAAsB,QAAW,YAAY,uBAAgC;AAChG,SAAO,MAAM,IAAI,oBAAoB,gBAAgB,MAAM;AAC7D;AAUO,SAAS,+BAA6C;AAC3D,SAAO,kBAAkB,GAAG,EAAE,KAAK;AACrC;AAcA,eAAsB,cAAc,QAA8C;AAChF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,eAAe,QAAQ;AAAA,IAC3B;AAAA,IACA,YAAY;AAAA,EACd,CAAC;AACD,QAAM,aAAa,QAAQ;AAAA,IACzB;AAAA,IACA,YAAY;AAAA,EACd,CAAC;AACD,QAAM,MAAM,oBAAoB,GAAG;AAEnC,oBAAkB,KAAK,UAAU;AACjC,MAAI;AACF,WAAO,MAAM,IAAI,wBAAwB;AAAA;AAAA,MAEvC,UAAU;AAAA;AAAA,MAEV,aAAa;AAAA;AAAA,MAEb,eAAe;AAAA,IACjB,CAAC;AAAA,EACH,UAAE;AACA,sBAAkB,IAAI;AAAA,EACxB;AACF;AAYO,SAAS,oBAAoB,KAAwB;AAC1D,MAAI,CAAC,IAAI,QAAQ,UAAU,mBAAmB,GAAG;AAC/C,UAAM,IAAI,0BAA0B,2BAAuC;AAAA,EAC7E;AAEA,QAAM,MAAM,oBAAoB,GAAG;AACnC,MAAI,CAAC,KAAK;AACR,UAAM,IAAI,0BAA0B,iCAA0C;AAAA,EAChF;AAEA,SAAO;AACT;AASO,SAAS,oBAAoB,KAA+B;AACjE,QAAM,SAAS,IAAI,QAAQ,UAAU,mBAAmB;AACxD,MAAI,CAAC,UAAU,EAAE,eAAe,SAAS;AACvC,WAAO;AAAA,EACT;AAEA,QAAM,YAAqB,OAAO;AAClC,SAAO,eAAe,SAAS,IAAI,YAAY;AACjD;AAOA,MAAM,oBAA6B,CAAC;AAYpC,SAAS,eAAe,OAAuC;AAC7D,MAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,EAAE,2BAA2B,UAAU,OAAO,MAAM,0BAA0B,cAAc,EAAE,6BAA6B,UAAU,OAAO,MAAM,4BAA4B,cAAc,EAAE,yBAAyB,QAAQ;AAChR,WAAO;AAAA,EACT;AAEA,QAAM,qBAA8B,MAAM;AAC1C,SAAO,OAAO,uBAAuB,YAAY,uBAAuB,QAAQ,qBAAqB,sBAAsB,OAAO,mBAAmB,oBAAoB;AAC3K;",
  "names": ["TemplaterRunMode", "TemplaterUnavailabilityReason"]
}


package/dist/lib/esm/transformers/duration-transformer.d.mts

@@ -0,0 +1,39 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * A transformer that can transform Duration to an ISO string and back.
+ */
+import { TypedTransformer } from '@mnaoumov/typescript-lib/transformers/typed-transformer';
+/**
+ * A transformer that converts a Duration to an ISO string and back.
+ */
+export declare class DurationTransformer extends TypedTransformer<moment.Duration, string> {
+    /**
+     * An id of the transformer.
+     *
+     * @returns The id of the transformer.
+     */
+    get id(): string;
+    /**
+     * Checks if the value is a Duration.
+     *
+     * @param value - The value to check.
+     * @returns `true` if the value is a Duration, `false` otherwise.
+     */
+    canTransform(value: unknown): value is moment.Duration;
+    /**
+     * Restores the value from a string.
+     *
+     * @param transformedValue - The string to restore the value from.
+     * @returns The restored value.
+     */
+    restoreValue(transformedValue: string): moment.Duration;
+    /**
+     * Transforms the value to a string.
+     *
+     * @param value - The value to transform.
+     * @returns The transformed value.
+     */
+    transformValue(value: moment.Duration): string;
+}

package/dist/lib/esm/transformers/duration-transformer.mjs

@@ -0,0 +1,93 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { TypedTransformer } from "@mnaoumov/typescript-lib/transformers/typed-transformer";
+import { moment } from "obsidian";
+class DurationTransformer extends TypedTransformer {
+  /**
+   * An id of the transformer.
+   *
+   * @returns The id of the transformer.
+   */
+  get id() {
+    return "duration";
+  }
+  /**
+   * Checks if the value is a Duration.
+   *
+   * @param value - The value to check.
+   * @returns `true` if the value is a Duration, `false` otherwise.
+   */
+  canTransform(value) {
+    const maybeDuration = value ?? {};
+    return !!maybeDuration.asHours && !!maybeDuration.asMinutes && !!maybeDuration.asSeconds && !!maybeDuration.asMilliseconds;
+  }
+  /**
+   * Restores the value from a string.
+   *
+   * @param transformedValue - The string to restore the value from.
+   * @returns The restored value.
+   */
+  restoreValue(transformedValue) {
+    return moment.duration(transformedValue);
+  }
+  /**
+   * Transforms the value to a string.
+   *
+   * @param value - The value to transform.
+   * @returns The transformed value.
+   */
+  transformValue(value) {
+    return value.toISOString();
+  }
+}
+export {
+  DurationTransformer
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+/// <reference path="../library.d.mts" />
+export * as 'duration-transformer' from './duration-transformer.mjs';

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

@@ -0,0 +1,54 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import * as duration_transformer from "./duration-transformer.mjs";
+export {
+  duration_transformer as "duration-transformer"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3RyYW5zZm9ybWVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdkdXJhdGlvbi10cmFuc2Zvcm1lcicgZnJvbSAnLi9kdXJhdGlvbi10cmFuc2Zvcm1lci50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsWUFBWUEsMEJBQTRCOyIsCiAgIm5hbWVzIjogWyJkdXJhdGlvbi10cmFuc2Zvcm1lciJdCn0K

package/dist/lib/esm/trusted-input.d.mts

@@ -0,0 +1,131 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Trusted input helpers that work on **either platform** — the documented entry point for keystrokes,
+ * pointer moves and clicks that Obsidian actually believes.
+ *
+ * Untrusted input (`element.dispatchEvent(new MouseEvent('click'))`) is silently ignored by CodeMirror,
+ * by the CSS `:hover` engine and by every `e.isTrusted` guard in Obsidian, so a test driving it exercises
+ * nothing while still passing. A trusted event has to come from outside the renderer, and how it gets
+ * there is platform-specific: Electron's `webContents.sendInputEvent` on desktop, a CDP injection
+ * round-tripped through the harness's host channel on mobile.
+ *
+ * This module **internalizes that split**, as every public-facing API here must: it stays
+ * cross-platform-loadable — no platform-only module is on its import graph — and each helper defers to a
+ * `Platform`-gated call-time dynamic `import()` of the arm that fits. So a consumer writes
+ * `await clickElement({ element })` once and never a platform check.
+ *
+ * The arms remain importable directly, for a caller making a deliberate platform commitment:
+ * {@link ./desktop-trusted-input.ts | desktop-trusted-input} and
+ * {@link ./mobile-trusted-input.ts | mobile-trusted-input}. Prefer this facade otherwise.
+ *
+ * **Every helper must be awaited.** The desktop arm has nothing to wait for, but the mobile arm's
+ * injection is a round-trip to the host, so a missing `await` lets the assertion run before the input has
+ * landed. The signature is the same on both platforms precisely so that a suite growing a mobile lane
+ * does not have to be rewritten.
+ *
+ * **Not every helper survives the port.** `moveMouse`, `hoverElement` and `unhoverElement` **throw** on
+ * mobile: a touch screen has no persistent pointer and `:hover` has no touch equivalent. They throw
+ * rather than no-op, because a silent no-op is exactly the false confidence trusted input exists to end.
+ * Gate those on `Platform.isDesktopApp`, or drive the element with {@link clickElement} instead.
+ *
+ * **Every Obsidian window is its own target.** A popout is a separate Electron web contents, so input sent
+ * to the main window never reaches it. {@link pressKey}, {@link clickMouse} and {@link moveMouse} take an
+ * optional `window` (the main window by default); the element and editor helpers use the window that owns
+ * their element or editor. Mobile has no popouts, so any window but the main one throws there.
+ */
+import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.mjs';
+export type { ClickElementParams, ClickMouseParams, HoverElementParams, MouseButton, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.mjs';
+/**
+ * Clicks the center of an element using **trusted** input — Electron's `sendInputEvent` on desktop, a CDP
+ * touch tap in the WebView on mobile.
+ *
+ * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /
+ * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the
+ * element's center — the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside
+ * `.cm-sizer`, so no element's center lands on it.
+ *
+ * @param params - The element to click, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickElement(params: ClickElementParams): Promise<void>;
+/**
+ * Clicks at the given viewport coordinates using **trusted** input, so the renderer synthesizes a real
+ * `click` (or `contextmenu`, for the right button) with `isTrusted === true`.
+ *
+ * The low-level primitive: one click at one point, with no waiting for any effect — callers poll their own
+ * readiness signal. Prefer {@link clickElement} for element-relative clicks.
+ *
+ * A real context menu actually opens, so a suite driving a right click must close it (or remove the
+ * leftover `.menu` element) before the next test.
+ *
+ * **On mobile the button model does not survive the port**: touch has no buttons, so `'left'` (the
+ * default) is a **tap**, `'right'` is the **long-press** that opens Obsidian Mobile's context menu, and
+ * `'middle'` throws.
+ *
+ * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickMouse(params: ClickMouseParams): Promise<void>;
+/**
+ * Moves the pointer to the center of an element using **trusted** pointer input, then polls until the
+ * element actually matches `:hover`.
+ *
+ * **Desktop only** — it throws on mobile, where `:hover` has no touch equivalent.
+ *
+ * @param params - The element to hover.
+ * @returns A {@link Promise} that resolves once the element matches `:hover`.
+ */
+export declare function hoverElement(params: HoverElementParams): Promise<void>;
+/**
+ * Moves the pointer to the given viewport coordinates using a **trusted** pointer move, so `:hover` rules
+ * genuinely apply.
+ *
+ * The low-level primitive: a single move that does **not** wait for any state to settle. Prefer
+ * {@link hoverElement} / {@link unhoverElement} for element-relative moves.
+ *
+ * **Desktop only** — it throws on mobile, which has no persistent pointer to move.
+ *
+ * @param params - The viewport coordinates to move to.
+ * @returns A {@link Promise} that resolves once the move has been injected.
+ */
+export declare function moveMouse(params: MoveMouseParams): Promise<void>;
+/**
+ * Presses a single key (optionally with modifiers) using **trusted** keyboard input, firing the full real
+ * key pipeline — `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
+ *
+ * It is delivered to the window's DOM-focused element, so the caller focuses the target first and then
+ * awaits the expected effect; the press itself polls for nothing. On mobile the accepted keys are the
+ * named ones (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) plus single printable
+ * characters — anything else throws rather than pressing nothing.
+ *
+ * @param params - The key to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the key press has been injected.
+ */
+export declare function pressKey(params: PressKeyParams): Promise<void>;
+/**
+ * Types text into a CodeMirror editor using **trusted** keyboard input.
+ *
+ * Focuses the editor (caret to the end) and presses every code point of the text — the same trusted
+ * sequence a real user produces — so the text reaches the document **only if the editor genuinely holds
+ * focus**. Then it polls until the document reflects the input, or a bounded timeout elapses (the expected
+ * outcome when the editor is read-only or focus was stolen).
+ *
+ * @param params - The editor to type into and the text to type.
+ * @returns A {@link Promise} that resolves once the keystrokes have settled.
+ */
+export declare function typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;
+/**
+ * Moves the pointer to a point just outside an element's bounding box using a **trusted** pointer move,
+ * then polls until the element no longer matches `:hover`.
+ *
+ * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box
+ * is reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.
+ *
+ * **Desktop only** — it throws on mobile, for the same reason {@link hoverElement} does.
+ *
+ * @param params - The element to move the pointer away from.
+ * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.
+ */
+export declare function unhoverElement(params: UnhoverElementParams): Promise<void>;