@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/cjs/test-runners/vitest-config.d.cts

@@ -0,0 +1,200 @@
+/// <reference path="../index.d.cts" />
+/**
+ * @file
+ *
+ * Shared vitest configuration for Obsidian plugins.
+ *
+ * Every plugin in the workspace declares the same five vitest projects — `unit-tests` plus the
+ * `integration-tests:{no-app,desktop,desktop-performance,android}` family — with the same timeouts,
+ * `setupFiles`, and `globalSetup` wiring. Maintaining that per repo means a convention change costs one
+ * near-identical edit per plugin, and any repo that is missed drifts silently. This module owns that
+ * configuration once, so a plugin's `scripts/vitest-config.ts` collapses to a single call.
+ *
+ * The seam mirrors {@link https://www.npmjs.com/package/obsidian-dev-utils | the ESLint one}
+ * (`defineEslintConfigs`): the factory builds a context holding the standard projects, the caller edits
+ * it in place through {@link DefineObsidianPluginVitestConfigOptions.editContext}, and appends any
+ * project the base does not know about through
+ * {@link DefineObsidianPluginVitestConfigOptions.customProjects}.
+ */
+import type { VitestReporter } from '@mnaoumov/typescript-dev-toolkit/test-runners/vitest-config' with { 'resolution-mode': 'import' };
+import type { TestProjectConfiguration, TestProjectInlineConfiguration, ViteUserConfig } from 'vitest/config' with { 'resolution-mode': 'import' };
+import { DEFAULT_VITEST_REPORTERS } from '@mnaoumov/typescript-dev-toolkit/test-runners/vitest-config';
+/**
+ * The `test` section of a single vitest project entry.
+ */
+export type ObsidianPluginVitestProjectConfig = NonNullable<TestProjectInlineConfiguration['test']>;
+/**
+ * One entry of a vitest `reporters` list: the name of a built-in reporter or a reporter instance. The same shape as
+ * the library configuration's {@link VitestReporter}.
+ */
+export type ObsidianPluginVitestReporter = VitestReporter;
+export { DEFAULT_VITEST_REPORTERS };
+/**
+ * The per-test budget of the regular integration projects, in milliseconds.
+ *
+ * Exported because a repo that assembles its vitest projects by hand instead of through
+ * {@link defineObsidianPluginVitestConfig} still needs the same relationship to the per-eval cap, and
+ * restating the number there is how the two drift apart.
+ */
+export declare const INTEGRATION_TEST_TIMEOUT_IN_MILLISECONDS: number;
+/**
+ * The options for defining a plugin's vitest configuration.
+ */
+export interface DefineObsidianPluginVitestConfigOptions {
+    /**
+     * A function that builds projects the base configuration does not know about, such as a plugin's own
+     * `integration-tests:demo-vault` project. The returned projects are appended after the standard five.
+     *
+     * @param context - The vitest configuration context.
+     * @returns The extra projects.
+     */
+    readonly customProjects?: (context: ObsidianPluginVitestConfigContext) => TestProjectConfiguration[];
+    /**
+     * A function that edits the vitest configuration context before it is assembled into a configuration.
+     *
+     * @param context - The vitest configuration context.
+     */
+    readonly editContext?: (context: ObsidianPluginVitestConfigContext) => void;
+}
+/**
+ * The context for defining a plugin's vitest configuration.
+ *
+ * Every member is live: the arrays and objects it exposes are the very ones the assembled configuration
+ * is built from, so editing them in place through
+ * {@link DefineObsidianPluginVitestConfigOptions.editContext} is what customizes the result.
+ */
+export declare class ObsidianPluginVitestConfigContext {
+    /**
+     * The `integration-tests:android` project, running the mobile-only and cross-platform suites against an
+     * Android emulator through Appium.
+     */
+    readonly android: ObsidianPluginVitestProjectConfig;
+    /**
+     * The per-test budget of the Android integration project, in milliseconds. Booting an emulator and
+     * driving it over Appium is slower than the desktop path, hence its own constant.
+     *
+     * @default `60000`
+     */
+    readonly androidTimeoutInMilliseconds = 60000;
+    /**
+     * The per-test budget of the regular integration projects, in milliseconds.
+     *
+     * It deliberately CLEARS the transports' per-eval cap rather than matching it, so that a closure which
+     * outruns the cap fails with the harness's `EvalCapExceededError` — naming the cap and the remedy —
+     * instead of with vitest's anonymous timeout. Lowering it to the cap restores that blind spot.
+     *
+     * @default `45000`
+     */
+    readonly bigTimeoutInMilliseconds: number;
+    /**
+     * The coverage `exclude` globs. Push onto it to drop more files from the coverage report.
+     *
+     * Declaration files are excluded by default because the coverage `include` below is `src/**\/*.ts`,
+     * which a `.d.ts` matches. A declaration file emits no runtime code, so it reports 0% and no test can
+     * ever raise it — a plugin that grows one under `src/` silently loses its 100% gate, and the usual
+     * remedy of an inline `v8 ignore` comment does not apply to a type-only file.
+     */
+    readonly coverageExclude: string[];
+    /**
+     * The `integration-tests:desktop` project, running the desktop-only and cross-platform suites against a
+     * real desktop Obsidian over CDP.
+     */
+    readonly desktop: ObsidianPluginVitestProjectConfig;
+    /**
+     * The `integration-tests:desktop-performance` project, running the at-scale suites. It is declared for
+     * every plugin even when there is no such suite yet — `passWithNoTests` makes an empty project free,
+     * and the matching `test:integration:desktop:performance` script exists in every plugin built on this library.
+     *
+     * A plugin's `test:integration` aggregate leaves this project out on purpose, and it stays out even on a
+     * machine with a desktop Obsidian set up. The reason is the fixture rather than the cost: a perf suite
+     * needs its own generated, populated vault, sized through env vars, and the aggregate's small temporary
+     * vault is the wrong one. The 600 s below is a timeout, not a duration — measured end to end, most perf
+     * suites finish in seconds, and only one that generates tens of thousands of notes takes minutes.
+     *
+     * Its CDP transport's per-eval cap is raised to 600 s as well (the budget clears it by the usual
+     * margin), because a perf suite's whole measurement is typically ONE long in-page evaluation, which the
+     * transport's 30 s default killed as a bare `CDP command timed out … Runtime.evaluate` naming neither the
+     * wait nor the assertion. Three plugins had each hand-written this raise in their own `editContext`
+     * before it moved here. Unlike a raised desktop cap, which is a backstop rather than a budget a closure
+     * may spend, this one IS a budget: `no-over-cap-wait-in-eval-in-obsidian` reads it for these files and
+     * for no other.
+     *
+     * No routine command runs them, but something does: a weekly sweep runs every plugin's
+     * `test:integration:desktop:performance`, which is also how to reach them by hand. Adding them to that
+     * aggregate is drift, not a gap to close.
+     */
+    readonly desktopPerformance: ObsidianPluginVitestProjectConfig;
+    /**
+     * The unit test files that redefine `window`, `document`, `location` or `top`, which the `unit-tests`
+     * project's VM pool cannot run.
+     *
+     * Under `pool: 'vmThreads'` those four are non-configurable properties of the VM global, so
+     * `vi.stubGlobal('window', …)` or `Object.defineProperty(window, 'location', …)` throws
+     * `Cannot redefine property`. That is JS semantics, not a bug to route around. Every other global stays
+     * configurable and stubs normally.
+     *
+     * Push a file here and it leaves `unit-tests` for a sibling `unit-tests:global-stubs` project that is
+     * identical except for the pool, which is the default one. A plugin's `test` and `test:coverage` scripts
+     * name `unit-tests`, which also selects every `unit-tests:*` project, so the sibling runs and is covered
+     * without a script change. It is emitted only when this list is non-empty.
+     *
+     * To keep a whole suite on the default pool instead, set `unitTests.pool` to `'forks'` and say why.
+     */
+    readonly globalStubTestFiles: string[];
+    /**
+     * The multiplier applied to a project's test budget to get its hook budget. A hook typically populates
+     * and opens a vault, so it needs several times what a single test does.
+     *
+     * @default `4`
+     */
+    readonly hookTimeoutMultiplier = 4;
+    /**
+     * The `integration-tests:no-app` project, running the suites that need no Obsidian instance at all.
+     */
+    readonly noApp: ObsidianPluginVitestProjectConfig;
+    /**
+     * The per-eval cap the performance integration project gives its CDP transport, in milliseconds.
+     *
+     * @default `600000`
+     */
+    readonly performanceEvalCapInMilliseconds = 600000;
+    /**
+     * The per-test budget of the performance integration project, in milliseconds. A performance vault is
+     * pre-populated with tens of thousands of notes before Obsidian opens, so both its setup and its tests
+     * need far more time than the regular integration projects.
+     *
+     * Like the regular budget, it CLEARS the project's per-eval cap
+     * ({@link ObsidianPluginVitestConfigContext.performanceEvalCapInMilliseconds}) rather than matching it,
+     * so an evaluation that outruns the cap reports itself instead of dying as vitest's anonymous timeout.
+     *
+     * @default `615000`
+     */
+    readonly performanceTimeoutInMilliseconds: number;
+    /**
+     * The reporters the run prints through.
+     *
+     * Pinned rather than left to vitest, which resolves an unset `reporters` differently for a developer
+     * and for an AI coding session — see {@link DEFAULT_VITEST_REPORTERS} for the whole of why, and for
+     * what it deliberately leaves to vitest 5 itself.
+     *
+     * Push onto it to add a reporter beside the pinned one.
+     *
+     * @default {@link DEFAULT_VITEST_REPORTERS}
+     */
+    readonly reporters: ObsidianPluginVitestReporter[];
+    /**
+     * The `unit-tests` project, running the mocked-Obsidian suites in `jsdom`.
+     */
+    readonly unitTests: ObsidianPluginVitestProjectConfig;
+    /**
+     * Creates a new context seeded with the standard projects.
+     */
+    constructor();
+}
+/**
+ * Defines the vitest configuration for an Obsidian plugin.
+ *
+ * @param options - The options for defining the configuration.
+ * @returns The vitest configuration.
+ */
+export declare function defineObsidianPluginVitestConfig(options?: DefineObsidianPluginVitestConfigOptions): ViteUserConfig;

package/dist/lib/cjs/version.cjs

@@ -0,0 +1,262 @@
+/*
+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 = 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 = 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);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        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);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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 version_exports = {};
+__export(version_exports, {
+  copyUpdatedManifest: () => copyUpdatedManifest,
+  parseVersionArguments: () => parseVersionArguments,
+  updateVersion: () => updateVersion
+});
+module.exports = __toCommonJS(version_exports);
+var import_fs = require('@mnaoumov/typescript-dev-toolkit/fs');
+var import_json = require('@mnaoumov/typescript-dev-toolkit/json');
+var import_root = require('@mnaoumov/typescript-dev-toolkit/root');
+var import_version = require('@mnaoumov/typescript-dev-toolkit/version');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_node_fs = require('node:fs');
+var import_promises = require('node:fs/promises');
+var import_node_util = require('node:util');
+var import_demo_vault = require('./demo-vault.cjs');
+var import_obsidian_plugin_repo_paths = require('./obsidian-plugin-repo-paths.cjs');
+const DESKTOP_RELEASES_JSON_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json";
+async function copyUpdatedManifest() {
+  await (0, import_promises.cp)(
+    (0, import_root.resolvePathFromRootSafe)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestJson }),
+    (0, import_root.resolvePathFromRootSafe)({ path: (0, import_path.join)(import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistBuild, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestJson) }),
+    { force: true }
+  );
+}
+function parseVersionArguments($arguments) {
+  const { positionals, values } = (0, import_node_util.parseArgs)({
+    allowPositionals: true,
+    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.
+    args: $arguments,
+    options: {
+      ...import_version.VERSION_ARGUMENT_OPTIONS,
+      "min-app-version": { type: "string" },
+      "no-demo-vault": { type: "boolean" }
+    }
+  });
+  return {
+    options: {
+      ...(0, import_version.toUpdateVersionOptions)(values),
+      minAppVersion: values["min-app-version"],
+      shouldArchiveDemoVault: !(values["no-demo-vault"] ?? false)
+    },
+    versionUpdateType: positionals[0]
+  };
+}
+async function updateVersion(versionUpdateType, options = {}) {
+  const {
+    minAppVersion,
+    prepareGitHubRelease,
+    shouldArchiveDemoVault = true,
+    ...genericOptions
+  } = options;
+  await (0, import_version.updateVersion)(versionUpdateType, {
+    ...genericOptions,
+    getReleaseAssetPaths: getPluginReleaseAssetPaths,
+    async prepareGitHubRelease(newVersion) {
+      await prepareGitHubRelease?.(newVersion);
+      if (shouldArchiveDemoVault) {
+        await (0, import_demo_vault.archivePluginDemoVault)();
+      }
+    },
+    async updateVersionInExtraFiles(newVersion) {
+      await updateVersionInFilesForPlugin(newVersion, minAppVersion);
+    }
+  });
+}
+async function getLatestObsidianVersion() {
+  const response = await fetch(DESKTOP_RELEASES_JSON_URL);
+  const desktopReleasesJson = await response.json();
+  return (0, import_type_guards.ensureNonNullable)(desktopReleasesJson.latestVersion, "Could not find the latest desktop Obsidian version");
+}
+async function getPluginReleaseAssetPaths() {
+  const buildFolder = (0, import_root.resolvePathFromRootSafe)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistBuild });
+  const fileNames = await (0, import_fs.readdirPosix)(buildFolder);
+  return fileNames.map((fileName) => (0, import_path.join)(buildFolder, fileName));
+}
+async function updateVersionInFilesForPlugin(newVersion, minAppVersion) {
+  const manifestBetaJsonPath = (0, import_root.resolvePathFromRootSafe)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestBetaJson });
+  if ((0, import_version.isPreRelease)(newVersion)) {
+    await (0, import_promises.cp)(
+      (0, import_root.resolvePathFromRootSafe)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestJson }),
+      manifestBetaJsonPath,
+      { force: true }
+    );
+    await (0, import_json.editJson)({
+      editFunction: (manifest) => {
+        manifest.version = newVersion;
+      },
+      path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestBetaJson
+    });
+  } else {
+    const resolvedMinAppVersion = minAppVersion ?? await getLatestObsidianVersion();
+    await (0, import_json.editJson)({
+      editFunction: (manifest) => {
+        manifest.minAppVersion = resolvedMinAppVersion;
+        manifest.version = newVersion;
+      },
+      path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestJson
+    });
+    await (0, import_json.editJson)({
+      editFunction: (versions) => {
+        versions[newVersion] = resolvedMinAppVersion;
+      },
+      path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.VersionsJson
+    });
+    if ((0, import_node_fs.existsSync)(manifestBetaJsonPath)) {
+      await (0, import_promises.rm)(manifestBetaJsonPath);
+    }
+  }
+  await copyUpdatedManifest();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyUpdatedManifest,
+  parseVersionArguments,
+  updateVersion
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/version.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Releases an Obsidian plugin: the generic release from `@mnaoumov/typescript-dev-toolkit/version`, plus what only a\n * plugin has \u2014 `manifest.json` (and `manifest-beta.json` for a pre-release) and `versions.json` bumped with the\n * plugin's `minAppVersion`, the updated manifest copied into `dist/build`, the demo vault archived as a release\n * asset, and the files in `dist/build` attached to the GitHub release instead of an `npm pack` tarball.\n */\n\nimport type {\n  ParsedVersionArguments as GenericParsedVersionArguments,\n  UpdateVersionOptions as GenericUpdateVersionOptions\n} from '@mnaoumov/typescript-dev-toolkit/version';\n\nimport { readdirPosix } from '@mnaoumov/typescript-dev-toolkit/fs';\nimport { editJson } from '@mnaoumov/typescript-dev-toolkit/json';\nimport { resolvePathFromRootSafe } from '@mnaoumov/typescript-dev-toolkit/root';\nimport {\n  isPreRelease,\n  toUpdateVersionOptions,\n  updateVersion as updateVersionGeneric,\n  VERSION_ARGUMENT_OPTIONS\n} from '@mnaoumov/typescript-dev-toolkit/version';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  rm\n} from 'node:fs/promises';\nimport { parseArgs } from 'node:util';\n\nimport { archivePluginDemoVault } from './demo-vault.ts';\nimport { ObsidianPluginRepoPaths } from './obsidian-plugin-repo-paths.ts';\n\n/**\n * Type representing the structure of Obsidian's `desktop-releases.json` feed.\n *\n * This is the feed the desktop app itself updates from, so it is the only source that states a version\n * desktop users can actually run.\n */\nexport interface DesktopReleasesJson {\n  /**\n   * The latest Obsidian version available for desktop.\n   */\n  latestVersion: string;\n}\n\n/**\n * Type representing the manifest file format for Obsidian plugins.\n */\nexport interface Manifest {\n  /**\n   * A minimum Obsidian version required for the plugin.\n   */\n  minAppVersion: string;\n\n  /**\n   * A version of the plugin.\n   */\n  version: string;\n}\n/**\n * The result of parsing the command-line arguments for a plugin release.\n */\nexport interface ParsedVersionArguments extends GenericParsedVersionArguments {\n  /**\n   * The {@link UpdateVersionOptions} parsed from the flags.\n   */\n  readonly options: UpdateVersionOptions;\n}\n\n/**\n * Options for {@link updateVersion}: the generic release options plus the plugin's own.\n */\nexport interface UpdateVersionOptions extends GenericUpdateVersionOptions {\n  /**\n   * An explicit `minAppVersion` to write into the plugin's `manifest.json` and its new `versions.json`\n   * entry. When set, it is used verbatim and the latest Obsidian desktop version is not fetched at all.\n   *\n   * Set this when the plugin has a known minimum it actually requires, rather than tracking whatever\n   * Obsidian released most recently. Only applies to non-pre-release versions (a pre-release copies the\n   * existing `manifest.json` and never writes `minAppVersion`).\n   *\n   * @default the latest Obsidian desktop version\n   */\n  readonly minAppVersion?: string | undefined;\n\n  /**\n   * Whether to archive the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact. Ignored\n   * when the repo has no `demo-vault/` folder.\n   *\n   * @default `true`\n   */\n  readonly shouldArchiveDemoVault?: boolean;\n}\n\n/**\n * The feed the Obsidian desktop app updates from.\n *\n * Deliberately NOT the GitHub `releases/latest` API: that endpoint returns the newest release of any kind\n * in `obsidianmd/obsidian-releases`, including one whose only asset is the Android APK, which no desktop\n * user can install. See {@link getLatestObsidianVersion}.\n */\nconst DESKTOP_RELEASES_JSON_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json';\n\n/**\n * Copies the updated manifest file to the distribution build folder.\n *\n * @returns A {@link Promise} that resolves when the copy operation is complete.\n */\nexport async function copyUpdatedManifest(): Promise<void> {\n  await cp(\n    resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestJson }),\n    resolvePathFromRootSafe({ path: join(ObsidianPluginRepoPaths.DistBuild, ObsidianPluginRepoPaths.ManifestJson) }),\n    { force: true }\n  );\n}\n\n/**\n * Parses the command-line arguments for a plugin release: every flag the generic `parseVersionArguments`\n * recognizes, plus two of the plugin's own:\n * - `--min-app-version=<x.y.z>` \u2014 write this `minAppVersion` into the plugin's `manifest.json` and its new\n *   `versions.json` entry instead of tracking the latest Obsidian desktop version.\n * - `--no-demo-vault` \u2014 skip archiving the plugin's demo vault (`demo-vault/`) as a release artifact.\n *\n * @param $arguments - The command-line arguments to parse (typically `process.argv.slice(2)`).\n * @returns The {@link ParsedVersionArguments} containing the version update type and the options.\n */\nexport function parseVersionArguments($arguments: string[]): ParsedVersionArguments {\n  const { positionals, values } = parseArgs({\n    allowPositionals: true,\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.\n    args: $arguments,\n    options: {\n      ...VERSION_ARGUMENT_OPTIONS,\n      'min-app-version': { type: 'string' },\n      'no-demo-vault': { type: 'boolean' }\n    }\n  });\n\n  return {\n    options: {\n      ...toUpdateVersionOptions(values),\n      minAppVersion: values['min-app-version'],\n      shouldArchiveDemoVault: !(values['no-demo-vault'] ?? false)\n    },\n    versionUpdateType: positionals[0]\n  };\n}\n\n/**\n * Releases the plugin. See the `@file` overview for what it adds to the generic release.\n *\n * @param versionUpdateType - The type of version update to perform (major, minor, patch, premajor, preminor, prepatch, prerelease, or x.y.z[-suffix]).\n * @param options - The {@link UpdateVersionOptions} controlling the release behavior.\n * @returns A {@link Promise} that resolves when the release is complete.\n */\nexport async function updateVersion(versionUpdateType?: string, options: UpdateVersionOptions = {}): Promise<void> {\n  const {\n    minAppVersion,\n    prepareGitHubRelease,\n    shouldArchiveDemoVault = true,\n    ...genericOptions\n  } = options;\n\n  await updateVersionGeneric(versionUpdateType, {\n    ...genericOptions,\n    getReleaseAssetPaths: getPluginReleaseAssetPaths,\n    async prepareGitHubRelease(newVersion: string): Promise<void> {\n      await prepareGitHubRelease?.(newVersion);\n      if (shouldArchiveDemoVault) {\n        await archivePluginDemoVault();\n      }\n    },\n    async updateVersionInExtraFiles(newVersion: string): Promise<void> {\n      await updateVersionInFilesForPlugin(newVersion, minAppVersion);\n    }\n  });\n}\n\n/**\n * Fetches the latest version of Obsidian that the desktop app can actually run.\n *\n * Reads {@link DESKTOP_RELEASES_JSON_URL}, not the GitHub `releases/latest` API. The API returns the newest\n * release of ANY kind, so whenever a mobile-only release (an APK-only asset) is newer than the desktop one,\n * it reports a version that does not exist for desktop. A plugin released in that window gets a\n * `minAppVersion` no desktop user can satisfy, and Obsidian silently keeps offering them the previous\n * release instead \u2014 the release succeeds and reaches nobody.\n *\n * @returns A {@link Promise} that resolves to the latest Obsidian version available for desktop.\n */\nasync function getLatestObsidianVersion(): Promise<string> {\n  // eslint-disable-next-line no-restricted-globals -- We run this outside of Obsidian, so we don't have `requestUrl()`.\n  const response = await fetch(DESKTOP_RELEASES_JSON_URL);\n  const desktopReleasesJson = await response.json() as Partial<DesktopReleasesJson>;\n  return ensureNonNullable(desktopReleasesJson.latestVersion, 'Could not find the latest desktop Obsidian version');\n}\n/**\n * The plugin's release assets: every file in `dist/build`.\n *\n * @returns The asset paths.\n */\nasync function getPluginReleaseAssetPaths(): Promise<string[]> {\n  const buildFolder = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DistBuild });\n  const fileNames = await readdirPosix(buildFolder);\n  return fileNames.map((fileName) => join(buildFolder, fileName));\n}\n\nasync function updateVersionInFilesForPlugin(newVersion: string, minAppVersion: string | undefined): Promise<void> {\n  const manifestBetaJsonPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestBetaJson });\n  if (isPreRelease(newVersion)) {\n    await cp(\n      resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestJson }),\n      manifestBetaJsonPath,\n      { force: true }\n    );\n    await editJson<Manifest>({\n      editFunction: (manifest) => {\n        manifest.version = newVersion;\n      },\n      path: ObsidianPluginRepoPaths.ManifestBetaJson\n    });\n  } else {\n    const resolvedMinAppVersion = minAppVersion ?? await getLatestObsidianVersion();\n\n    await editJson<Manifest>({\n      editFunction: (manifest) => {\n        manifest.minAppVersion = resolvedMinAppVersion;\n        manifest.version = newVersion;\n      },\n      path: ObsidianPluginRepoPaths.ManifestJson\n    });\n\n    await editJson<Record<string, string>>({\n      editFunction: (versions) => {\n        versions[newVersion] = resolvedMinAppVersion;\n      },\n      path: ObsidianPluginRepoPaths.VersionsJson\n    });\n\n    if (existsSync(manifestBetaJsonPath)) {\n      await rm(manifestBetaJsonPath);\n    }\n  }\n\n  await copyUpdatedManifest();\n}\n"],
  "mappings": "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",
  "names": ["updateVersionGeneric"]
}


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

@@ -0,0 +1,92 @@
+/// <reference path="./index.d.cts" />
+/**
+ * @file
+ *
+ * Releases an Obsidian plugin: the generic release from `@mnaoumov/typescript-dev-toolkit/version`, plus what only a
+ * plugin has — `manifest.json` (and `manifest-beta.json` for a pre-release) and `versions.json` bumped with the
+ * plugin's `minAppVersion`, the updated manifest copied into `dist/build`, the demo vault archived as a release
+ * asset, and the files in `dist/build` attached to the GitHub release instead of an `npm pack` tarball.
+ */
+import type { ParsedVersionArguments as GenericParsedVersionArguments, UpdateVersionOptions as GenericUpdateVersionOptions } from '@mnaoumov/typescript-dev-toolkit/version' with { 'resolution-mode': 'import' };
+/**
+ * Type representing the structure of Obsidian's `desktop-releases.json` feed.
+ *
+ * This is the feed the desktop app itself updates from, so it is the only source that states a version
+ * desktop users can actually run.
+ */
+export interface DesktopReleasesJson {
+    /**
+     * The latest Obsidian version available for desktop.
+     */
+    latestVersion: string;
+}
+/**
+ * Type representing the manifest file format for Obsidian plugins.
+ */
+export interface Manifest {
+    /**
+     * A minimum Obsidian version required for the plugin.
+     */
+    minAppVersion: string;
+    /**
+     * A version of the plugin.
+     */
+    version: string;
+}
+/**
+ * The result of parsing the command-line arguments for a plugin release.
+ */
+export interface ParsedVersionArguments extends GenericParsedVersionArguments {
+    /**
+     * The {@link UpdateVersionOptions} parsed from the flags.
+     */
+    readonly options: UpdateVersionOptions;
+}
+/**
+ * Options for {@link updateVersion}: the generic release options plus the plugin's own.
+ */
+export interface UpdateVersionOptions extends GenericUpdateVersionOptions {
+    /**
+     * An explicit `minAppVersion` to write into the plugin's `manifest.json` and its new `versions.json`
+     * entry. When set, it is used verbatim and the latest Obsidian desktop version is not fetched at all.
+     *
+     * Set this when the plugin has a known minimum it actually requires, rather than tracking whatever
+     * Obsidian released most recently. Only applies to non-pre-release versions (a pre-release copies the
+     * existing `manifest.json` and never writes `minAppVersion`).
+     *
+     * @default the latest Obsidian desktop version
+     */
+    readonly minAppVersion?: string | undefined;
+    /**
+     * Whether to archive the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact. Ignored
+     * when the repo has no `demo-vault/` folder.
+     *
+     * @default `true`
+     */
+    readonly shouldArchiveDemoVault?: boolean;
+}
+/**
+ * Copies the updated manifest file to the distribution build folder.
+ *
+ * @returns A {@link Promise} that resolves when the copy operation is complete.
+ */
+export declare function copyUpdatedManifest(): Promise<void>;
+/**
+ * Parses the command-line arguments for a plugin release: every flag the generic `parseVersionArguments`
+ * recognizes, plus two of the plugin's own:
+ * - `--min-app-version=<x.y.z>` — write this `minAppVersion` into the plugin's `manifest.json` and its new
+ *   `versions.json` entry instead of tracking the latest Obsidian desktop version.
+ * - `--no-demo-vault` — skip archiving the plugin's demo vault (`demo-vault/`) as a release artifact.
+ *
+ * @param $arguments - The command-line arguments to parse (typically `process.argv.slice(2)`).
+ * @returns The {@link ParsedVersionArguments} containing the version update type and the options.
+ */
+export declare function parseVersionArguments($arguments: string[]): ParsedVersionArguments;
+/**
+ * Releases the plugin. See the `@file` overview for what it adds to the generic release.
+ *
+ * @param versionUpdateType - The type of version update to perform (major, minor, patch, premajor, preminor, prepatch, prerelease, or x.y.z[-suffix]).
+ * @param options - The {@link UpdateVersionOptions} controlling the release behavior.
+ * @returns A {@link Promise} that resolves when the release is complete.
+ */
+export declare function updateVersion(versionUpdateType?: string, options?: UpdateVersionOptions): Promise<void>;