obsidian-dev-utils 50.0.0 → 51.0.1

package/dist/lib/esm/script-utils/exec.mjs

@@ -0,0 +1,111 @@
+/*
+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() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { getLibDebugger } from "../debug.mjs";
+import { trimEnd } from "../string.mjs";
+import { toCommandLine } from "./cli-utils.mjs";
+import {
+  process,
+  spawn
+} from "./node-modules.mjs";
+function exec(command, options = {}) {
+  const {
+    cwd = process.cwd(),
+    isQuiet: quiet = false,
+    shouldIgnoreExitCode: ignoreExitCode = false,
+    shouldIncludeDetails: withDetails = false,
+    stdin = ""
+  } = options;
+  if (Array.isArray(command)) {
+    command = toCommandLine(command);
+  }
+  return new Promise((resolve, reject) => {
+    getLibDebugger("Exec")(`Executing command: ${command}`);
+    const child = spawn(command, [], {
+      cwd,
+      env: {
+        DEBUG_COLORS: "1",
+        ...process.env
+      },
+      shell: true,
+      stdio: "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdin.write(stdin);
+    child.stdin.end();
+    child.stdout.on("data", (data) => {
+      if (!quiet) {
+        process.stdout.write(data);
+      }
+      stdout += data.toString("utf-8");
+    });
+    child.stdout.on("end", () => {
+      stdout = trimEnd(stdout, "\n");
+    });
+    child.stderr.on("data", (data) => {
+      if (!quiet) {
+        process.stderr.write(data);
+      }
+      stderr += data.toString("utf-8");
+    });
+    child.stderr.on("end", () => {
+      stderr = trimEnd(stderr, "\n");
+    });
+    child.on("close", (exitCode, exitSignal) => {
+      if (exitCode !== 0 && !ignoreExitCode) {
+        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : "(null)"}
+${stderr}`));
+        return;
+      }
+      if (!withDetails) {
+        resolve(stdout);
+        return;
+      }
+      resolve({
+        exitCode,
+        exitSignal,
+        stderr,
+        stdout
+      });
+    });
+    child.on("error", (err) => {
+      if (!ignoreExitCode) {
+        reject(err);
+        return;
+      }
+      if (!withDetails) {
+        resolve(stdout);
+        return;
+      }
+      resolve({
+        exitCode: null,
+        exitSignal: null,
+        stderr,
+        stdout
+      });
+    });
+  });
+}
+export {
+  exec
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/exec.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for executing commands.\n */\n\nimport { getLibDebugger } from '../debug.ts';\nimport { trimEnd } from '../string.ts';\nimport { toCommandLine } from './cli-utils.ts';\nimport {\n  process,\n  spawn\n} from './node-modules.ts';\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOption {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, throws an error if the command fails.\n   */\n  readonly shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `false`, only returns the output of the command.\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  stdout: string;\n}\n\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport async function exec(command: string | string[], options?: { withDetails?: false } & ExecOption): Promise<string>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: string | string[], options: { withDetails: true } & ExecOption): Promise<ExecResult>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: string | string[], options: ExecOption = {}): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails: withDetails = false,\n    stdin = ''\n  } = options;\n  if (Array.isArray(command)) {\n    command = toCommandLine(command);\n  }\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n\n    const child = spawn(command, [], {\n      cwd,\n      env: {\n        DEBUG_COLORS: '1',\n        ...process.env\n      },\n      shell: true,\n      stdio: 'pipe'\n    });\n\n    let stdout = '';\n    let stderr = '';\n\n    child.stdin.write(stdin);\n    child.stdin.end();\n\n    child.stdout.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stdout.write(data);\n      }\n      stdout += data.toString('utf-8');\n    });\n\n    child.stdout.on('end', () => {\n      stdout = trimEnd(stdout, '\\n');\n    });\n\n    child.stderr.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stderr.write(data);\n      }\n      stderr += data.toString('utf-8');\n    });\n\n    child.stderr.on('end', () => {\n      stderr = trimEnd(stderr, '\\n');\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,sBAAsB;AAC/B,SAAS,eAAe;AACxB,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAmGA,SAAS,KAAK,SAA4B,UAAsB,CAAC,GAAiC;AACvG,QAAM;AAAA,IACJ,MAAM,QAAQ,IAAI;AAAA,IAClB,SAAS,QAAQ;AAAA,IACjB,sBAAsB,iBAAiB;AAAA,IACvC,sBAAsB,cAAc;AAAA,IACpC,QAAQ;AAAA,EACV,IAAI;AACJ,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,cAAU,cAAc,OAAO;AAAA,EACjC;AAEA,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,mBAAe,MAAM,EAAE,sBAAsB,OAAO,EAAE;AAEtD,UAAM,QAAQ,MAAM,SAAS,CAAC,GAAG;AAAA,MAC/B;AAAA,MACA,KAAK;AAAA,QACH,cAAc;AAAA,QACd,GAAG,QAAQ;AAAA,MACb;AAAA,MACA,OAAO;AAAA,MACP,OAAO;AAAA,IACT,CAAC;AAED,QAAI,SAAS;AACb,QAAI,SAAS;AAEb,UAAM,MAAM,MAAM,KAAK;AACvB,UAAM,MAAM,IAAI;AAEhB,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAiB;AACxC,UAAI,CAAC,OAAO;AACV,gBAAQ,OAAO,MAAM,IAAI;AAAA,MAC3B;AACA,gBAAU,KAAK,SAAS,OAAO;AAAA,IACjC,CAAC;AAED,UAAM,OAAO,GAAG,OAAO,MAAM;AAC3B,eAAS,QAAQ,QAAQ,IAAI;AAAA,IAC/B,CAAC;AAED,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAiB;AACxC,UAAI,CAAC,OAAO;AACV,gBAAQ,OAAO,MAAM,IAAI;AAAA,MAC3B;AACA,gBAAU,KAAK,SAAS,OAAO;AAAA,IACjC,CAAC;AAED,UAAM,OAAO,GAAG,OAAO,MAAM;AAC3B,eAAS,QAAQ,QAAQ,IAAI;AAAA,IAC/B,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,UAAU,eAAe;AAC1C,UAAI,aAAa,KAAK,CAAC,gBAAgB;AACrC,eAAO,IAAI,MAAM,iCAAiC,WAAW,OAAO,QAAQ,IAAI,QAAQ;AAAA,EAAK,MAAM,EAAE,CAAC;AACtG;AAAA,MACF;AAEA,UAAI,CAAC,aAAa;AAChB,gBAAQ,MAAM;AACd;AAAA,MACF;AACA,cAAQ;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,QAAQ;AACzB,UAAI,CAAC,gBAAgB;AACnB,eAAO,GAAG;AACV;AAAA,MACF;AAEA,UAAI,CAAC,aAAa;AAChB,gBAAQ,MAAM;AACd;AAAA,MACF;AAEA,cAAQ;AAAA,QACN,UAAU;AAAA,QACV,YAAY;AAAA,QACZ;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/script-utils/formatters/dprint.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 initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import {
+  getFolderName,
+  join
+} from "../../path.mjs";
+import { assertNonNullable } from "../../type-guards.mjs";
+import { existsSync } from "../node-modules.mjs";
+import { ObsidianDevUtilsRepoPaths } from "../obsidian-dev-utils-repo-paths.mjs";
+import {
+  execFromRoot,
+  getRootFolder,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+async function format(rewrite = true) {
+  const rootFolder = getRootFolder();
+  assertNonNullable(rootFolder, "Root folder not found");
+  let dprintJsonPath = resolvePathFromRootSafe(ObsidianDevUtilsRepoPaths.DprintJson);
+  if (!existsSync(dprintJsonPath)) {
+    const packageFolder = getRootFolder(getFolderName(import.meta.url));
+    assertNonNullable(packageFolder, "Could not find package folder.");
+    dprintJsonPath = resolvePathFromRootSafe(join(ObsidianDevUtilsRepoPaths.Dist, ObsidianDevUtilsRepoPaths.DprintJson), packageFolder);
+  }
+  if (!existsSync(dprintJsonPath)) {
+    throw new Error("dprint.json not found");
+  }
+  const command = rewrite ? "fmt" : "check";
+  await execFromRoot(["npx", "dprint", command, "--config", dprintJsonPath, "**/*"]);
+}
+export {
+  format
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/formatters/index.d.mts

@@ -0,0 +1 @@
+export * as dprint from './dprint.mjs';

package/dist/lib/esm/script-utils/formatters/index.mjs

@@ -0,0 +1,26 @@
+/*
+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() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import * as dprint from "./dprint.mjs";
+export {
+  dprint
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9mb3JtYXR0ZXJzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgZHByaW50IGZyb20gJy4vZHByaW50LnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLFlBQVksWUFBWTsiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,75 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains utility functions for file system operations.
+ */
+import type { Dirent, ObjectEncodingOptions, PathLike } from './node-modules.mjs';
+/**
+ * Options for controlling the format of the result when returning buffers.
+ *
+ * `directory` is used instead of `folder` to preserve compatibility with `node:fs` module.
+ */
+export type BufferResultOptions = 'buffer' | {
+    /**
+     * Should be set to "buffer" to return buffers.
+     */
+    readonly encoding: 'buffer';
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `false` to return buffers.
+     */
+    readonly withFileTypes?: false;
+};
+/**
+ * Options for controlling the format of the result when returning Dirent objects.
+ */
+export type DirentResultOptions = {
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `true` to return Dirent objects.
+     */
+    readonly withFileTypes: true;
+} & ObjectEncodingOptions;
+/**
+ * Options for controlling the format of the result when returning strings.
+ */
+export type StringResultOptions = {
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `false` to return strings.
+     */
+    readonly withFileTypes?: false;
+} & ObjectEncodingOptions | undefined;
+/**
+ * Reads the contents of a directory and returns an array of strings with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. If not provided, returns strings.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths.
+ */
+export declare function readdirPosix(path: PathLike, options?: StringResultOptions): Promise<string[]>;
+/**
+ * Reads the contents of a directory and returns an array of buffers with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. Specify "buffer" to return buffers.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted buffers.
+ */
+export declare function readdirPosix(path: PathLike, options: BufferResultOptions): Promise<Buffer[]>;
+/**
+ * Reads the contents of a directory and returns an array of Dirent objects with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. Specify `withFileTypes: true` to return Dirent objects.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted Dirent objects.
+ */
+export declare function readdirPosix(path: PathLike, options: DirentResultOptions): Promise<Dirent[]>;

package/dist/lib/esm/script-utils/fs.mjs

@@ -0,0 +1,78 @@
+/*
+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() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import {
+  toPosixBuffer,
+  toPosixPath
+} from "../path.mjs";
+import { readdir } from "./node-modules.mjs";
+async function readdirPosix(path, options = {}) {
+  if (isStringResultOptions(options)) {
+    const paths = await readdir(path, options);
+    return paths.map(toPosixPath);
+  }
+  if (isBufferResultOptions(options)) {
+    const buffers = await readdir(path, options);
+    return buffers.map(toPosixBuffer);
+  }
+  const dirents = await readdir(path, options);
+  for (const dirent of dirents) {
+    dirent.name = toPosixPath(dirent.name);
+    dirent.parentPath = toPosixPath(dirent.parentPath);
+  }
+  return dirents;
+}
+function isBufferResultOptions(options) {
+  if (options === void 0) {
+    return false;
+  }
+  if (options === "buffer") {
+    return true;
+  }
+  const commonOptions = options;
+  if (commonOptions.withFileTypes === true) {
+    return false;
+  }
+  if (commonOptions.encoding !== "buffer") {
+    return false;
+  }
+  return true;
+}
+function isStringResultOptions(options) {
+  if (options === void 0) {
+    return true;
+  }
+  if (options === "buffer") {
+    return false;
+  }
+  const commonOptions = options;
+  if (commonOptions.encoding === "buffer") {
+    return false;
+  }
+  if (commonOptions.withFileTypes === true) {
+    return false;
+  }
+  return true;
+}
+export {
+  readdirPosix
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/fs.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for file system operations.\n */\n\nimport type {\n  Dirent,\n  ObjectEncodingOptions,\n  PathLike\n} from './node-modules.ts';\n\nimport {\n  toPosixBuffer,\n  toPosixPath\n} from '../path.ts';\nimport { readdir } from './node-modules.ts';\n\n/**\n * Options for controlling the format of the result when returning buffers.\n *\n * `directory` is used instead of `folder` to preserve compatibility with `node:fs` module.\n */\nexport type BufferResultOptions = 'buffer' | {\n  /**\n   * Should be set to \"buffer\" to return buffers.\n   */\n  readonly encoding: 'buffer';\n\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `false` to return buffers.\n   */\n  readonly withFileTypes?: false;\n};\n\n/**\n * Options for controlling the format of the result when returning Dirent objects.\n */\nexport type DirentResultOptions = {\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `true` to return Dirent objects.\n   */\n  readonly withFileTypes: true;\n} & ObjectEncodingOptions;\n\n/**\n * Options for controlling the format of the result when returning strings.\n */\nexport type StringResultOptions =\n  | {\n    /**\n     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n     */\n    readonly recursive?: boolean;\n\n    /**\n     * Should be set to `false` to return strings.\n     */\n    readonly withFileTypes?: false;\n  } & ObjectEncodingOptions\n  | undefined;\n\n/**\n * Common options for controlling the format of the result.\n */\ninterface CommonOptions {\n  /**\n   * Encoding to use when returning strings.\n   */\n  readonly encoding?: 'buffer' | NodeJS.BufferEncoding;\n\n  /**\n   * Set `true` to return Dirent objects or `false` to return strings or buffers.\n   */\n  readonly withFileTypes?: boolean;\n}\n\n/**\n * Reads the contents of a directory and returns an array of strings with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. If not provided, returns strings.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths.\n */\nexport async function readdirPosix(path: PathLike, options?: StringResultOptions): Promise<string[]>;\n/**\n * Reads the contents of a directory and returns an array of buffers with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. Specify \"buffer\" to return buffers.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted buffers.\n */\nexport async function readdirPosix(path: PathLike, options: BufferResultOptions): Promise<Buffer[]>;\n/**\n * Reads the contents of a directory and returns an array of Dirent objects with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. Specify `withFileTypes: true` to return Dirent objects.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted Dirent objects.\n */\nexport async function readdirPosix(path: PathLike, options: DirentResultOptions): Promise<Dirent[]>;\n/**\n * Reads the contents of a directory and converts file paths or buffer results to POSIX format.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths, buffers, or Dirent objects.\n */\nexport async function readdirPosix(\n  path: PathLike,\n  options: BufferResultOptions | DirentResultOptions | StringResultOptions = {}\n): Promise<Buffer[] | Dirent[] | string[]> {\n  if (isStringResultOptions(options)) {\n    const paths = await readdir(path, options);\n    return paths.map(toPosixPath);\n  }\n\n  if (isBufferResultOptions(options)) {\n    const buffers = await readdir(path, options);\n    return buffers.map(toPosixBuffer);\n  }\n\n  const dirents = await readdir(path, options);\n  for (const dirent of dirents) {\n    dirent.name = toPosixPath(dirent.name);\n    dirent.parentPath = toPosixPath(dirent.parentPath);\n  }\n\n  return dirents;\n}\n\n/**\n * Type guard to check if the options are for returning buffers.\n *\n * @param options - The options to check.\n * @returns `true` if the options are for returning buffers, otherwise `false`.\n */\nfunction isBufferResultOptions(options: BufferResultOptions | DirentResultOptions | StringResultOptions): options is BufferResultOptions {\n  /* v8 ignore start -- Dead code: readdirPosix defaults options to {}, so undefined never reaches here. */\n  if (options === undefined) {\n    return false;\n  }\n  /* v8 ignore stop */\n\n  if (options === 'buffer') {\n    return true;\n  }\n\n  const commonOptions = options as CommonOptions;\n\n  if (commonOptions.withFileTypes === true) {\n    return false;\n  }\n\n  /* v8 ignore start -- Dead code: isStringResultOptions already handles non-buffer encoding before this is called. */\n  if (commonOptions.encoding !== 'buffer') {\n    return false;\n  }\n  /* v8 ignore stop */\n\n  return true;\n}\n\n/**\n * Type guard to check if the options are for returning strings.\n *\n * @param options - The options to check.\n * @returns `true` if the options are for returning strings, otherwise `false`.\n */\nfunction isStringResultOptions(options: BufferResultOptions | DirentResultOptions | StringResultOptions): options is StringResultOptions {\n  /* v8 ignore start -- Dead code: readdirPosix defaults options to {}, so undefined never reaches here. */\n  if (options === undefined) {\n    return true;\n  }\n  /* v8 ignore stop */\n\n  if (options === 'buffer') {\n    return false;\n  }\n\n  const commonOptions = options as CommonOptions;\n\n  if (commonOptions.encoding === 'buffer') {\n    return false;\n  }\n\n  if (commonOptions.withFileTypes === true) {\n    return false;\n  }\n\n  return true;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAYA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,eAAe;AAsGxB,eAAsB,aACpB,MACA,UAA2E,CAAC,GACnC;AACzC,MAAI,sBAAsB,OAAO,GAAG;AAClC,UAAM,QAAQ,MAAM,QAAQ,MAAM,OAAO;AACzC,WAAO,MAAM,IAAI,WAAW;AAAA,EAC9B;AAEA,MAAI,sBAAsB,OAAO,GAAG;AAClC,UAAM,UAAU,MAAM,QAAQ,MAAM,OAAO;AAC3C,WAAO,QAAQ,IAAI,aAAa;AAAA,EAClC;AAEA,QAAM,UAAU,MAAM,QAAQ,MAAM,OAAO;AAC3C,aAAW,UAAU,SAAS;AAC5B,WAAO,OAAO,YAAY,OAAO,IAAI;AACrC,WAAO,aAAa,YAAY,OAAO,UAAU;AAAA,EACnD;AAEA,SAAO;AACT;AAQA,SAAS,sBAAsB,SAA0G;AAEvI,MAAI,YAAY,QAAW;AACzB,WAAO;AAAA,EACT;AAGA,MAAI,YAAY,UAAU;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAEtB,MAAI,cAAc,kBAAkB,MAAM;AACxC,WAAO;AAAA,EACT;AAGA,MAAI,cAAc,aAAa,UAAU;AACvC,WAAO;AAAA,EACT;AAGA,SAAO;AACT;AAQA,SAAS,sBAAsB,SAA0G;AAEvI,MAAI,YAAY,QAAW;AACzB,WAAO;AAAA,EACT;AAGA,MAAI,YAAY,UAAU;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAEtB,MAAI,cAAc,aAAa,UAAU;AACvC,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,kBAAkB,MAAM;AACxC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": []
}


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

@@ -0,0 +1,18 @@
+export * as build from './build.mjs';
+export * as bundlers from './bundlers/index.mjs';
+export * as cli_utils from './cli-utils.mjs';
+export * as code_generator from './code-generator.mjs';
+export * as exec from './exec.mjs';
+export * as formatters from './formatters/index.mjs';
+export * as fs from './fs.mjs';
+export * as json from './json.mjs';
+export * as linters from './linters/index.mjs';
+export * as node_modules from './node-modules.mjs';
+export * as npm_publish from './npm-publish.mjs';
+export * as npm_run from './npm-run.mjs';
+export * as npm from './npm.mjs';
+export * as obsidian_cli from './obsidian-cli.mjs';
+export * as obsidian_dev_utils_repo_paths from './obsidian-dev-utils-repo-paths.mjs';
+export * as root from './root.mjs';
+export * as test_runners from './test-runners/index.mjs';
+export * as version from './version.mjs';

package/dist/lib/esm/script-utils/index.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 initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import * as build from "./build.mjs";
+import * as bundlers from "./bundlers/index.mjs";
+import * as cli_utils from "./cli-utils.mjs";
+import * as code_generator from "./code-generator.mjs";
+import * as exec from "./exec.mjs";
+import * as formatters from "./formatters/index.mjs";
+import * as fs from "./fs.mjs";
+import * as json from "./json.mjs";
+import * as linters from "./linters/index.mjs";
+import * as node_modules from "./node-modules.mjs";
+import * as npm_publish from "./npm-publish.mjs";
+import * as npm_run from "./npm-run.mjs";
+import * as npm from "./npm.mjs";
+import * as obsidian_cli from "./obsidian-cli.mjs";
+import * as obsidian_dev_utils_repo_paths from "./obsidian-dev-utils-repo-paths.mjs";
+import * as root from "./root.mjs";
+import * as test_runners from "./test-runners/index.mjs";
+import * as version from "./version.mjs";
+export {
+  build,
+  bundlers,
+  cli_utils,
+  code_generator,
+  exec,
+  formatters,
+  fs,
+  json,
+  linters,
+  node_modules,
+  npm,
+  npm_publish,
+  npm_run,
+  obsidian_cli,
+  obsidian_dev_utils_repo_paths,
+  root,
+  test_runners,
+  version
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzIGJ1aWxkIGZyb20gJy4vYnVpbGQudHMnO1xuZXhwb3J0ICogYXMgYnVuZGxlcnMgZnJvbSAnLi9idW5kbGVycy9pbmRleC50cyc7XG5leHBvcnQgKiBhcyBjbGlfdXRpbHMgZnJvbSAnLi9jbGktdXRpbHMudHMnO1xuZXhwb3J0ICogYXMgY29kZV9nZW5lcmF0b3IgZnJvbSAnLi9jb2RlLWdlbmVyYXRvci50cyc7XG5leHBvcnQgKiBhcyBleGVjIGZyb20gJy4vZXhlYy50cyc7XG5leHBvcnQgKiBhcyBmb3JtYXR0ZXJzIGZyb20gJy4vZm9ybWF0dGVycy9pbmRleC50cyc7XG5leHBvcnQgKiBhcyBmcyBmcm9tICcuL2ZzLnRzJztcbmV4cG9ydCAqIGFzIGpzb24gZnJvbSAnLi9qc29uLnRzJztcbmV4cG9ydCAqIGFzIGxpbnRlcnMgZnJvbSAnLi9saW50ZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzIG5vZGVfbW9kdWxlcyBmcm9tICcuL25vZGUtbW9kdWxlcy50cyc7XG5leHBvcnQgKiBhcyBucG1fcHVibGlzaCBmcm9tICcuL25wbS1wdWJsaXNoLnRzJztcbmV4cG9ydCAqIGFzIG5wbV9ydW4gZnJvbSAnLi9ucG0tcnVuLnRzJztcbmV4cG9ydCAqIGFzIG5wbSBmcm9tICcuL25wbS50cyc7XG5leHBvcnQgKiBhcyBvYnNpZGlhbl9jbGkgZnJvbSAnLi9vYnNpZGlhbi1jbGkudHMnO1xuZXhwb3J0ICogYXMgb2JzaWRpYW5fZGV2X3V0aWxzX3JlcG9fcGF0aHMgZnJvbSAnLi9vYnNpZGlhbi1kZXYtdXRpbHMtcmVwby1wYXRocy50cyc7XG5leHBvcnQgKiBhcyByb290IGZyb20gJy4vcm9vdC50cyc7XG5leHBvcnQgKiBhcyB0ZXN0X3J1bm5lcnMgZnJvbSAnLi90ZXN0LXJ1bm5lcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgdmVyc2lvbiBmcm9tICcuL3ZlcnNpb24udHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsWUFBWSxXQUFXO0FBQ3ZCLFlBQVksY0FBYztBQUMxQixZQUFZLGVBQWU7QUFDM0IsWUFBWSxvQkFBb0I7QUFDaEMsWUFBWSxVQUFVO0FBQ3RCLFlBQVksZ0JBQWdCO0FBQzVCLFlBQVksUUFBUTtBQUNwQixZQUFZLFVBQVU7QUFDdEIsWUFBWSxhQUFhO0FBQ3pCLFlBQVksa0JBQWtCO0FBQzlCLFlBQVksaUJBQWlCO0FBQzdCLFlBQVksYUFBYTtBQUN6QixZQUFZLFNBQVM7QUFDckIsWUFBWSxrQkFBa0I7QUFDOUIsWUFBWSxtQ0FBbUM7QUFDL0MsWUFBWSxVQUFVO0FBQ3RCLFlBQVksa0JBQWtCO0FBQzlCLFlBQVksYUFBYTsiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,65 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains utility functions for JSON.
+ */
+import type { Promisable } from 'type-fest';
+/**
+ * Options for {@link editJson}.
+ */
+export interface EditJsonOptions {
+    /**
+     * If `true`, skips editing if the file does not exist.
+     */
+    readonly shouldSkipIfMissing?: boolean;
+}
+/**
+ * Reads, edits, and writes back a JSON file using a provided edit function.
+ *
+ * @typeParam T - The type of the data to be edited.
+ * @param path - The path to the JSON file.
+ * @param editFn - The function to edit the parsed JSON data.
+ * @param options - Additional options for editing.
+ * @returns A {@link Promise} that resolves when the file has been edited and written.
+ */
+export declare function editJson<T>(path: string, editFn: (data: T) => Promisable<void>, options?: EditJsonOptions): Promise<void>;
+/**
+ * Reads, edits, and writes back a JSON file using a provided edit function.
+ *
+ * @typeParam T - The type of the data to be edited.
+ * @param path - The path to the JSON file.
+ * @param editFn - The function to edit the parsed JSON data.
+ * @param options - Additional options for editing.
+ */
+export declare function editJsonSync<T>(path: string, editFn: (data: T) => void, options?: EditJsonOptions): void;
+/**
+ * Reads a JSON file and parses its contents into a JavaScript object of type `T`.
+ *
+ * @typeParam T - The type to which the JSON content will be parsed.
+ * @param path - The path to the JSON file.
+ * @returns A {@link Promise} that resolves with the parsed JSON object of type `T`.
+ */
+export declare function readJson<T>(path: string): Promise<T>;
+/**
+ * Reads a JSON file and parses its contents into a JavaScript object of type `T`.
+ *
+ * @typeParam T - The type to which the JSON content will be parsed.
+ * @param path - The path to the JSON file.
+ * @returns The parsed JSON object of type `T`.
+ */
+export declare function readJsonSync<T>(path: string): T;
+/**
+ * Writes a JavaScript object to a JSON file.
+ *
+ * @param path - The path to the JSON file.
+ * @param data - The data to write to the JSON file.
+ * @returns A {@link Promise} that resolves when the file has been written.
+ */
+export declare function writeJson(path: string, data: unknown): Promise<void>;
+/**
+ * Writes a JavaScript object to a JSON file.
+ *
+ * @param path - The path to the JSON file.
+ * @param data - The data to write to the JSON file.
+ */
+export declare function writeJsonSync(path: string, data: unknown): void;

package/dist/lib/esm/script-utils/json.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 initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { toJson } from "../object-utils.mjs";
+import {
+  existsSync,
+  readFile,
+  readFileSync,
+  writeFile,
+  writeFileSync
+} from "./node-modules.mjs";
+async function editJson(path, editFn, options = {}) {
+  const {
+    shouldSkipIfMissing
+  } = options;
+  if (shouldSkipIfMissing && !existsSync(path)) {
+    return;
+  }
+  const data = await readJson(path);
+  await editFn(data);
+  await writeJson(path, data);
+}
+function editJsonSync(path, editFn, options = {}) {
+  const {
+    shouldSkipIfMissing
+  } = options;
+  if (shouldSkipIfMissing && !existsSync(path)) {
+    return;
+  }
+  const data = readJsonSync(path);
+  editFn(data);
+  writeJsonSync(path, data);
+}
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf-8"));
+}
+function readJsonSync(path) {
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+async function writeJson(path, data) {
+  await writeFile(path, `${toJson(data)}
+`);
+}
+function writeJsonSync(path, data) {
+  writeFileSync(path, `${toJson(data)}
+`);
+}
+export {
+  editJson,
+  editJsonSync,
+  readJson,
+  readJsonSync,
+  writeJson,
+  writeJsonSync
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/linters/cspell.mjs

@@ -0,0 +1,29 @@
+/*
+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() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { execFromRoot } from "../root.mjs";
+async function spellcheck() {
+  await execFromRoot("npx cspell . --no-progress");
+}
+export {
+  spellcheck
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9saW50ZXJzL2NzcGVsbC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqXG4gKiBUaGlzIG1vZHVsZSBwcm92aWRlcyBhIGZ1bmN0aW9uIGZvciBydW5uaW5nIGEgc3BlbGxjaGVjayBvbiB0aGUgY29kZWJhc2UgdXNpbmcgdGhlIGBjc3BlbGxgIGxpYnJhcnkuXG4gKiBJdCByZXBvcnRzIGFueSBzcGVsbGluZyBpc3N1ZXMgZm91bmQgaW4gdGhlIGNvZGUgYW5kIHJldHVybnMgYSB7QGxpbmsgQ2xpVGFza1Jlc3VsdH0gaW5kaWNhdGluZyB3aGV0aGVyIHRoZSBzcGVsbGNoZWNrIHdhcyBzdWNjZXNzZnVsLlxuICovXG5cbmltcG9ydCB7IGV4ZWNGcm9tUm9vdCB9IGZyb20gJy4uL3Jvb3QudHMnO1xuXG4vKipcbiAqIFJ1bnMgYSBzcGVsbGNoZWNrIG9uIHRoZSBlbnRpcmUgY29kZWJhc2UgdXNpbmcgYGNzcGVsbGAuXG4gKlxuICogQ2hlY2tzIGFsbCBmaWxlcyBpbiB0aGUgY3VycmVudCBmb2xkZXIgYW5kIGl0cyBzdWJmb2xkZXJzIGZvciBzcGVsbGluZyBpc3N1ZXMuXG4gKiBJZiBpc3N1ZXMgYXJlIGZvdW5kLCB0aGV5IGFyZSBsb2dnZWQgdG8gdGhlIGNvbnNvbGUgd2l0aCB0aGVpciBmaWxlIHBhdGgsIGxpbmUsIGFuZCBjb2x1bW4gbnVtYmVyLlxuICpcbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gYSB7QGxpbmsgQ2xpVGFza1Jlc3VsdH0sIGluZGljYXRpbmcgdGhlIHN1Y2Nlc3Mgb3IgZmFpbHVyZSBvZiB0aGUgc3BlbGxjaGVjay5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHNwZWxsY2hlY2soKTogUHJvbWlzZTx2b2lkPiB7XG4gIGF3YWl0IGV4ZWNGcm9tUm9vdCgnbnB4IGNzcGVsbCAuIC0tbm8tcHJvZ3Jlc3MnKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQU9BLFNBQVMsb0JBQW9CO0FBVTdCLGVBQXNCLGFBQTRCO0FBQ2hELFFBQU0sYUFBYSw0QkFBNEI7QUFDakQ7IiwKICAibmFtZXMiOiBbXQp9Cg==