@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/templater.cjs

@@ -0,0 +1,279 @@
+/*
+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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(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);
+    }
+    if (globalThis.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 templater_exports = {};
+__export(templater_exports, {
+  TEMPLATER_PLUGIN_ID: () => TEMPLATER_PLUGIN_ID,
+  TemplaterActiveFileProvider: () => TemplaterActiveFileProvider,
+  TemplaterRunMode: () => TemplaterRunMode,
+  TemplaterUnavailabilityReason: () => TemplaterUnavailabilityReason,
+  TemplaterUnavailableError: () => TemplaterUnavailableError,
+  getTemplaterFunctions: () => getTemplaterFunctions,
+  getTemplaterRenderTargetFile: () => getTemplaterRenderTargetFile,
+  parseTemplate: () => parseTemplate,
+  requireTemplaterApi: () => requireTemplaterApi,
+  resolveTemplaterApi: () => resolveTemplaterApi
+});
+module.exports = __toCommonJS(templater_exports);
+var import_active_file_provider = require('./active-file-provider.cjs');
+var import_file_system = require('./file-system.cjs');
+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 import_active_file_provider.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 = (0, import_file_system.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 = (0, import_file_system.getFile)({
+    app,
+    pathOrFile: templatePathOrFile
+  });
+  const targetFile = (0, import_file_system.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";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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": "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",
  "names": ["TemplaterRunMode", "TemplaterUnavailabilityReason"]
}


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

@@ -0,0 +1,284 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * The slice of Templater's INTERNAL API this library talks to, and the runtime narrowing that gets hold
+ * of it.
+ *
+ * **Templater publishes no API.** Rendering a template against a file and getting the resulting string
+ * back is only reachable through undocumented internals hanging off
+ * `app.plugins.getPlugin('templater-obsidian').templater` — `create_running_config`,
+ * `functions_generator.generate_object`, `read_and_parse_template`, and a `RunMode` enum. Every plugin
+ * that wants it re-derives the same reverse engineering, which is why it lives here instead.
+ *
+ * **This module is explicitly BEST-EFFORT.** Nothing it binds to is documented or covered by Templater's
+ * semantic versioning, so a Templater release may rename or reshape any of it without warning. The shapes
+ * below were read from Templater `2.24.3`. Two deliberate consequences follow:
+ *
+ * - {@link resolveTemplaterApi} returns `null` — a Templater too old, too new or too broken to talk to
+ *   reads as "not there" and the integration stays dormant.
+ * - {@link requireTemplaterApi} throws a {@link TemplaterUnavailableError} that NAMES the plugin and the
+ *   reason, rather than letting a `Cannot read properties of undefined` surface from somewhere inside
+ *   Templater.
+ *
+ * The types are DECLARED HERE rather than imported, and narrowed to the members actually called: Templater
+ * ships no npm types package, and depending on it would turn an optional integration into a build-time
+ * dependency.
+ *
+ * The second thing this module supplies is an active-file answer. While a template renders,
+ * `app.workspace.getActiveFile()` still points at whatever the user happens to have open — NOT at the file
+ * the template is being rendered for — so a plugin's own helper called from inside a template resolves
+ * links against the wrong note. {@link TemplaterActiveFileProvider} answers with the render target for the
+ * duration of a {@link parseTemplate} call and falls back to the workspace otherwise. Note this is about
+ * the CONSUMER's helpers: Templater's own `tp.file.*` already resolves through the running config's
+ * `target_file` and needs no help.
+ */
+import type { App, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PathOrFile } from './file-system.cjs';
+import { AppActiveFileProvider } from './active-file-provider.cjs';
+/**
+ * Parameters for {@link getTemplaterFunctions}.
+ */
+export interface GetTemplaterFunctionsParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Whether to return Templater's `current_functions_object` when it already has one, instead of
+     * generating a fresh object. Reuse is cheaper and gives the object of the render currently in flight;
+     * pass `false` to force a new one built for `targetPathOrFile`.
+     *
+     * @default `true`
+     */
+    readonly shouldReuseCurrent?: boolean;
+    /**
+     * The file the generated functions should resolve against — what `tp.file.*` reports.
+     */
+    readonly targetPathOrFile: PathOrFile;
+}
+/**
+ * Parameters for {@link parseTemplate}.
+ */
+export interface ParseTemplateParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The file the template is rendered FOR. It is what `tp.file.*` resolves to inside the template, and
+     * what {@link TemplaterActiveFileProvider} reports for the duration of the call.
+     */
+    readonly targetPathOrFile: PathOrFile;
+    /**
+     * The template file to render.
+     */
+    readonly templatePathOrFile: PathOrFile;
+}
+/**
+ * Templater's internal API object, narrowed to the members this library calls.
+ *
+ * Its members are `snake_case` because Templater's are; they are transcribed rather than renamed so the
+ * shape can be checked against Templater's source at a glance.
+ */
+export interface TemplaterApi {
+    /**
+     * Builds the {@link TemplaterRunningConfig} that describes one render.
+     *
+     * @param templateFile - The template being rendered, or `undefined` when there is none (as when only
+     * the functions object is wanted).
+     * @param targetFile - The file the render is for.
+     * @param runMode - Which {@link TemplaterRunMode} the render is.
+     * @returns The running config.
+     */
+    create_running_config: (templateFile: TFile | undefined, targetFile: TFile, runMode: TemplaterRunMode) => TemplaterRunningConfig;
+    /**
+     * The functions object (`tp`) of the render currently in flight, when there is one.
+     */
+    current_functions_object?: object | undefined;
+    /**
+     * Builds the functions object (`tp`) a template is evaluated against.
+     */
+    functions_generator: TemplaterFunctionsGenerator;
+    /**
+     * Reads the config's `template_file` and renders it, returning the resulting text.
+     *
+     * @param config - The {@link TemplaterRunningConfig} describing the render. Templater throws when its
+     * `template_file` is not a `TFile`.
+     * @returns A {@link Promise} resolving to the rendered text.
+     */
+    read_and_parse_template: (config: TemplaterRunningConfig) => Promise<string>;
+}
+/**
+ * The `functions_generator` half of {@link TemplaterApi}.
+ */
+export interface TemplaterFunctionsGenerator {
+    /**
+     * Builds the functions object (`tp`) for a running config.
+     *
+     * @param config - The {@link TemplaterRunningConfig} to build for.
+     * @returns A {@link Promise} resolving to the functions object.
+     */
+    generate_object: (config: TemplaterRunningConfig) => Promise<object>;
+}
+/**
+ * One Templater render, as Templater's `create_running_config` describes it.
+ *
+ * Its members are `snake_case` because Templater's are.
+ */
+export interface TemplaterRunningConfig {
+    /**
+     * The file Templater considers active. Templater fills this in itself from
+     * `workspace.activeEditor?.file ?? workspace.getActiveFile()`; it is optional here because a
+     * hand-built config may omit it.
+     */
+    active_file?: null | TFile | undefined;
+    /**
+     * Which {@link TemplaterRunMode} the render is.
+     */
+    run_mode: TemplaterRunMode;
+    /**
+     * The file the render is for — what `tp.file.*` resolves to.
+     */
+    target_file: TFile;
+    /**
+     * The template being rendered, when there is one.
+     */
+    template_file?: TFile | undefined;
+}
+/**
+ * Templater's plugin id, as its manifest declares it.
+ */
+export declare const TEMPLATER_PLUGIN_ID = "templater-obsidian";
+/**
+ * Templater's `RunMode` enum, which says what kind of render a {@link TemplaterRunningConfig} describes.
+ *
+ * The numeric values ARE Templater's, and the members are listed in its declaration order so the two can
+ * be compared line for line. They are written out explicitly all the same, because they cross into
+ * Templater as integers — never renumber them.
+ */
+export declare enum TemplaterRunMode {
+    /**
+     * Render the template into a newly created file.
+     */
+    CreateNewFromTemplate = 0,
+    /**
+     * Render the template and append the result to the active file.
+     */
+    AppendActiveFile = 1,
+    /**
+     * Render the template and overwrite a given file with the result.
+     */
+    OverwriteFile = 2,
+    /**
+     * Render the template and overwrite the active file with the result.
+     */
+    OverwriteActiveFile = 3,
+    /**
+     * Render the template on demand, for a caller that wants the resulting text rather than a file
+     * written. This is what {@link parseTemplate} uses.
+     */
+    DynamicProcessor = 4,
+    /**
+     * Render the template as a startup template. {@link getTemplaterFunctions} uses it for the throwaway
+     * config it builds, because that config renders nothing.
+     */
+    StartupTemplate = 5
+}
+/**
+ * Why Templater's internal API could not be handed over.
+ */
+export declare enum TemplaterUnavailabilityReason {
+    /**
+     * Templater is not installed, or is installed but disabled. Obsidian's `getPlugin` cannot tell the two
+     * apart — it returns nothing either way.
+     */
+    NotLoaded = "notLoaded",
+    /**
+     * Templater is loaded, but does not expose the internals this library calls — it is too old, too new,
+     * or has been reshaped.
+     */
+    ShapeChanged = "shapeChanged"
+}
+/**
+ * Active-file provider that answers with the file a {@link parseTemplate} render is currently for,
+ * falling back to the workspace's active file when no render is in flight.
+ *
+ * This is the piece that makes a consumer's own template helpers resolve against the right note: during a
+ * render the workspace still has whatever the user was looking at open, which is rarely the target.
+ */
+export declare 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(): null | TFile;
+}
+/**
+ * Thrown when Templater's internal API cannot be handed over, carrying the
+ * {@link TemplaterUnavailabilityReason} that says why.
+ */
+export declare class TemplaterUnavailableError extends Error {
+    /**
+     * Which of the two failures occurred.
+     */
+    readonly reason: TemplaterUnavailabilityReason;
+    /**
+     * Creates a {@link TemplaterUnavailableError}.
+     *
+     * @param reason - Why the API is unavailable.
+     */
+    constructor(reason: TemplaterUnavailabilityReason);
+}
+/**
+ * Gets Templater's functions object — the `tp` a template is evaluated against — so a caller can invoke
+ * `tp.date.now()`, `tp.file.title` and the rest outside a template.
+ *
+ * @param params - The {@link GetTemplaterFunctionsParams}.
+ * @returns A {@link Promise} resolving to the functions object.
+ * @throws A {@link TemplaterUnavailableError} when Templater is not loaded or its shape has changed.
+ */
+export declare function getTemplaterFunctions(params: GetTemplaterFunctionsParams): Promise<object>;
+/**
+ * Gets the file the innermost in-flight {@link parseTemplate} render is for.
+ *
+ * Renders nest — a template may render another — so the calls form a stack and this reports the top of
+ * it. Outside any render it is `null`.
+ *
+ * @returns The render target, or `null` when no render is in flight.
+ */
+export declare function getTemplaterRenderTargetFile(): null | TFile;
+/**
+ * Renders a Templater template against a target file and returns the resulting text, without writing
+ * anything.
+ *
+ * For the duration of the call {@link getTemplaterRenderTargetFile} and
+ * {@link TemplaterActiveFileProvider} report `targetPathOrFile`, so a consumer's own helpers invoked from
+ * inside the template resolve against it rather than against whatever the user has open.
+ *
+ * @param params - The {@link ParseTemplateParams}.
+ * @returns A {@link Promise} resolving to the rendered text.
+ * @throws A {@link TemplaterUnavailableError} when Templater is not loaded or its shape has changed.
+ */
+export declare function parseTemplate(params: ParseTemplateParams): Promise<string>;
+/**
+ * Gets Templater's internal API, throwing when it cannot be had.
+ *
+ * Use this where the caller cannot carry on without Templater — the error names the plugin and says which
+ * of the two failures occurred. Use {@link resolveTemplaterApi} instead where the integration is optional.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns Templater's internal API.
+ * @throws A {@link TemplaterUnavailableError} when Templater is not loaded or its shape has changed.
+ */
+export declare function requireTemplaterApi(app: App): TemplaterApi;
+/**
+ * Gets Templater's internal API, when Templater is installed, enabled and still the shape this library
+ * expects.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns The internal API, or `null` when Templater is not there to talk to.
+ */
+export declare function resolveTemplaterApi(app: App): null | TemplaterApi;