@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/demo-vault.d.mts

@@ -0,0 +1,33 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * Archives a plugin's demo vault as a release artifact.
+ *
+ * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. At release time this
+ * module installs the freshly built plugin into that vault's `.obsidian/plugins/<id>/` folder and
+ * zips the whole vault into `dist/build/<plugin-id>-demo-vault.zip`, so the existing GitHub-release
+ * step (which uploads every file in `dist/build/`) attaches it automatically.
+ *
+ * The version is deliberately absent from that name and lives INSIDE the archive instead — see
+ * `obsidian/demo-vault-naming.ts` for why — in the two places a person actually meets it: the vault
+ * sits under a single `<plugin-id>-demo-vault-<version>/` folder, so unzipping several releases by hand
+ * into one folder neither collides nor produces anonymous directories, and the vault's `README.md`
+ * heading gains the version it demonstrates.
+ *
+ * The archived copy also carries the `.obsidian/app.json` settings this package owns (see
+ * `demo-vault-app-json.ts`). Those settings and the README heading are written into the ZIP ENTRY and
+ * never into the repo folder: both files are tracked, and `updateVersion` archives after it has already
+ * pushed, so an in-place write would leave an uncommitted change behind a published release.
+ */
+/**
+ * Archives the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact.
+ *
+ * Installs the freshly built plugin from `dist/build/` into the vault's
+ * `.obsidian/plugins/<id>/` folder, then zips the whole vault to
+ * `dist/build/<plugin-id>-demo-vault.zip`, under a single `<plugin-id>-demo-vault-<version>/` folder.
+ *
+ * @returns A {@link Promise} that resolves to the absolute path of the created zip archive, or
+ * `null` if the repo has no `demo-vault/` folder.
+ */
+export declare function archivePluginDemoVault(): Promise<null | string>;

package/dist/lib/esm/demo-vault.mjs

@@ -0,0 +1,205 @@
+/*
+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 {
+  getDemoVaultArchiveFileName,
+  getDemoVaultFolderName
+} from "@mnaoumov/obsidian-lib/demo-vault-naming";
+import { readdirPosix } from "@mnaoumov/typescript-dev-toolkit/fs";
+import {
+  getRootFolder,
+  resolvePathFromRootSafe
+} from "@mnaoumov/typescript-dev-toolkit/root";
+import {
+  getFolderName,
+  join,
+  relative
+} from "@mnaoumov/typescript-lib/path";
+import { zipSync } from "fflate";
+import { existsSync } from "node:fs";
+import {
+  cp,
+  mkdir,
+  readFile,
+  writeFile
+} from "node:fs/promises";
+import {
+  buildArchivedDemoVaultAppJsonContent,
+  findOwnedDemoVaultAppJsonSettings,
+  parseDemoVaultAppJson
+} from "./demo-vault-app-json.mjs";
+import { ObsidianPluginRepoPaths } from "./obsidian-plugin-repo-paths.mjs";
+const DEMO_VAULT_HELPER_PLUGIN_ID = "demo-vault-helper";
+const DATA_JSON_FILE_NAME = "data.json";
+const DATA_JSON_INDENT = 2;
+const README_FILE_NAME = "README.md";
+const OPENING_HEADING_REG_EXP = /^# .*/;
+async function archivePluginDemoVault() {
+  const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });
+  if (!existsSync(demoVaultPath)) {
+    return null;
+  }
+  const manifestPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestJson });
+  const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+  const pluginFolder = resolvePathFromRootSafe({
+    path: join(
+      ObsidianPluginRepoPaths.DemoVault,
+      ObsidianPluginRepoPaths.DotObsidian,
+      ObsidianPluginRepoPaths.Plugins,
+      manifest.id
+    )
+  });
+  await mkdir(pluginFolder, { recursive: true });
+  const distBuildPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DistBuild });
+  await cp(distBuildPath, pluginFolder, { recursive: true });
+  await injectDemoVaultHelper(manifest.id);
+  const zipPath = resolvePathFromRootSafe({
+    path: join(ObsidianPluginRepoPaths.DistBuild, getDemoVaultArchiveFileName(manifest.id))
+  });
+  const rootFolderName = getDemoVaultFolderName({
+    pluginId: manifest.id,
+    version: manifest.version
+  });
+  const entries = await readDemoVaultEntries({
+    demoVaultPath,
+    rootFolderName
+  });
+  injectAppJson({
+    appJson: await readCommittedAppJson(),
+    entries,
+    rootFolderName
+  });
+  injectReadmeVersion({
+    entries,
+    rootFolderName,
+    version: manifest.version
+  });
+  await writeFile(zipPath, zipSync(Object.fromEntries(entries)));
+  return zipPath;
+}
+function injectAppJson(params) {
+  const {
+    appJson,
+    entries,
+    rootFolderName
+  } = params;
+  const entryName = join(rootFolderName, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson);
+  entries.set(entryName, Buffer.from(buildArchivedDemoVaultAppJsonContent({ appJson }), "utf-8"));
+}
+async function injectDemoVaultHelper(demoedPluginId) {
+  const packageFolder = getRootFolder(getFolderName(import.meta.url));
+  if (!packageFolder) {
+    throw new Error("Could not resolve the obsidian-dev-utils package folder to inject the demo-vault-helper plugin.");
+  }
+  const helperSourcePath = join(packageFolder, ObsidianPluginRepoPaths.DistDemoVaultHelper);
+  const helperFolder = resolvePathFromRootSafe({
+    path: join(
+      ObsidianPluginRepoPaths.DemoVault,
+      ObsidianPluginRepoPaths.DotObsidian,
+      ObsidianPluginRepoPaths.Plugins,
+      DEMO_VAULT_HELPER_PLUGIN_ID
+    )
+  });
+  await mkdir(helperFolder, { recursive: true });
+  await cp(helperSourcePath, helperFolder, { recursive: true });
+  const settings = { demoedPluginId };
+  await writeFile(join(helperFolder, DATA_JSON_FILE_NAME), `${JSON.stringify(settings, null, DATA_JSON_INDENT)}
+`, "utf-8");
+}
+function injectReadmeVersion(params) {
+  const {
+    entries,
+    rootFolderName,
+    version
+  } = params;
+  const entryName = join(rootFolderName, README_FILE_NAME);
+  const entry = entries.get(entryName);
+  if (!entry) {
+    return;
+  }
+  const content = entry.toString("utf-8");
+  const versionedContent = content.replace(OPENING_HEADING_REG_EXP, (heading) => `${heading} v${version}`);
+  if (versionedContent === content) {
+    return;
+  }
+  entries.set(entryName, Buffer.from(versionedContent, "utf-8"));
+}
+async function readCommittedAppJson() {
+  const appJsonPath = resolvePathFromRootSafe({
+    path: join(ObsidianPluginRepoPaths.DemoVault, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson)
+  });
+  const content = existsSync(appJsonPath) ? await readFile(appJsonPath, "utf-8") : null;
+  const appJson = parseDemoVaultAppJson({ content, path: appJsonPath });
+  const ownedSettings = findOwnedDemoVaultAppJsonSettings({ appJson });
+  if (ownedSettings.length > 0) {
+    throw new Error(
+      `${appJsonPath} sets ${ownedSettings.join(", ")}, which obsidian-dev-utils owns and writes into the archived demo vault. Settings it owns must not be committed.`
+    );
+  }
+  return appJson;
+}
+async function readDemoVaultEntries(params) {
+  const {
+    demoVaultPath,
+    rootFolderName
+  } = params;
+  const entries = /* @__PURE__ */ new Map();
+  for (const dirent of await readdirPosix(demoVaultPath, { recursive: true, withFileTypes: true })) {
+    if (!dirent.isFile()) {
+      continue;
+    }
+    const path = join(dirent.parentPath, dirent.name);
+    entries.set(join(rootFolderName, relative(demoVaultPath, path)), await readFile(path));
+  }
+  return entries;
+}
+export {
+  archivePluginDemoVault
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/demo-vault.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Archives a plugin's demo vault as a release artifact.\n *\n * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. At release time this\n * module installs the freshly built plugin into that vault's `.obsidian/plugins/<id>/` folder and\n * zips the whole vault into `dist/build/<plugin-id>-demo-vault.zip`, so the existing GitHub-release\n * step (which uploads every file in `dist/build/`) attaches it automatically.\n *\n * The version is deliberately absent from that name and lives INSIDE the archive instead \u2014 see\n * `obsidian/demo-vault-naming.ts` for why \u2014 in the two places a person actually meets it: the vault\n * sits under a single `<plugin-id>-demo-vault-<version>/` folder, so unzipping several releases by hand\n * into one folder neither collides nor produces anonymous directories, and the vault's `README.md`\n * heading gains the version it demonstrates.\n *\n * The archived copy also carries the `.obsidian/app.json` settings this package owns (see\n * `demo-vault-app-json.ts`). Those settings and the README heading are written into the ZIP ENTRY and\n * never into the repo folder: both files are tracked, and `updateVersion` archives after it has already\n * pushed, so an in-place write would leave an uncommitted change behind a published release.\n */\n\nimport type { DemoVaultHelperSettings } from '@mnaoumov/obsidian-lib/demo-vault-helper-settings';\n\nimport {\n  getDemoVaultArchiveFileName,\n  getDemoVaultFolderName\n} from '@mnaoumov/obsidian-lib/demo-vault-naming';\nimport { readdirPosix } from '@mnaoumov/typescript-dev-toolkit/fs';\nimport {\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '@mnaoumov/typescript-dev-toolkit/root';\nimport {\n  getFolderName,\n  join,\n  relative\n} from '@mnaoumov/typescript-lib/path';\nimport { zipSync } from 'fflate';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\n\nimport type { DemoVaultAppJson } from './demo-vault-app-json.ts';\n\nimport {\n  buildArchivedDemoVaultAppJsonContent,\n  findOwnedDemoVaultAppJsonSettings,\n  parseDemoVaultAppJson\n} from './demo-vault-app-json.ts';\nimport { ObsidianPluginRepoPaths } from './obsidian-plugin-repo-paths.ts';\n\nconst DEMO_VAULT_HELPER_PLUGIN_ID = 'demo-vault-helper';\nconst DATA_JSON_FILE_NAME = 'data.json';\nconst DATA_JSON_INDENT = 2;\nconst README_FILE_NAME = 'README.md';\n\n// The README's opening `# H1`, and only that one: without the `m` flag the match is anchored to the start\n// of the file, and `.` stops at the newline that ends the line.\nconst OPENING_HEADING_REG_EXP = /^# .*/;\n\n/**\n * The archive's entries, keyed by the name each one takes inside the ZIP.\n *\n * The whole archive is assembled as this map and serialized once, so injecting an entry is an ordinary\n * `set` rather than a mutation of a half-built archive object.\n */\ntype DemoVaultZipEntries = Map<string, Buffer>;\n\n/**\n * Parameters for {@link injectAppJson}.\n */\ninterface InjectAppJsonParams {\n  /**\n   * The committed settings the owned ones are merged over.\n   */\n  readonly appJson: DemoVaultAppJson;\n\n  /**\n   * The archive's entries, edited in place.\n   */\n  readonly entries: DemoVaultZipEntries;\n\n  /**\n   * The archive's single top-level folder, which every entry name is relative to.\n   */\n  readonly rootFolderName: string;\n}\n\n/**\n * Parameters for {@link injectReadmeVersion}.\n */\ninterface InjectReadmeVersionParams {\n  /**\n   * The archive's entries, edited in place.\n   */\n  readonly entries: DemoVaultZipEntries;\n\n  /**\n   * The archive's single top-level folder, which every entry name is relative to.\n   */\n  readonly rootFolderName: string;\n\n  /**\n   * The plugin version the vault demonstrates.\n   */\n  readonly version: string;\n}\n\n/**\n * The minimal shape of a plugin `manifest.json` read by {@link archivePluginDemoVault}.\n */\ninterface PluginManifest {\n  /**\n   * The plugin id, used as the folder name under `demo-vault/.obsidian/plugins/`.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin version, embedded in the archive's top-level folder name and its README heading.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link readDemoVaultEntries}.\n */\ninterface ReadDemoVaultEntriesParams {\n  /**\n   * The vault folder to read, as an absolute path.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n   * The archive's single top-level folder, which every entry name is relative to.\n   */\n  readonly rootFolderName: string;\n}\n\n/**\n * Archives the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact.\n *\n * Installs the freshly built plugin from `dist/build/` into the vault's\n * `.obsidian/plugins/<id>/` folder, then zips the whole vault to\n * `dist/build/<plugin-id>-demo-vault.zip`, under a single `<plugin-id>-demo-vault-<version>/` folder.\n *\n * @returns A {@link Promise} that resolves to the absolute path of the created zip archive, or\n * `null` if the repo has no `demo-vault/` folder.\n */\nexport async function archivePluginDemoVault(): Promise<null | string> {\n  const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });\n  if (!existsSync(demoVaultPath)) {\n    return null;\n  }\n\n  const manifestPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestJson });\n  const manifest = JSON.parse(await readFile(manifestPath, 'utf-8')) as PluginManifest;\n\n  const pluginFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      manifest.id\n    )\n  });\n  await mkdir(pluginFolder, { recursive: true });\n\n  const distBuildPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DistBuild });\n  await cp(distBuildPath, pluginFolder, { recursive: true });\n\n  await injectDemoVaultHelper(manifest.id);\n\n  const zipPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DistBuild, getDemoVaultArchiveFileName(manifest.id))\n  });\n  const rootFolderName = getDemoVaultFolderName({\n    pluginId: manifest.id,\n    version: manifest.version\n  });\n  const entries = await readDemoVaultEntries({\n    demoVaultPath,\n    rootFolderName\n  });\n  injectAppJson({\n    appJson: await readCommittedAppJson(),\n    entries,\n    rootFolderName\n  });\n  injectReadmeVersion({\n    entries,\n    rootFolderName,\n    version: manifest.version\n  });\n  // Every entry is stamped with the moment the archive is built rather than the file's own mtime, which is\n  // what the previous archiver wrote. A demo vault's committed timestamps are checkout artifacts of whoever\n  // ran the release, so they carry nothing a reader could use; the build time at least describes the\n  // archive.\n  await writeFile(zipPath, zipSync(Object.fromEntries(entries)));\n  return zipPath;\n}\n\n// Stores the archived vault's `.obsidian/app.json` \u2014 the committed settings with the owned ones merged\n// over them. The ENTRY is written rather than the file, so the repo folder is left exactly as it was, and\n// A vault with nothing else to configure \u2014 which commits no `app.json` at all \u2014 gets one here regardless.\nfunction injectAppJson(params: InjectAppJsonParams): void {\n  const {\n    appJson,\n    entries,\n    rootFolderName\n  } = params;\n\n  const entryName = join(rootFolderName, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson);\n  entries.set(entryName, Buffer.from(buildArchivedDemoVaultAppJsonContent({ appJson }), 'utf-8'));\n}\n\n// Injects the built, `obsidian-dev-utils`-owned `demo-vault-helper` bootstrap plugin (shipped in this package) into the demo vault, so no per-vault copy is committed and an `obsidian-dev-utils` bump propagates fixes.\n//\n// Alongside the binaries it writes the helper's own `data.json` naming the demonstrated plugin. That is\n// the one moment the id is known for certain \u2014 it comes from the plugin's own manifest \u2014 whereas the\n// opened vault only offers plugin folders to count, which the bootstrap itself adds to (see\n// `DemoVaultHelperSettings`).\nasync function injectDemoVaultHelper(demoedPluginId: string): Promise<void> {\n  const packageFolder = getRootFolder(getFolderName(import.meta.url));\n  if (!packageFolder) {\n    throw new Error('Could not resolve the obsidian-dev-utils package folder to inject the demo-vault-helper plugin.');\n  }\n\n  const helperSourcePath = join(packageFolder, ObsidianPluginRepoPaths.DistDemoVaultHelper);\n  const helperFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      DEMO_VAULT_HELPER_PLUGIN_ID\n    )\n  });\n  await mkdir(helperFolder, { recursive: true });\n  await cp(helperSourcePath, helperFolder, { recursive: true });\n\n  const settings: DemoVaultHelperSettings = { demoedPluginId };\n  await writeFile(join(helperFolder, DATA_JSON_FILE_NAME), `${JSON.stringify(settings, null, DATA_JSON_INDENT)}\\n`, 'utf-8');\n}\n\n// Names the version on the archived `README.md`'s heading, so the vault says which release it demonstrates\n// however far it travels from the release page it was downloaded from.\n//\n// Entry-only, for the same reason `injectAppJson` is: the committed README is a tracked, hand-authored\n// file and `updateVersion` archives after it has already pushed.\n//\n// A vault that ships no README, or one opening on something other than an `# H1`, is left alone rather\n// than corrected. The demo-vault coverage suite exempts `README.md` from its H1 check, so neither shape\n// is a defect \u2014 and a release is the wrong moment to start failing on one.\nfunction injectReadmeVersion(params: InjectReadmeVersionParams): void {\n  const {\n    entries,\n    rootFolderName,\n    version\n  } = params;\n\n  const entryName = join(rootFolderName, README_FILE_NAME);\n  const entry = entries.get(entryName);\n  if (!entry) {\n    return;\n  }\n\n  const content = entry.toString('utf-8');\n  const versionedContent = content.replace(OPENING_HEADING_REG_EXP, (heading) => `${heading} v${version}`);\n  if (versionedContent === content) {\n    return;\n  }\n\n  entries.set(entryName, Buffer.from(versionedContent, 'utf-8'));\n}\n\n// Reads the demo vault's committed `.obsidian/app.json`, refusing the settings this package owns.\n//\n// Those settings are injected into the archive, so a committed one is a second source of truth that\n// nothing keeps in step. The demo-vault coverage suite already fails on it, which means reaching here\n// means that gate was skipped \u2014 so this refuses rather than overwriting a value somebody chose on purpose.\nasync function readCommittedAppJson(): Promise<DemoVaultAppJson> {\n  const appJsonPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DemoVault, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson)\n  });\n  const content = existsSync(appJsonPath) ? await readFile(appJsonPath, 'utf-8') : null;\n  const appJson = parseDemoVaultAppJson({ content, path: appJsonPath });\n\n  const ownedSettings = findOwnedDemoVaultAppJsonSettings({ appJson });\n  if (ownedSettings.length > 0) {\n    throw new Error(\n      `${appJsonPath} sets ${ownedSettings.join(', ')}, which obsidian-dev-utils owns and writes into the archived demo vault. Settings it owns must not be committed.`\n    );\n  }\n\n  return appJson;\n}\n\n// Reads every file in the demo vault as an archive entry, under the single top-level folder the archive\n// sits in.\n//\n// Only FILES become entries. Git cannot track an empty folder, so a committed demo vault has none \u2014 and\n// `extractZipArchive` creates an entry's parent folders whether or not the archive declared them, so a\n// folder entry would earn nothing even if one could exist.\nasync function readDemoVaultEntries(params: ReadDemoVaultEntriesParams): Promise<DemoVaultZipEntries> {\n  const {\n    demoVaultPath,\n    rootFolderName\n  } = params;\n\n  const entries: DemoVaultZipEntries = new Map<string, Buffer>();\n  for (const dirent of await readdirPosix(demoVaultPath, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = join(dirent.parentPath, dirent.name);\n    entries.set(join(rootFolderName, relative(demoVaultPath, path)), await readFile(path));\n  }\n\n  return entries;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/formatters/dprint.d.mts

@@ -0,0 +1,15 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Formats an Obsidian plugin with dprint: the generic runner from `@mnaoumov/typescript-dev-toolkit`, falling
+ * back to this package's `dprint.json` template when the project has none.
+ */
+import type { FormatOptions } from '@mnaoumov/typescript-dev-toolkit/formatters/dprint';
+/**
+ * Formats the source code.
+ *
+ * @param options - The {@link FormatOptions}.
+ */
+export declare function format(options?: FormatOptions): Promise<void>;
+export { type FormatOptions } from '@mnaoumov/typescript-dev-toolkit/formatters/dprint';

package/dist/lib/esm/formatters/dprint.mjs

@@ -0,0 +1,60 @@
+/*
+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 { format as formatGeneric } from "@mnaoumov/typescript-dev-toolkit/formatters/dprint";
+import { RepoPaths } from "@mnaoumov/typescript-dev-toolkit/repo-paths";
+import { getTemplateFilePath } from "../templates.mjs";
+import {} from "@mnaoumov/typescript-dev-toolkit/formatters/dprint";
+async function format(options) {
+  await formatGeneric({ defaultConfigFilePath: getTemplateFilePath(RepoPaths.DprintJson), ...options });
+}
+export {
+  format
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2Zvcm1hdHRlcnMvZHByaW50LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogRm9ybWF0cyBhbiBPYnNpZGlhbiBwbHVnaW4gd2l0aCBkcHJpbnQ6IHRoZSBnZW5lcmljIHJ1bm5lciBmcm9tIGBAbW5hb3Vtb3YvdHlwZXNjcmlwdC1kZXYtdG9vbGtpdGAsIGZhbGxpbmdcbiAqIGJhY2sgdG8gdGhpcyBwYWNrYWdlJ3MgYGRwcmludC5qc29uYCB0ZW1wbGF0ZSB3aGVuIHRoZSBwcm9qZWN0IGhhcyBub25lLlxuICovXG5cbmltcG9ydCB0eXBlIHsgRm9ybWF0T3B0aW9ucyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L2Zvcm1hdHRlcnMvZHByaW50JztcblxuaW1wb3J0IHsgZm9ybWF0IGFzIGZvcm1hdEdlbmVyaWMgfSBmcm9tICdAbW5hb3Vtb3YvdHlwZXNjcmlwdC1kZXYtdG9vbGtpdC9mb3JtYXR0ZXJzL2RwcmludCc7XG5pbXBvcnQgeyBSZXBvUGF0aHMgfSBmcm9tICdAbW5hb3Vtb3YvdHlwZXNjcmlwdC1kZXYtdG9vbGtpdC9yZXBvLXBhdGhzJztcblxuaW1wb3J0IHsgZ2V0VGVtcGxhdGVGaWxlUGF0aCB9IGZyb20gJy4uL3RlbXBsYXRlcy50cyc7XG5cbi8qKlxuICogRm9ybWF0cyB0aGUgc291cmNlIGNvZGUuXG4gKlxuICogQHBhcmFtIG9wdGlvbnMgLSBUaGUge0BsaW5rIEZvcm1hdE9wdGlvbnN9LlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZm9ybWF0KG9wdGlvbnM/OiBGb3JtYXRPcHRpb25zKTogUHJvbWlzZTx2b2lkPiB7XG4gIGF3YWl0IGZvcm1hdEdlbmVyaWMoeyBkZWZhdWx0Q29uZmlnRmlsZVBhdGg6IGdldFRlbXBsYXRlRmlsZVBhdGgoUmVwb1BhdGhzLkRwcmludEpzb24pLCAuLi5vcHRpb25zIH0pO1xufVxuZXhwb3J0IHsgdHlwZSBGb3JtYXRPcHRpb25zIH0gZnJvbSAnQG1uYW91bW92L3R5cGVzY3JpcHQtZGV2LXRvb2xraXQvZm9ybWF0dGVycy9kcHJpbnQnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVNBLFNBQVMsVUFBVSxxQkFBcUI7QUFDeEMsU0FBUyxpQkFBaUI7QUFFMUIsU0FBUywyQkFBMkI7QUFVcEMsZUFBbUM7QUFIbkMsZUFBc0IsT0FBTyxTQUF3QztBQUNuRSxRQUFNLGNBQWMsRUFBRSx1QkFBdUIsb0JBQW9CLFVBQVUsVUFBVSxHQUFHLEdBQUcsUUFBUSxDQUFDO0FBQ3RHOyIsCiAgIm5hbWVzIjogW10KfQo=

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

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

package/dist/lib/esm/formatters/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 dprint from "./dprint.mjs";
+export {
+  dprint
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2Zvcm1hdHRlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnZHByaW50JyBmcm9tICcuL2RwcmludC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsWUFBWSxZQUFjOyIsCiAgIm5hbWVzIjogW10KfQo=

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

@@ -0,0 +1,16 @@
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+/// <reference lib="es2022" />
+/// <reference lib="esnext.disposable" />
+/// <reference types="node" />
+export * as 'bundlers' from './bundlers/index.mjs';
+export * as 'demo-vault-app-json' from './demo-vault-app-json.mjs';
+export * as 'demo-vault-buttons' from './demo-vault-buttons.mjs';
+export * as 'demo-vault-coverage' from './demo-vault-coverage.mjs';
+export * as 'demo-vault' from './demo-vault.mjs';
+export * as 'formatters' from './formatters/index.mjs';
+export * as 'linters' from './linters/index.mjs';
+export * as 'obsidian-plugin-repo-paths' from './obsidian-plugin-repo-paths.mjs';
+export * as 'templates' from './templates.mjs';
+export * as 'test-runners' from './test-runners/index.mjs';
+export * as 'version' from './version.mjs';

package/dist/lib/esm/index.mjs

@@ -0,0 +1,74 @@
+/*
+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 bundlers from "./bundlers/index.mjs";
+import * as demo_vault_app_json from "./demo-vault-app-json.mjs";
+import * as demo_vault_buttons from "./demo-vault-buttons.mjs";
+import * as demo_vault_coverage from "./demo-vault-coverage.mjs";
+import * as demo_vault from "./demo-vault.mjs";
+import * as formatters from "./formatters/index.mjs";
+import * as linters from "./linters/index.mjs";
+import * as obsidian_plugin_repo_paths from "./obsidian-plugin-repo-paths.mjs";
+import * as templates from "./templates.mjs";
+import * as test_runners from "./test-runners/index.mjs";
+import * as version from "./version.mjs";
+export {
+  bundlers,
+  demo_vault as "demo-vault",
+  demo_vault_app_json as "demo-vault-app-json",
+  demo_vault_buttons as "demo-vault-buttons",
+  demo_vault_coverage as "demo-vault-coverage",
+  formatters,
+  linters,
+  obsidian_plugin_repo_paths as "obsidian-plugin-repo-paths",
+  templates,
+  test_runners as "test-runners",
+  version
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2J1bmRsZXJzJyBmcm9tICcuL2J1bmRsZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdkZW1vLXZhdWx0LWFwcC1qc29uJyBmcm9tICcuL2RlbW8tdmF1bHQtYXBwLWpzb24udHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQtYnV0dG9ucycgZnJvbSAnLi9kZW1vLXZhdWx0LWJ1dHRvbnMudHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQtY292ZXJhZ2UnIGZyb20gJy4vZGVtby12YXVsdC1jb3ZlcmFnZS50cyc7XG5leHBvcnQgKiBhcyAnZGVtby12YXVsdCcgZnJvbSAnLi9kZW1vLXZhdWx0LnRzJztcbmV4cG9ydCAqIGFzICdmb3JtYXR0ZXJzJyBmcm9tICcuL2Zvcm1hdHRlcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ2xpbnRlcnMnIGZyb20gJy4vbGludGVycy9pbmRleC50cyc7XG5leHBvcnQgKiBhcyAnb2JzaWRpYW4tcGx1Z2luLXJlcG8tcGF0aHMnIGZyb20gJy4vb2JzaWRpYW4tcGx1Z2luLXJlcG8tcGF0aHMudHMnO1xuZXhwb3J0ICogYXMgJ3RlbXBsYXRlcycgZnJvbSAnLi90ZW1wbGF0ZXMudHMnO1xuZXhwb3J0ICogYXMgJ3Rlc3QtcnVubmVycycgZnJvbSAnLi90ZXN0LXJ1bm5lcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ3ZlcnNpb24nIGZyb20gJy4vdmVyc2lvbi50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsWUFBWSxjQUFnQjtBQUM1QixZQUFZQSx5QkFBMkI7QUFDdkMsWUFBWUMsd0JBQTBCO0FBQ3RDLFlBQVlDLHlCQUEyQjtBQUN2QyxZQUFZQyxnQkFBa0I7QUFDOUIsWUFBWSxnQkFBa0I7QUFDOUIsWUFBWSxhQUFlO0FBQzNCLFlBQVlDLGdDQUFrQztBQUM5QyxZQUFZLGVBQWlCO0FBQzdCLFlBQVlDLGtCQUFvQjtBQUNoQyxZQUFZLGFBQWU7IiwKICAibmFtZXMiOiBbImRlbW8tdmF1bHQtYXBwLWpzb24iLCAiZGVtby12YXVsdC1idXR0b25zIiwgImRlbW8tdmF1bHQtY292ZXJhZ2UiLCAiZGVtby12YXVsdCIsICJvYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocyIsICJ0ZXN0LXJ1bm5lcnMiXQp9Cg==

package/dist/lib/esm/integration-test-setup.d.mts

@@ -0,0 +1,33 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * Per-worker integration-test setup endpoint: makes every library helper reachable as `lib.<helper>` inside
+ * an `evalInObsidian` closure.
+ *
+ * Add it to the `setupFiles` of each integration-test project, after `obsidian-integration-testing`'s own
+ * setup:
+ *
+ * ```ts
+ * setupFiles: [
+ *   'obsidian-integration-testing/vitest-setup',
+ *   'obsidian-dev-utils/integration-test-setup'
+ * ]
+ * ```
+ *
+ * Importing this module registers a renderer-side resolver whose result the harness merges into the `lib`
+ * argument of every `evalInObsidian` callback. Two more pieces are needed for `lib.<helper>` to work:
+ *
+ * - The **harness plugin** must be loaded in the test vault, because it is what publishes the library on
+ *   `window.__obsidianDevUtilsModule`. Seed and enable it via
+ *   `obsidian-dev-utils/integration-test-vitest-global-setup` (or, when composing with your own vault
+ *   fixtures, {@link getIntegrationTestPluginPopulate} +
+ *   `createSetup({ enableCommunityPlugins: [OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID] })`).
+ * - The **types** must be activated, or `lib.<helper>` will not compile. Put
+ *   `/// <reference types="obsidian-dev-utils/@types/obsidian-integration-testing" />` in a `.d.ts` your
+ *   `tsconfig.json` already includes. A `compilerOptions.types` entry does NOT work for this.
+ *
+ * Registration is idempotent (the harness dedupes resolvers by source text), so importing this module from
+ * more than one setup file is safe.
+ */
+export {};

package/dist/lib/esm/integration-test-setup.mjs

@@ -0,0 +1,52 @@
+/*
+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 { registerIntegrationTestLibResolver } from "./test-runners/integration-test-plugin.mjs";
+registerIntegrationTestLibResolver();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/integration-test-vitest-global-setup.d.mts

@@ -0,0 +1,39 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * Turnkey Vitest `globalSetup` for a plugin's integration tests: does everything
+ * `obsidian-integration-testing`'s own global setup does (temp vault, install and enable the
+ * plugin-under-test), and additionally seeds and enables the `obsidian-dev-utils` integration-test harness
+ * plugin, so `lib.<helper>` works inside `evalInObsidian` closures.
+ *
+ * ```ts
+ * globalSetup: ['obsidian-dev-utils/integration-test-vitest-global-setup'],
+ * setupFiles: [
+ *   'obsidian-integration-testing/vitest-setup',
+ *   'obsidian-dev-utils/integration-test-setup'
+ * ]
+ * ```
+ *
+ * Replaces `obsidian-integration-testing/vitest-global-setup-plugin`; do not list both.
+ *
+ * If the project already needs its own `populate` (demo-vault fixtures, a large performance vault), skip
+ * this module and compose instead — merge {@link getIntegrationTestPluginPopulate} into that map and pass
+ * {@link OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID} to `enableCommunityPlugins`:
+ *
+ * ```ts
+ * export const { setup, teardown } = createSetup({
+ *   enableCommunityPlugins: [OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID],
+ *   populate: () => ({ ...myFixtures(), ...getIntegrationTestPluginPopulate() })
+ * });
+ * ```
+ */
+/**
+ * Vitest global setup: creates the temp vault, installs and enables the plugin-under-test, then seeds and
+ * enables the `obsidian-dev-utils` integration-test harness plugin alongside it.
+ */
+export declare const setup: (this: void, project: import("vitest/node").TestProject) => Promise<void>;
+/**
+ * Vitest global teardown: removes the temp vault and disposes the transport.
+ */
+export declare const teardown: (this: void) => Promise<void>;