obsidian-dev-utils 70.0.1 → 70.2.0

package/dist/lib/esm/script-utils/obsidian-dev-utils-repo-paths.mjs

@@ -66,6 +66,8 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
   ObsidianDevUtilsRepoPaths2["StylesCss"] = "styles.css";
   ObsidianDevUtilsRepoPaths2["TestHelpers"] = "test-helpers";
   ObsidianDevUtilsRepoPaths2["TsConfigJson"] = "tsconfig.json";
+  ObsidianDevUtilsRepoPaths2["TsConfigValidateDeclarationsCjsJson"] = "tsconfig.validate-declarations-cjs.json";
+  ObsidianDevUtilsRepoPaths2["TsConfigValidateDeclarationsJson"] = "tsconfig.validate-declarations.json";
   ObsidianDevUtilsRepoPaths2["TsExtension"] = ".ts";
   ObsidianDevUtilsRepoPaths2["Types"] = "@types";
   return ObsidianDevUtilsRepoPaths2;
@@ -73,4 +75,4 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
 export {
   ObsidianDevUtilsRepoPaths
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/validate-declarations.d.mts

@@ -0,0 +1,24 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Type-checks the generated declaration files (`.d.cts` / `.d.mts`) to prove they are self-contained
+ * — every `lib` and internal cross-reference they rely on resolves on its own, independent of the
+ * consumer's `tsconfig`.
+ *
+ * The library does not own the types of the third-party packages its declarations import (e.g.
+ * `type-fest`, `obsidian`, `markdownlint`). Cross-module-format interop diagnostics caused by those
+ * imports — for example a CommonJS `.d.cts` importing an ESM-only package without a
+ * `resolution-mode` attribute (`TS1541` / `TS1542` / `TS1479`) — describe the third-party package's
+ * shape, not a flaw in our declarations, and are the consumer's concern. They are therefore ignored.
+ * Only diagnostics about the library's own declarations are reported.
+ */
+/**
+ * Validates the generated declaration files against the `tsconfig.validate-declarations*.json`
+ * configs, reporting only diagnostics that concern the library's own declarations and ignoring those
+ * caused by importing third-party packages.
+ *
+ * @returns `true` when the library's own declarations have no type errors, `false` otherwise.
+ * @throws If the root folder cannot be found.
+ */
+export declare function validateDeclarations(): boolean;

package/dist/lib/esm/script-utils/validate-declarations.mjs

@@ -0,0 +1,106 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  forEachChild,
+  isExportDeclaration,
+  isImportDeclaration,
+  isImportTypeNode,
+  isLiteralTypeNode,
+  isStringLiteral
+} from "typescript";
+import { join } from "../path.mjs";
+import {
+  checkProjectTypes,
+  parseTsConfig,
+  toCanonical
+} from "./check-project-types.mjs";
+import { ObsidianDevUtilsRepoPaths } from "./obsidian-dev-utils-repo-paths.mjs";
+import { getRootFolder } from "./root.mjs";
+const NODE_MODULES_SEGMENT = "/node_modules/";
+const RELATIVE_SPECIFIER_PREFIX = ".";
+const VALIDATE_DECLARATIONS_TS_CONFIG_FILE_NAMES = [
+  ObsidianDevUtilsRepoPaths.TsConfigValidateDeclarationsJson,
+  ObsidianDevUtilsRepoPaths.TsConfigValidateDeclarationsCjsJson
+];
+function validateDeclarations() {
+  const root = getRootFolder();
+  if (!root) {
+    throw new Error("Could not find root folder");
+  }
+  const rootCanonical = toCanonical(root);
+  let isValid = true;
+  for (const tsConfigFileName of VALIDATE_DECLARATIONS_TS_CONFIG_FILE_NAMES) {
+    const { fileNames, options } = parseTsConfig(join(root, tsConfigFileName));
+    const isConfigValid = checkProjectTypes({
+      options,
+      rootNames: fileNames,
+      shouldKeepDiagnostic: (diagnostic) => !isThirdPartyModuleImportDiagnostic(diagnostic),
+      shouldKeepFile: (fileName) => shouldKeepProjectFile(fileName, rootCanonical)
+    });
+    isValid &&= isConfigValid;
+  }
+  return isValid;
+}
+function findEnclosingModuleSpecifier(sourceFile, position) {
+  let specifier = null;
+  visit(sourceFile);
+  return specifier;
+  function visit(node) {
+    if (position < node.getStart(sourceFile) || position >= node.getEnd()) {
+      return;
+    }
+    const nodeSpecifier = getModuleSpecifier(node);
+    if (nodeSpecifier !== null) {
+      specifier = nodeSpecifier;
+    }
+    forEachChild(node, visit);
+  }
+}
+function getModuleSpecifier(node) {
+  if (isImportDeclaration(node) || isExportDeclaration(node)) {
+    return getStringLiteralText(node.moduleSpecifier);
+  }
+  if (isImportTypeNode(node)) {
+    return isLiteralTypeNode(node.argument) ? getStringLiteralText(node.argument.literal) : null;
+  }
+  return null;
+}
+function getStringLiteralText(node) {
+  return node && isStringLiteral(node) ? node.text : null;
+}
+function isThirdPartyModuleImportDiagnostic(diagnostic) {
+  const file = diagnostic.file;
+  if (!file || diagnostic.start === void 0) {
+    return false;
+  }
+  const specifier = findEnclosingModuleSpecifier(file, diagnostic.start);
+  return specifier !== null && !specifier.startsWith(RELATIVE_SPECIFIER_PREFIX);
+}
+function shouldKeepProjectFile(fileName, rootCanonical) {
+  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);
+}
+export {
+  validateDeclarations
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy92YWxpZGF0ZS1kZWNsYXJhdGlvbnMudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBUeXBlLWNoZWNrcyB0aGUgZ2VuZXJhdGVkIGRlY2xhcmF0aW9uIGZpbGVzIChgLmQuY3RzYCAvIGAuZC5tdHNgKSB0byBwcm92ZSB0aGV5IGFyZSBzZWxmLWNvbnRhaW5lZFxuICogXHUyMDE0IGV2ZXJ5IGBsaWJgIGFuZCBpbnRlcm5hbCBjcm9zcy1yZWZlcmVuY2UgdGhleSByZWx5IG9uIHJlc29sdmVzIG9uIGl0cyBvd24sIGluZGVwZW5kZW50IG9mIHRoZVxuICogY29uc3VtZXIncyBgdHNjb25maWdgLlxuICpcbiAqIFRoZSBsaWJyYXJ5IGRvZXMgbm90IG93biB0aGUgdHlwZXMgb2YgdGhlIHRoaXJkLXBhcnR5IHBhY2thZ2VzIGl0cyBkZWNsYXJhdGlvbnMgaW1wb3J0IChlLmcuXG4gKiBgdHlwZS1mZXN0YCwgYG9ic2lkaWFuYCwgYG1hcmtkb3dubGludGApLiBDcm9zcy1tb2R1bGUtZm9ybWF0IGludGVyb3AgZGlhZ25vc3RpY3MgY2F1c2VkIGJ5IHRob3NlXG4gKiBpbXBvcnRzIFx1MjAxNCBmb3IgZXhhbXBsZSBhIENvbW1vbkpTIGAuZC5jdHNgIGltcG9ydGluZyBhbiBFU00tb25seSBwYWNrYWdlIHdpdGhvdXQgYVxuICogYHJlc29sdXRpb24tbW9kZWAgYXR0cmlidXRlIChgVFMxNTQxYCAvIGBUUzE1NDJgIC8gYFRTMTQ3OWApIFx1MjAxNCBkZXNjcmliZSB0aGUgdGhpcmQtcGFydHkgcGFja2FnZSdzXG4gKiBzaGFwZSwgbm90IGEgZmxhdyBpbiBvdXIgZGVjbGFyYXRpb25zLCBhbmQgYXJlIHRoZSBjb25zdW1lcidzIGNvbmNlcm4uIFRoZXkgYXJlIHRoZXJlZm9yZSBpZ25vcmVkLlxuICogT25seSBkaWFnbm9zdGljcyBhYm91dCB0aGUgbGlicmFyeSdzIG93biBkZWNsYXJhdGlvbnMgYXJlIHJlcG9ydGVkLlxuICovXG5cbmltcG9ydCB0eXBlIHtcbiAgRGlhZ25vc3RpYyxcbiAgTm9kZSxcbiAgU291cmNlRmlsZVxufSBmcm9tICd0eXBlc2NyaXB0JztcblxuaW1wb3J0IHtcbiAgZm9yRWFjaENoaWxkLFxuICBpc0V4cG9ydERlY2xhcmF0aW9uLFxuICBpc0ltcG9ydERlY2xhcmF0aW9uLFxuICBpc0ltcG9ydFR5cGVOb2RlLFxuICBpc0xpdGVyYWxUeXBlTm9kZSxcbiAgaXNTdHJpbmdMaXRlcmFsXG59IGZyb20gJ3R5cGVzY3JpcHQnO1xuXG5pbXBvcnQgeyBqb2luIH0gZnJvbSAnLi4vcGF0aC50cyc7XG5pbXBvcnQge1xuICBjaGVja1Byb2plY3RUeXBlcyxcbiAgcGFyc2VUc0NvbmZpZyxcbiAgdG9DYW5vbmljYWxcbn0gZnJvbSAnLi9jaGVjay1wcm9qZWN0LXR5cGVzLnRzJztcbmltcG9ydCB7IE9ic2lkaWFuRGV2VXRpbHNSZXBvUGF0aHMgfSBmcm9tICcuL29ic2lkaWFuLWRldi11dGlscy1yZXBvLXBhdGhzLnRzJztcbmltcG9ydCB7IGdldFJvb3RGb2xkZXIgfSBmcm9tICcuL3Jvb3QudHMnO1xuXG5jb25zdCBOT0RFX01PRFVMRVNfU0VHTUVOVCA9ICcvbm9kZV9tb2R1bGVzLyc7XG5jb25zdCBSRUxBVElWRV9TUEVDSUZJRVJfUFJFRklYID0gJy4nO1xuXG5jb25zdCBWQUxJREFURV9ERUNMQVJBVElPTlNfVFNfQ09ORklHX0ZJTEVfTkFNRVMgPSBbXG4gIE9ic2lkaWFuRGV2VXRpbHNSZXBvUGF0aHMuVHNDb25maWdWYWxpZGF0ZURlY2xhcmF0aW9uc0pzb24sXG4gIE9ic2lkaWFuRGV2VXRpbHNSZXBvUGF0aHMuVHNDb25maWdWYWxpZGF0ZURlY2xhcmF0aW9uc0Nqc0pzb25cbl07XG5cbi8qKlxuICogVmFsaWRhdGVzIHRoZSBnZW5lcmF0ZWQgZGVjbGFyYXRpb24gZmlsZXMgYWdhaW5zdCB0aGUgYHRzY29uZmlnLnZhbGlkYXRlLWRlY2xhcmF0aW9ucyouanNvbmBcbiAqIGNvbmZpZ3MsIHJlcG9ydGluZyBvbmx5IGRpYWdub3N0aWNzIHRoYXQgY29uY2VybiB0aGUgbGlicmFyeSdzIG93biBkZWNsYXJhdGlvbnMgYW5kIGlnbm9yaW5nIHRob3NlXG4gKiBjYXVzZWQgYnkgaW1wb3J0aW5nIHRoaXJkLXBhcnR5IHBhY2thZ2VzLlxuICpcbiAqIEByZXR1cm5zIGB0cnVlYCB3aGVuIHRoZSBsaWJyYXJ5J3Mgb3duIGRlY2xhcmF0aW9ucyBoYXZlIG5vIHR5cGUgZXJyb3JzLCBgZmFsc2VgIG90aGVyd2lzZS5cbiAqIEB0aHJvd3MgSWYgdGhlIHJvb3QgZm9sZGVyIGNhbm5vdCBiZSBmb3VuZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHZhbGlkYXRlRGVjbGFyYXRpb25zKCk6IGJvb2xlYW4ge1xuICBjb25zdCByb290ID0gZ2V0Um9vdEZvbGRlcigpO1xuXG4gIGlmICghcm9vdCkge1xuICAgIHRocm93IG5ldyBFcnJvcignQ291bGQgbm90IGZpbmQgcm9vdCBmb2xkZXInKTtcbiAgfVxuXG4gIGNvbnN0IHJvb3RDYW5vbmljYWwgPSB0b0Nhbm9uaWNhbChyb290KTtcblxuICBsZXQgaXNWYWxpZCA9IHRydWU7XG5cbiAgZm9yIChjb25zdCB0c0NvbmZpZ0ZpbGVOYW1lIG9mIFZBTElEQVRFX0RFQ0xBUkFUSU9OU19UU19DT05GSUdfRklMRV9OQU1FUykge1xuICAgIGNvbnN0IHsgZmlsZU5hbWVzLCBvcHRpb25zIH0gPSBwYXJzZVRzQ29uZmlnKGpvaW4ocm9vdCwgdHNDb25maWdGaWxlTmFtZSkpO1xuICAgIGNvbnN0IGlzQ29uZmlnVmFsaWQgPSBjaGVja1Byb2plY3RUeXBlcyh7XG4gICAgICBvcHRpb25zLFxuICAgICAgcm9vdE5hbWVzOiBmaWxlTmFtZXMsXG4gICAgICBzaG91bGRLZWVwRGlhZ25vc3RpYzogKGRpYWdub3N0aWMpID0+ICFpc1RoaXJkUGFydHlNb2R1bGVJbXBvcnREaWFnbm9zdGljKGRpYWdub3N0aWMpLFxuICAgICAgc2hvdWxkS2VlcEZpbGU6IChmaWxlTmFtZSkgPT4gc2hvdWxkS2VlcFByb2plY3RGaWxlKGZpbGVOYW1lLCByb290Q2Fub25pY2FsKVxuICAgIH0pO1xuICAgIGlzVmFsaWQgJiY9IGlzQ29uZmlnVmFsaWQ7XG4gIH1cblxuICByZXR1cm4gaXNWYWxpZDtcbn1cblxuZnVuY3Rpb24gZmluZEVuY2xvc2luZ01vZHVsZVNwZWNpZmllcihzb3VyY2VGaWxlOiBTb3VyY2VGaWxlLCBwb3NpdGlvbjogbnVtYmVyKTogbnVsbCB8IHN0cmluZyB7XG4gIGxldCBzcGVjaWZpZXI6IG51bGwgfCBzdHJpbmcgPSBudWxsO1xuICB2aXNpdChzb3VyY2VGaWxlKTtcbiAgcmV0dXJuIHNwZWNpZmllcjtcblxuICBmdW5jdGlvbiB2aXNpdChub2RlOiBOb2RlKTogdm9pZCB7XG4gICAgaWYgKHBvc2l0aW9uIDwgbm9kZS5nZXRTdGFydChzb3VyY2VGaWxlKSB8fCBwb3NpdGlvbiA+PSBub2RlLmdldEVuZCgpKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgY29uc3Qgbm9kZVNwZWNpZmllciA9IGdldE1vZHVsZVNwZWNpZmllcihub2RlKTtcbiAgICBpZiAobm9kZVNwZWNpZmllciAhPT0gbnVsbCkge1xuICAgICAgc3BlY2lmaWVyID0gbm9kZVNwZWNpZmllcjtcbiAgICB9XG5cbiAgICBmb3JFYWNoQ2hpbGQobm9kZSwgdmlzaXQpO1xuICB9XG59XG5cbmZ1bmN0aW9uIGdldE1vZHVsZVNwZWNpZmllcihub2RlOiBOb2RlKTogbnVsbCB8IHN0cmluZyB7XG4gIGlmIChpc0ltcG9ydERlY2xhcmF0aW9uKG5vZGUpIHx8IGlzRXhwb3J0RGVjbGFyYXRpb24obm9kZSkpIHtcbiAgICByZXR1cm4gZ2V0U3RyaW5nTGl0ZXJhbFRleHQobm9kZS5tb2R1bGVTcGVjaWZpZXIpO1xuICB9XG5cbiAgaWYgKGlzSW1wb3J0VHlwZU5vZGUobm9kZSkpIHtcbiAgICByZXR1cm4gaXNMaXRlcmFsVHlwZU5vZGUobm9kZS5hcmd1bWVudCkgPyBnZXRTdHJpbmdMaXRlcmFsVGV4dChub2RlLmFyZ3VtZW50LmxpdGVyYWwpIDogbnVsbDtcbiAgfVxuXG4gIHJldHVybiBudWxsO1xufVxuXG5mdW5jdGlvbiBnZXRTdHJpbmdMaXRlcmFsVGV4dChub2RlOiBOb2RlIHwgdW5kZWZpbmVkKTogbnVsbCB8IHN0cmluZyB7XG4gIHJldHVybiBub2RlICYmIGlzU3RyaW5nTGl0ZXJhbChub2RlKSA/IG5vZGUudGV4dCA6IG51bGw7XG59XG5cbmZ1bmN0aW9uIGlzVGhpcmRQYXJ0eU1vZHVsZUltcG9ydERpYWdub3N0aWMoZGlhZ25vc3RpYzogRGlhZ25vc3RpYyk6IGJvb2xlYW4ge1xuICBjb25zdCBmaWxlID0gZGlhZ25vc3RpYy5maWxlO1xuICBpZiAoIWZpbGUgfHwgZGlhZ25vc3RpYy5zdGFydCA9PT0gdW5kZWZpbmVkKSB7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgY29uc3Qgc3BlY2lmaWVyID0gZmluZEVuY2xvc2luZ01vZHVsZVNwZWNpZmllcihmaWxlLCBkaWFnbm9zdGljLnN0YXJ0KTtcbiAgcmV0dXJuIHNwZWNpZmllciAhPT0gbnVsbCAmJiAhc3BlY2lmaWVyLnN0YXJ0c1dpdGgoUkVMQVRJVkVfU1BFQ0lGSUVSX1BSRUZJWCk7XG59XG5cbmZ1bmN0aW9uIHNob3VsZEtlZXBQcm9qZWN0RmlsZShmaWxlTmFtZTogc3RyaW5nLCByb290Q2Fub25pY2FsOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgcmV0dXJuIGZpbGVOYW1lLnN0YXJ0c1dpdGgoYCR7cm9vdENhbm9uaWNhbH0vYCkgJiYgIWZpbGVOYW1lLmluY2x1ZGVzKE5PREVfTU9EVUxFU19TRUdNRU5UKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBcUJBO0FBQUEsRUFDRTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsT0FDSztBQUVQLFNBQVMsWUFBWTtBQUNyQjtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFDUCxTQUFTLGlDQUFpQztBQUMxQyxTQUFTLHFCQUFxQjtBQUU5QixNQUFNLHVCQUF1QjtBQUM3QixNQUFNLDRCQUE0QjtBQUVsQyxNQUFNLDZDQUE2QztBQUFBLEVBQ2pELDBCQUEwQjtBQUFBLEVBQzFCLDBCQUEwQjtBQUM1QjtBQVVPLFNBQVMsdUJBQWdDO0FBQzlDLFFBQU0sT0FBTyxjQUFjO0FBRTNCLE1BQUksQ0FBQyxNQUFNO0FBQ1QsVUFBTSxJQUFJLE1BQU0sNEJBQTRCO0FBQUEsRUFDOUM7QUFFQSxRQUFNLGdCQUFnQixZQUFZLElBQUk7QUFFdEMsTUFBSSxVQUFVO0FBRWQsYUFBVyxvQkFBb0IsNENBQTRDO0FBQ3pFLFVBQU0sRUFBRSxXQUFXLFFBQVEsSUFBSSxjQUFjLEtBQUssTUFBTSxnQkFBZ0IsQ0FBQztBQUN6RSxVQUFNLGdCQUFnQixrQkFBa0I7QUFBQSxNQUN0QztBQUFBLE1BQ0EsV0FBVztBQUFBLE1BQ1gsc0JBQXNCLENBQUMsZUFBZSxDQUFDLG1DQUFtQyxVQUFVO0FBQUEsTUFDcEYsZ0JBQWdCLENBQUMsYUFBYSxzQkFBc0IsVUFBVSxhQUFhO0FBQUEsSUFDN0UsQ0FBQztBQUNELGdCQUFZO0FBQUEsRUFDZDtBQUVBLFNBQU87QUFDVDtBQUVBLFNBQVMsNkJBQTZCLFlBQXdCLFVBQWlDO0FBQzdGLE1BQUksWUFBMkI7QUFDL0IsUUFBTSxVQUFVO0FBQ2hCLFNBQU87QUFFUCxXQUFTLE1BQU0sTUFBa0I7QUFDL0IsUUFBSSxXQUFXLEtBQUssU0FBUyxVQUFVLEtBQUssWUFBWSxLQUFLLE9BQU8sR0FBRztBQUNyRTtBQUFBLElBQ0Y7QUFFQSxVQUFNLGdCQUFnQixtQkFBbUIsSUFBSTtBQUM3QyxRQUFJLGtCQUFrQixNQUFNO0FBQzFCLGtCQUFZO0FBQUEsSUFDZDtBQUVBLGlCQUFhLE1BQU0sS0FBSztBQUFBLEVBQzFCO0FBQ0Y7QUFFQSxTQUFTLG1CQUFtQixNQUEyQjtBQUNyRCxNQUFJLG9CQUFvQixJQUFJLEtBQUssb0JBQW9CLElBQUksR0FBRztBQUMxRCxXQUFPLHFCQUFxQixLQUFLLGVBQWU7QUFBQSxFQUNsRDtBQUVBLE1BQUksaUJBQWlCLElBQUksR0FBRztBQUMxQixXQUFPLGtCQUFrQixLQUFLLFFBQVEsSUFBSSxxQkFBcUIsS0FBSyxTQUFTLE9BQU8sSUFBSTtBQUFBLEVBQzFGO0FBRUEsU0FBTztBQUNUO0FBRUEsU0FBUyxxQkFBcUIsTUFBdUM7QUFDbkUsU0FBTyxRQUFRLGdCQUFnQixJQUFJLElBQUksS0FBSyxPQUFPO0FBQ3JEO0FBRUEsU0FBUyxtQ0FBbUMsWUFBaUM7QUFDM0UsUUFBTSxPQUFPLFdBQVc7QUFDeEIsTUFBSSxDQUFDLFFBQVEsV0FBVyxVQUFVLFFBQVc7QUFDM0MsV0FBTztBQUFBLEVBQ1Q7QUFFQSxRQUFNLFlBQVksNkJBQTZCLE1BQU0sV0FBVyxLQUFLO0FBQ3JFLFNBQU8sY0FBYyxRQUFRLENBQUMsVUFBVSxXQUFXLHlCQUF5QjtBQUM5RTtBQUVBLFNBQVMsc0JBQXNCLFVBQWtCLGVBQWdDO0FBQy9FLFNBQU8sU0FBUyxXQUFXLEdBQUcsYUFBYSxHQUFHLEtBQUssQ0FBQyxTQUFTLFNBQVMsb0JBQW9CO0FBQzVGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/script-utils/version.d.mts

@@ -7,6 +7,69 @@
  * of Git and GitHub CLI, updating version numbers in files, and performing
  * Git operations such as tagging and pushing.
  */
+/**
+ * Options for {@link addUpdatedFilesToGit}.
+ */
+export interface AddUpdatedFilesToGitOptions {
+    /**
+     * Whether to pass `--no-verify` to the release commit, skipping the pre-commit hook. Defaults to `false`.
+     */
+    readonly shouldBypassCommitVerification?: boolean;
+}
+/**
+ * The result of parsing the command-line arguments for a version update.
+ */
+export interface ParsedVersionArgs {
+    /**
+     * The {@link UpdateVersionOptions} parsed from the flags.
+     */
+    readonly options: UpdateVersionOptions;
+    /**
+     * The positional version update type argument, or `undefined` if none was provided.
+     */
+    readonly versionUpdateType: string | undefined;
+}
+/**
+ * Options for {@link updateChangelog}.
+ */
+export interface UpdateChangelogOptions {
+    /**
+     * Whether to skip the interactive review of the generated changelog. When `true`, the changelog
+     * is still generated from commit messages, but it is not opened in the editor for manual review.
+     * Defaults to `false`.
+     */
+    readonly shouldBypassChangelogEditing?: boolean;
+}
+/**
+ * Options for {@link updateVersion}.
+ */
+export interface UpdateVersionOptions {
+    /**
+     * Whether to perform a dry run. When `true`, all local steps are executed (version bump, changelog,
+     * commit, tag), but the changes are not pushed and no GitHub release is published. Defaults to `false`.
+     */
+    readonly isDryRun?: boolean;
+    /**
+     * A callback function to prepare the GitHub release.
+     *
+     * @param newVersion - The new version number for the release.
+     * @returns A {@link Promise} that resolves when the GitHub release has been prepared.
+     */
+    prepareGitHubRelease?(this: void, newVersion: string): Promise<void>;
+    /**
+     * Whether to skip the interactive review of the generated changelog. Defaults to `false`.
+     */
+    readonly shouldBypassChangelogEditing?: boolean;
+    /**
+     * Whether to pass `--no-verify` to the release commit, skipping the pre-commit hook. Defaults to `false`.
+     */
+    readonly shouldBypassCommitVerification?: boolean;
+    /**
+     * Whether to skip the preflight checks (clean-repo check, format, spellcheck, lint, build, and tests).
+     * Defaults to `false`.
+     */
+    readonly shouldSkipPreflightChecks?: boolean;
+}
 /**
  * Enum representing different types of version updates.
  *
@@ -55,10 +118,18 @@ export declare function addGitTag(newVersion: string): Promise<void>;
 /**
  * Adds updated files to the Git staging area and commits them with the new version message.
  *
+ * If the commit fails (for example, the pre-commit hook rejects a new word in the changelog) and the
+ * process is attached to an interactive terminal, the user is prompted to fix the issue (for example,
+ * add the missing word to `cspell.json`) and press Enter to retry. The retry re-stages all files, so the
+ * fix is picked up without restarting the whole release lifecycle. In a non-interactive environment (no
+ * TTY, such as CI), the error is re-thrown instead of prompting, so the script fails fast rather than
+ * hanging. Pass `shouldBypassCommitVerification` to skip the pre-commit hook entirely in such cases.
+ *
  * @param newVersion - The new version number used as the commit message.
+ * @param options - The {@link AddUpdatedFilesToGitOptions} controlling the commit behavior.
  * @returns A {@link Promise} that resolves when the files have been added and committed.
  */
-export declare function addUpdatedFilesToGit(newVersion: string): Promise<void>;
+export declare function addUpdatedFilesToGit(newVersion: string, options?: AddUpdatedFilesToGitOptions): Promise<void>;
 /**
  * Checks if the GitHub CLI is installed on the system.
  *
@@ -121,6 +192,20 @@ export declare function getVersionUpdateType(versionUpdateType: string): Version
  * @returns A {@link Promise} that resolves when the push operation is complete.
  */
 export declare function gitPush(): Promise<void>;
+/**
+ * Parses the command-line arguments for a version update into a version update type and
+ * {@link UpdateVersionOptions}.
+ *
+ * Recognized flags:
+ * - `--bypass-changelog-editing` — generate the changelog without opening it for manual review.
+ * - `--bypass-commit-verification` — pass `--no-verify` to the release commit.
+ * - `--dry-run` — run all local steps but skip the push and the GitHub release.
+ * - `--skip-preflight-checks` — skip the clean-repo check, format, spellcheck, lint, build, and tests.
+ *
+ * @param args - The command-line arguments to parse (typically `process.argv.slice(2)`).
+ * @returns The {@link ParsedVersionArgs} containing the version update type and the options.
+ */
+export declare function parseVersionArgs(args: string[]): ParsedVersionArgs;
 /**
  * Publishes a GitHub release for the new version.
  *
@@ -138,9 +223,10 @@ export declare function publishGitHubRelease(newVersion: string, isObsidianPlugi
  * and prompts the user to review the changes.
  *
  * @param newVersion - The new version number to be added to the changelog.
+ * @param options - The {@link UpdateChangelogOptions} controlling the changelog review behavior.
  * @returns A {@link Promise} that resolves when the changelog update is complete.
  */
-export declare function updateChangelog(newVersion: string): Promise<void>;
+export declare function updateChangelog(newVersion: string, options?: UpdateChangelogOptions): Promise<void>;
 /**
  * Updates the version of the project based on the specified update type.
  *
@@ -155,10 +241,10 @@ export declare function updateChangelog(newVersion: string): Promise<void>;
  * 8. If an Obsidian plugin, copies the updated manifest and publishes a GitHub release.
  *
  * @param versionUpdateType - The type of version update to perform (major, minor, patch, premajor, preminor, prepatch, prerelease, or x.y.z[-suffix]).
- * @param prepareGitHubRelease - A callback function to prepare the GitHub release.
+ * @param options - The {@link UpdateVersionOptions} controlling the release behavior.
  * @returns A {@link Promise} that resolves when the version update is complete.
  */
-export declare function updateVersion(versionUpdateType?: string, prepareGitHubRelease?: (newVersion: string) => Promise<void>): Promise<void>;
+export declare function updateVersion(versionUpdateType?: string, options?: UpdateVersionOptions): Promise<void>;
 /**
  * Updates the version in various files, including `package.json`, `package-lock.json`,
  * and Obsidian plugin manifests if applicable.