@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.0.0

package/assets/docs-site/components/ConstructorBlock.astro

@@ -0,0 +1,16 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+interface Props {
+  description?: string;
+  signature: string;
+}
+
+const { signature, description } = Astro.props;
+---
+
+<div class="filterable-block" data-inherited="false">
+  <h2><span class="icon-own" title="Defined on this type"></span> Constructor</h2>
+  <Code code={signature} lang="ts" />
+  {description && <p set:html={description} />}
+</div>

package/assets/docs-site/components/ImportStatement.astro

@@ -0,0 +1,12 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+interface Props {
+  text: string;
+}
+
+const { text } = Astro.props;
+---
+
+<p><strong>Import:</strong></p>
+<Code code={text} lang="ts" />

package/assets/docs-site/components/MemberDetail.astro

@@ -0,0 +1,101 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+/** A rendered API parameter. */
+interface ParameterInfo {
+  description: string;
+  name: string;
+  type: string;
+}
+
+interface Props {
+  description?: string;
+  examples?: string[];
+  parameters?: ParameterInfo[];
+  remarks?: string;
+  returnDescription?: string;
+  returnType?: string;
+  signature?: string;
+  since?: string;
+  type?: string;
+}
+
+const {
+  type,
+  description,
+  signature,
+  parameters = [],
+  returnType,
+  returnDescription,
+  remarks,
+  examples = [],
+  since
+} = Astro.props;
+
+/** Strip markdown code fence markers and extract language + code */
+function parseCodeFence(raw: string): { code: string; lang: string } {
+  const match = /^```(\w*)\n([\s\S]*?)(?:\n```)?$/.exec(raw.trim());
+  if (match) {
+    return { code: match[2]?.trimEnd() ?? '', lang: match[1] || 'ts' };
+  }
+  return { code: raw.trim(), lang: 'ts' };
+}
+const parsedExamples = examples.map(parseCodeFence);
+---
+
+{type && <p><strong>Type:</strong> <span set:html={type} /></p>}
+
+{description && <Fragment set:html={description} />}
+
+{signature && (
+  <>
+    <p><strong>Signature:</strong></p>
+    <Code code={signature} lang="ts" />
+  </>
+)}
+
+{parameters.length > 0 && (
+  <>
+    <p><strong>Parameters:</strong></p>
+    <table>
+      <thead>
+        <tr>
+          <th style="text-align: left">Parameter</th>
+          <th style="text-align: left">Type</th>
+          <th style="text-align: left">Description</th>
+        </tr>
+      </thead>
+      <tbody>
+        {parameters.map((param) => (
+          <tr>
+            <td style="text-align: left">{param.name}</td>
+            <td style="text-align: left" set:html={param.type} />
+            <td style="text-align: left" set:html={param.description} />
+          </tr>
+        ))}
+      </tbody>
+    </table>
+  </>
+)}
+
+{returnType && (
+  <p><strong>Returns:</strong> <span set:html={returnType} />
+    {returnDescription && <> — <span set:html={returnDescription} /></>}
+  </p>
+)}
+
+{since && <p><strong>Since:</strong> {since}</p>}
+
+{remarks && (
+  <>
+    <p><strong>Remarks:</strong></p>
+    <Fragment set:html={remarks} />
+  </>
+)}
+
+{parsedExamples.map(({ code, lang }) => (
+  <>
+    <p><strong>Example:</strong></p>
+    <Code code={code} lang={lang} />
+  </>
+))}

package/assets/docs-site/components/MethodTable.astro

@@ -0,0 +1,45 @@
+---
+interface MethodRow {
+  description: string;
+  href: string;
+  inheritedFrom?: string;
+  returns: string;
+  signature: string;
+}
+
+interface Props {
+  rows: MethodRow[];
+}
+
+const { rows } = Astro.props;
+---
+
+<h2>Methods</h2>
+<table>
+  <colgroup>
+    <col style="width: 20%" />
+    <col style="width: 30%" />
+    <col style="width: 50%" />
+  </colgroup>
+  <thead>
+    <tr>
+      <th style="text-align: left">Method</th>
+      <th style="text-align: left">Returns</th>
+      <th style="text-align: left">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    {rows.map((row) => {
+      const inherited = row.inheritedFrom
+        ? `<br/><em>(Inherited from ${row.inheritedFrom})</em>`
+        : '';
+      return (
+        <tr>
+          <td style="text-align: left">{row.href ? <a href={row.href} set:html={row.signature} /> : <span set:html={row.signature} />}</td>
+          <td style="text-align: left" set:html={row.returns} />
+          <td style="text-align: left" set:html={row.description + inherited} />
+        </tr>
+      );
+    })}
+  </tbody>
+</table>

package/assets/docs-site/components/PropertyTable.astro

@@ -0,0 +1,45 @@
+---
+interface PropertyRow {
+  description: string;
+  href: string;
+  inheritedFrom?: string;
+  name: string;
+  type: string;
+}
+
+interface Props {
+  rows: PropertyRow[];
+}
+
+const { rows } = Astro.props;
+---
+
+<h2>Properties</h2>
+<table>
+  <colgroup>
+    <col style="width: 20%" />
+    <col style="width: 30%" />
+    <col style="width: 50%" />
+  </colgroup>
+  <thead>
+    <tr>
+      <th style="text-align: left">Property</th>
+      <th style="text-align: left">Type</th>
+      <th style="text-align: left">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    {rows.map((row) => {
+      const inherited = row.inheritedFrom
+        ? `<br/><em>(Inherited from ${row.inheritedFrom})</em>`
+        : '';
+      return (
+        <tr>
+          <td style="text-align: left">{row.href ? <a href={row.href}>{row.name}</a> : row.name}</td>
+          <td style="text-align: left" set:html={row.type} />
+          <td style="text-align: left" set:html={row.description + inherited} />
+        </tr>
+      );
+    })}
+  </tbody>
+</table>

package/assets/docs-site/components/SiteTitle.astro

@@ -0,0 +1,43 @@
+---
+/**
+ * Site-title override: renders the title Starlight passes in, plus the documented package's version as an
+ * always-visible badge. `defineDocsSiteConfig` reads the version from the site's root package.json and defines it
+ * as `import.meta.env.DOCS_SITE_PACKAGE_VERSION`.
+ */
+const { siteTitle, siteTitleHref } = Astro.locals.starlightRoute;
+const version = `v${import.meta.env.DOCS_SITE_PACKAGE_VERSION}`;
+---
+
+<a href={siteTitleHref} class="site-title sl-flex">
+	<span translate="no">{siteTitle}</span>
+	<span class="site-version" translate="no">{version}</span>
+</a>
+
+<style>
+	@layer starlight.core {
+		.site-title {
+			align-items: center;
+			gap: 0.5rem;
+			font-size: var(--sl-text-h4);
+			font-weight: 600;
+			color: var(--sl-color-text-accent);
+			text-decoration: none;
+			white-space: nowrap;
+			min-width: 0;
+		}
+		span:first-child {
+			overflow: hidden;
+			text-overflow: ellipsis;
+		}
+		.site-version {
+			flex: none;
+			font-size: var(--sl-text-xs);
+			font-weight: 500;
+			line-height: 1.5;
+			color: var(--sl-color-gray-1);
+			background: var(--sl-color-gray-6);
+			padding: 0.05rem 0.45rem;
+			border-radius: 999px;
+		}
+	}
+</style>

package/assets/docs-site/components/TypeSignature.astro

@@ -0,0 +1,20 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+interface Props {
+  extends?: string[];
+  implements?: string[];
+  kind: 'class' | 'interface';
+  name: string;
+  typeParams?: string[];
+}
+
+const { kind, name, typeParams = [], extends: baseTypes = [], implements: implTypes = [] } = Astro.props;
+const typeParamsStr = typeParams.length > 0 ? `<${typeParams.join(', ')}>` : '';
+const extendsClause = baseTypes.length > 0 ? ` extends ${baseTypes.join(', ')}` : '';
+const implementsClause = implTypes.length > 0 ? ` implements ${implTypes.join(', ')}` : '';
+const signature = `export ${kind} ${name}${typeParamsStr}${extendsClause}${implementsClause}`;
+---
+
+<p><strong>Signature:</strong></p>
+<Code code={signature} lang="ts" />

package/assets/docs-site/styles/global.css

@@ -0,0 +1,221 @@
+:root {
+    --icon-size-med: 20px;
+
+    .starlight-aside--todo {
+        --sl-color-asides-text-accent: var(--sl-color-red-high);
+        --sl-color-asides-border: var(--sl-color-red);
+        background-color: var(--sl-color-red-low);
+    }
+}
+
+:root[data-theme='dark'] {
+    --sl-color-accent-high: hsl(255, 92%, 82%);
+    --sl-color-accent: hsl(258, 85%, 68%);
+    --sl-color-accent-low: hsl(260, 42%, 38%);
+    --sl-hero-color: hsla(258, 85%, 68%, 30%);
+
+    .starlight-aside--tutorial {
+        --sl-color-asides-text-accent: #157AFF;
+        --sl-color-asides-border: #21385a;
+        background-color: #1e314c;
+    }
+
+    .starlight-aside--remark {
+        --sl-color-asides-text-accent: #ea9f52;
+        --sl-color-asides-border: #af6b32;
+        background-color: #302418;
+    }
+
+    .starlight-aside--todo {
+        --sl-color-asides-text-accent: #d2c7ff;
+        --sl-color-asides-border: #291761;
+        background-color: #321c81;
+    }
+
+    .starlight-aside--note {
+        --sl-color-asides-text-accent: #85d4da;
+        --sl-color-asides-border: #5eb5bd;
+        background-color: #416263;
+    }
+}
+
+:root[data-theme='light'] {
+    --sl-color-accent-high: hsl(260, 55%, 32%);
+    --sl-color-accent: hsl(258, 66%, 55%);
+    --sl-color-accent-low: hsl(256, 82%, 84%);
+    --sl-hero-color: hsla(258, 66%, 55%, 25%);
+
+    .starlight-aside--tutorial {
+        --sl-color-asides-text-accent: #086DDD;
+        --sl-color-asides-border: #1e5a97;
+        background-color: #E6F0FB;
+    }
+
+    .starlight-aside--remark {
+        --sl-color-asides-text-accent: #EC7500;
+        --sl-color-asides-border: #7a390c;
+        background-color: #ffead5;
+    }
+
+    .starlight-aside--todo {
+        --sl-color-asides-text-accent: #6844dc;
+        --sl-color-asides-border: #5f3ad6;
+        background-color: #ddd5f8;
+    }
+
+    .starlight-aside--note {
+        --sl-color-asides-text-accent: #0d9a99;
+        --sl-color-asides-border: #21a6a5;
+        background-color: #cdeded;
+    }
+}
+
+/* Prevent horizontal scroll on mobile — any overflowing element (tables, code blocks,
+   long type names) is clipped at the page level. Individual containers like tables still
+   scroll horizontally via their own overflow:auto. Using `clip` instead of `hidden` avoids
+   creating a new scroll container. */
+html,
+body {
+    overflow-x: clip;
+}
+
+/* Widen content area for API reference tables */
+:root {
+    --sl-content-width: 65rem;
+    --sl-content-pad-x: 1rem;
+}
+
+/* Ensure long content scrolls horizontally within its container on mobile */
+.sl-markdown-content pre {
+    overflow-x: auto;
+}
+
+/* API reference tables */
+.sl-markdown-content table {
+    width: 100%;
+    display: block;
+    overflow-x: auto;
+}
+
+.sl-markdown-content table th,
+.sl-markdown-content table td {
+    text-align: left;
+}
+
+/* Hide graph view on API pages — not useful for reference docs */
+.slsg-graph-panel { /* cspell:disable-line */
+    display: none;
+}
+
+.group-label {
+    text-transform: none;
+}
+
+
+/* Hero style */
+[data-has-hero] .page {
+    height: 100%;
+    background:
+        linear-gradient(215deg, var(--sl-hero-color), transparent 40%),
+        radial-gradient(var(--sl-hero-color), transparent 40%) no-repeat -80vw -70vh / 150vw 200vh,
+        radial-gradient(var(--sl-hero-color), transparent 65%) no-repeat 50% calc(100% + 20rem) /
+			150rem 30rem;
+}
+
+[data-has-hero] header {
+    border-bottom: 1px solid transparent;
+    background-color: transparent;
+    -webkit-backdrop-filter: blur(16px);
+    backdrop-filter: blur(16px);
+}
+
+
+[data-has-hero] .hero > img {
+    filter: drop-shadow(0 0 3rem var(--sl-hero-color));
+}
+
+
+.svg-embed {
+    display: flex;
+}
+
+.starlight-aside {
+    --sl-color-asides-text-accent: var(--sl-color-red-high);
+    --sl-color-asides-border: var(--sl-color-red);
+    background-color: var(--sl-color-red-low);
+    border-radius: 8px;
+    border: unset;
+
+    .starlight-aside__content:has(hr) {
+        display: none;
+    }
+
+    svg {
+        width: var(--icon-size-med);
+        height: var(--icon-size-med);
+    }
+}
+
+.sl-separator {
+    display: flex;
+}
+
+.sl-separator:after {
+    content: "";
+    height: 2rem;
+    border-inline-end: 1px solid var(--sl-color-gray-5);
+}
+
+.obsidian-docs-link {
+    text-decoration: none;
+    color: var(--sl-color-accent);
+    font-weight: 600;
+    padding: 0 8px;
+}
+
+.code-location-icon {
+    display: flex;
+    margin-left: auto;
+}
+
+.code-location-text {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.5rem;
+    justify-content: flex-end;
+}
+
+h3, h4, h5 {
+    display: flex;
+}
+
+
+.content-badge {
+    color: white;
+    background-color: var(--badge-color, var(--sl-color-accent));
+    border-radius: 4px;
+    padding: 0.1rem 0.25rem;
+    font-weight: 800;
+    font-size: 0.75rem;
+}
+
+.content-badge--devtools {
+    --badge-color: var(--sl-color-accent);
+}
+.content-badge--css {
+    --badge-color: var(--sl-color-red);
+}
+.content-badge--js {
+    --badge-color: var(--sl-color-purple);
+}
+.content-badge--electron {
+    --badge-color: var(--sl-color-orange);
+}
+.content-badge--html {
+    --badge-color: var(--sl-color-blue);
+}
+
+.content-badge--warning {
+    --badge-color: var(--sl-color-red);
+}

package/dist/lib/cjs/build.cjs

@@ -166,4 +166,4 @@ function shouldKeepProjectFile(params) {
   buildCompileTypeScript,
   buildTemplates
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/build.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides utility functions to handle the build process for static assets and cleaning\n * the build output folder. It includes functions to copy static files to the distribution folder\n * and to remove the existing build output.\n */\n\nimport type {\n  PackageJson,\n  TsConfigJson\n} from 'type-fest';\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { trimStart } from '@mnaoumov/typescript-lib/string';\nimport {\n  cp,\n  glob,\n  rm\n} from 'node:fs/promises';\n\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { readdirPosix } from './fs.ts';\nimport { readJson } from './json.ts';\nimport {\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { readPackageJson } from './npm.ts';\nimport { resolveToolCommand } from './package-manager.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Removes the distribution folder and its contents.\n *\n * This function deletes the entire distribution folder to ensure a clean build environment.\n *\n * @returns A {@link Promise} that resolves when the folder has been removed.\n */\nexport async function buildClean(): Promise<void> {\n  await rm(RepoPaths.Dist, { force: true, recursive: true });\n}\n\n/**\n * Compiles the code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompile(): Promise<void> {\n  if (await npmRunOptional('build:compile:svelte') === NpmRunOptionalResult.Skipped) {\n    await buildCompileSvelte();\n  }\n  if (await npmRunOptional('build:compile:typescript') === NpmRunOptionalResult.Skipped) {\n    await buildCompileTypeScript();\n  }\n}\n\n/**\n * Compiles the Svelte code.\n *\n * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig\n * `include` patterns and filtering that list would never match: `include` lists TypeScript globs\n * (`./src/**\\/*.ts`, …), so no `.svelte` path can ever appear in it and the check would always be skipped.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project has Svelte files but does not declare `svelte-check`.\n */\nexport async function buildCompileSvelte(): Promise<void> {\n  const tsConfigPath = resolvePathFromRootSafe({ path: RepoPaths.TsConfigJson });\n  const tsConfig = await readJson<TsConfigJson>(tsConfigPath);\n  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {\n    cwd: resolvePathFromRootSafe({ path: RepoPaths.CurrentFolder }),\n    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]\n  }));\n\n  const [firstSvelteFile] = svelteFiles;\n\n  if (firstSvelteFile === undefined) {\n    getLibDebugger('build:buildCompileSvelte')('No Svelte files found in the project, skipping Svelte compilation');\n    return;\n  }\n\n  const packageJson = await readPackageJson();\n\n  if (!checkSvelteCheckDeclared(packageJson)) {\n    throw new Error(\n      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \\`${SVELTE_CHECK_PACKAGE_NAME}\\` is not declared in package.json.`\n        + ` Add \\`${SVELTE_CHECK_PACKAGE_NAME}\\` as a devDependency to type-check the Svelte code.`\n    );\n  }\n\n  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), '--tsconfig', RepoPaths.TsConfigJson]);\n}\n\n/**\n * Compiles the TypeScript code.\n *\n * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does\n * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}\n * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the\n * files we own, so the declarations we author are still fully validated.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project's own declarations fail validation.\n */\nexport async function buildCompileTypeScript(): Promise<void> {\n  await execFromRoot([...resolveToolCommand({ tool: 'tsc' }), '--build', '--force']);\n\n  if (!areProjectTypesValid()) {\n    throw new Error('TypeScript declaration validation failed.');\n  }\n}\n\n/**\n * Copies all template files from the templates folder to the `templates` folder within the\n * distribution folder.\n *\n * This function recursively reads the contents of the templates folder and copies each file to the\n * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the\n * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source\n * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as\n * `eslint.config.mts`), so an active config template can live in the repo under a name that the\n * corresponding tool does not auto-discover.\n *\n * @returns A {@link Promise} that resolves when all files have been copied.\n */\nexport async function buildTemplates(): Promise<void> {\n  for (const dirent of await readdirPosix(RepoPaths.Templates, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = trimStart({\n      $string: join(dirent.parentPath, dirent.name),\n      prefix: `${RepoPaths.Templates}/`\n    });\n    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;\n    await cp(join(RepoPaths.Templates, path), join(RepoPaths.DistTemplates, destinationPath));\n  }\n}\n\nconst TEMPLATE_FILE_SUFFIX = '.template';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\n\nconst SVELTE_CHECK_PACKAGE_NAME = 'svelte-check';\n\nconst SVELTE_FILE_PATTERNS = [\n  `${RepoPaths.AnyPath}/*.svelte`,\n  `${RepoPaths.AnyPath}/*.svelte.js`,\n  `${RepoPaths.AnyPath}/*.svelte.ts`\n];\n\n/**\n * `node_modules` must be listed explicitly: a tsconfig that sets `exclude` at all **replaces** TypeScript's\n * default `node_modules` exclusion, so it cannot be relied on to keep dependencies out of the glob.\n */\nconst SVELTE_FILE_EXCLUDE_PATTERNS = [\n  `${RepoPaths.AnyPath}/${RepoPaths.NodeModules}/${RepoPaths.AnyPath}`,\n  `${RepoPaths.AnyPath}/${RepoPaths.Dist}/${RepoPaths.AnyPath}`\n];\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Re-runs the project type-check in-memory with `skipLibCheck: false`, reporting only diagnostics\n * whose source file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @returns `true` when the project's own files have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nfunction areProjectTypesValid(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n  const { fileNames, options } = parseTsConfig(join(root, RepoPaths.TsConfigJson));\n\n  return checkProjectTypes({\n    options,\n    rootNames: fileNames,\n    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n  });\n}\n\n/**\n * Determines whether the project declares `svelte-check`.\n *\n * The declaration is read from `package.json` rather than probed in `node_modules/.bin`, because\n * {@link resolveToolCommand} deliberately falls back to the package manager's exec form for tools that have\n * no bin shim — the only way a locally installed tool resolves under yarn PnP. Treating a missing shim as a\n * missing tool would therefore break PnP projects.\n *\n * @param packageJson - The project's parsed `package.json`.\n * @returns `true` when `svelte-check` is declared as a regular, dev, or peer dependency.\n */\nfunction checkSvelteCheckDeclared(packageJson: PackageJson): boolean {\n  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies]\n    .some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== undefined);\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/build.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides utility functions to handle the build process for static assets and cleaning\n * the build output folder. It includes functions to copy static files to the distribution folder\n * and to remove the existing build output.\n */\n\nimport type {\n  PackageJson,\n  TsConfigJson\n} from 'type-fest';\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { trimStart } from '@mnaoumov/typescript-lib/string';\nimport {\n  cp,\n  glob,\n  rm\n} from 'node:fs/promises';\n\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { readdirPosix } from './fs.ts';\nimport { readJson } from './json.ts';\nimport {\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { readPackageJson } from './npm.ts';\nimport { resolveToolCommand } from './package-manager.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Removes the distribution folder and its contents.\n *\n * This function deletes the entire distribution folder to ensure a clean build environment.\n *\n * @returns A {@link Promise} that resolves when the folder has been removed.\n */\nexport async function buildClean(): Promise<void> {\n  await rm(RepoPaths.Dist, { force: true, recursive: true });\n}\n\n/**\n * Compiles the code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompile(): Promise<void> {\n  if (await npmRunOptional('build:compile:svelte') === NpmRunOptionalResult.Skipped) {\n    await buildCompileSvelte();\n  }\n  if (await npmRunOptional('build:compile:typescript') === NpmRunOptionalResult.Skipped) {\n    await buildCompileTypeScript();\n  }\n}\n\n/**\n * Compiles the Svelte code.\n *\n * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig\n * `include` patterns and filtering that list would never match: `include` lists TypeScript globs\n * (`./src/**\\/*.ts`, …), so no `.svelte` path can ever appear in it and the check would always be skipped.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project has Svelte files but does not declare `svelte-check`.\n */\nexport async function buildCompileSvelte(): Promise<void> {\n  const tsConfigPath = resolvePathFromRootSafe({ path: RepoPaths.TsConfigJson });\n  const tsConfig = await readJson<TsConfigJson>(tsConfigPath);\n  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {\n    cwd: resolvePathFromRootSafe({ path: RepoPaths.CurrentFolder }),\n    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]\n  }));\n\n  const [firstSvelteFile] = svelteFiles;\n\n  if (firstSvelteFile === undefined) {\n    getLibDebugger('build:buildCompileSvelte')('No Svelte files found in the project, skipping Svelte compilation');\n    return;\n  }\n\n  const packageJson = await readPackageJson();\n\n  if (!checkSvelteCheckDeclared(packageJson)) {\n    throw new Error(\n      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \\`${SVELTE_CHECK_PACKAGE_NAME}\\` is not declared in package.json.`\n        + ` Add \\`${SVELTE_CHECK_PACKAGE_NAME}\\` as a devDependency to type-check the Svelte code.`\n    );\n  }\n\n  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), '--tsconfig', RepoPaths.TsConfigJson]);\n}\n\n/**\n * Compiles the TypeScript code.\n *\n * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does\n * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}\n * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the\n * files we own, so the declarations we author are still fully validated.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project's own declarations fail validation.\n */\nexport async function buildCompileTypeScript(): Promise<void> {\n  await execFromRoot([...resolveToolCommand({ tool: 'tsc' }), '--build', '--force']);\n\n  if (!areProjectTypesValid()) {\n    throw new Error('TypeScript declaration validation failed.');\n  }\n}\n\n/**\n * Copies all template files from the templates folder to the `templates` folder within the\n * distribution folder.\n *\n * This function recursively reads the contents of the templates folder and copies each file to the\n * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the\n * templates from `node_modules/@mnaoumov/typescript-dev-toolkit/dist/templates`. A trailing `.template` on a source\n * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as\n * `eslint.config.mts`), so an active config template can live in the repo under a name that the\n * corresponding tool does not auto-discover.\n *\n * @returns A {@link Promise} that resolves when all files have been copied.\n */\nexport async function buildTemplates(): Promise<void> {\n  for (const dirent of await readdirPosix(RepoPaths.Templates, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = trimStart({\n      $string: join(dirent.parentPath, dirent.name),\n      prefix: `${RepoPaths.Templates}/`\n    });\n    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;\n    await cp(join(RepoPaths.Templates, path), join(RepoPaths.DistTemplates, destinationPath));\n  }\n}\n\nconst TEMPLATE_FILE_SUFFIX = '.template';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\n\nconst SVELTE_CHECK_PACKAGE_NAME = 'svelte-check';\n\nconst SVELTE_FILE_PATTERNS = [\n  `${RepoPaths.AnyPath}/*.svelte`,\n  `${RepoPaths.AnyPath}/*.svelte.js`,\n  `${RepoPaths.AnyPath}/*.svelte.ts`\n];\n\n/**\n * `node_modules` must be listed explicitly: a tsconfig that sets `exclude` at all **replaces** TypeScript's\n * default `node_modules` exclusion, so it cannot be relied on to keep dependencies out of the glob.\n */\nconst SVELTE_FILE_EXCLUDE_PATTERNS = [\n  `${RepoPaths.AnyPath}/${RepoPaths.NodeModules}/${RepoPaths.AnyPath}`,\n  `${RepoPaths.AnyPath}/${RepoPaths.Dist}/${RepoPaths.AnyPath}`\n];\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Re-runs the project type-check in-memory with `skipLibCheck: false`, reporting only diagnostics\n * whose source file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @returns `true` when the project's own files have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nfunction areProjectTypesValid(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n  const { fileNames, options } = parseTsConfig(join(root, RepoPaths.TsConfigJson));\n\n  return checkProjectTypes({\n    options,\n    rootNames: fileNames,\n    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n  });\n}\n\n/**\n * Determines whether the project declares `svelte-check`.\n *\n * The declaration is read from `package.json` rather than probed in `node_modules/.bin`, because\n * {@link resolveToolCommand} deliberately falls back to the package manager's exec form for tools that have\n * no bin shim — the only way a locally installed tool resolves under yarn PnP. Treating a missing shim as a\n * missing tool would therefore break PnP projects.\n *\n * @param packageJson - The project's parsed `package.json`.\n * @returns `true` when `svelte-check` is declared as a regular, dev, or peer dependency.\n */\nfunction checkSvelteCheckDeclared(packageJson: PackageJson): boolean {\n  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies]\n    .some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== undefined);\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],"mappings":"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","names":[]}

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

@@ -49,7 +49,7 @@ export declare function buildCompileTypeScript(): Promise<void>;
  *
  * This function recursively reads the contents of the templates folder and copies each file to the
  * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the
- * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source
+ * templates from `node_modules/@mnaoumov/typescript-dev-toolkit/dist/templates`. A trailing `.template` on a source
  * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as
  * `eslint.config.mts`), so an active config template can live in the repo under a name that the
  * corresponding tool does not auto-discover.

package/dist/lib/cjs/commitlint-forbidden-patterns.cjs

@@ -29,7 +29,7 @@ __export(commitlint_forbidden_patterns_exports, {
 });
 module.exports = __toCommonJS(commitlint_forbidden_patterns_exports);
 var import_forbidden_patterns = require('./forbidden-patterns.cjs');
-const NO_FORBIDDEN_PATTERNS_RULE_NAME = "obsidian-dev-utils/no-forbidden-patterns";
+const NO_FORBIDDEN_PATTERNS_RULE_NAME = "typescript-dev-toolkit/no-forbidden-patterns";
 async function noForbiddenPatternsRule(commit) {
   const patterns = await (0, import_forbidden_patterns.readForbiddenPatterns)();
   const text = [commit.header, commit.body, commit.footer].filter((part) => part !== null).join("\n");
@@ -52,4 +52,4 @@ const forbiddenPatternsPlugin = {
   forbiddenPatternsPlugin,
   noForbiddenPatternsRule
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/commitlint-forbidden-patterns.d.cts

@@ -18,7 +18,7 @@ import type { AsyncRule, Plugin, RuleOutcome } from '@commitlint/types' with { '
 /**
  * The name the rule is registered under.
  */
-export declare const NO_FORBIDDEN_PATTERNS_RULE_NAME = "obsidian-dev-utils/no-forbidden-patterns";
+export declare const NO_FORBIDDEN_PATTERNS_RULE_NAME = "typescript-dev-toolkit/no-forbidden-patterns";
 type Commit = Parameters<AsyncRule>[0];
 /**
  * Checks the whole commit message — header, body and footer — against the forbidden patterns.