@outfitter/tooling 0.3.4 → 0.3.5

package/dist/shared/@outfitter/tooling-6cxfdx0q.js

@@ -1,187 +0,0 @@
-// @bun
-// packages/tooling/src/cli/check-changeset.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-function getChangedPackagePaths(files) {
-  const packageNames = new Set;
-  const pattern = /^packages\/([^/]+)\/src\//;
-  for (const file of files) {
-    const match = pattern.exec(file);
-    if (match?.[1]) {
-      packageNames.add(match[1]);
-    }
-  }
-  return [...packageNames].toSorted();
-}
-function getChangedChangesetFiles(files) {
-  const pattern = /^\.changeset\/([^/]+\.md)$/;
-  const results = [];
-  for (const file of files) {
-    const match = pattern.exec(file);
-    if (match?.[1] && match[1] !== "README.md") {
-      results.push(match[1]);
-    }
-  }
-  return results.toSorted();
-}
-function checkChangesetRequired(changedPackages, changesetFiles) {
-  if (changedPackages.length === 0) {
-    return { ok: true, missingFor: [] };
-  }
-  if (changesetFiles.length > 0) {
-    return { ok: true, missingFor: [] };
-  }
-  return { ok: false, missingFor: changedPackages };
-}
-function parseIgnoredPackagesFromChangesetConfig(jsonContent) {
-  try {
-    const parsed = JSON.parse(jsonContent);
-    if (!Array.isArray(parsed.ignore)) {
-      return [];
-    }
-    return parsed.ignore.filter((entry) => typeof entry === "string");
-  } catch {
-    return [];
-  }
-}
-function parseChangesetFrontmatterPackageNames(markdownContent) {
-  const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdownContent);
-  if (!frontmatterMatch?.[1]) {
-    return [];
-  }
-  const packages = new Set;
-  for (const line of frontmatterMatch[1].split(/\r?\n/)) {
-    const trimmed = line.trim();
-    const match = /^(["']?)(@[^"':\s]+\/[^"':\s]+)\1\s*:/.exec(trimmed);
-    if (match?.[2]) {
-      packages.add(match[2]);
-    }
-  }
-  return [...packages].toSorted();
-}
-function findIgnoredPackageReferences(input) {
-  if (input.ignoredPackages.length === 0 || input.changesetFiles.length === 0) {
-    return [];
-  }
-  const ignored = new Set(input.ignoredPackages);
-  const results = [];
-  for (const file of input.changesetFiles) {
-    const content = input.readChangesetFile(file);
-    const referencedPackages = parseChangesetFrontmatterPackageNames(content);
-    const invalidReferences = referencedPackages.filter((pkg) => ignored.has(pkg));
-    if (invalidReferences.length > 0) {
-      results.push({ file, packages: invalidReferences.toSorted() });
-    }
-  }
-  return results.toSorted((a, b) => a.file.localeCompare(b.file));
-}
-function loadIgnoredPackages(cwd) {
-  const configPath = join(cwd, ".changeset", "config.json");
-  if (!existsSync(configPath)) {
-    return [];
-  }
-  try {
-    return parseIgnoredPackagesFromChangesetConfig(readFileSync(configPath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function getIgnoredReferencesForChangedChangesets(cwd, changesetFiles) {
-  const ignoredPackages = loadIgnoredPackages(cwd);
-  return findIgnoredPackageReferences({
-    changesetFiles,
-    ignoredPackages,
-    readChangesetFile: (filename) => {
-      try {
-        return readFileSync(join(cwd, ".changeset", filename), "utf-8");
-      } catch {
-        return "";
-      }
-    }
-  });
-}
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m"
-};
-async function runCheckChangeset(options = {}) {
-  if (options.skip || process.env["NO_CHANGESET"] === "1") {
-    process.stdout.write(`${COLORS.dim}check-changeset skipped (NO_CHANGESET=1)${COLORS.reset}
-`);
-    process.exitCode = 0;
-    return;
-  }
-  if (process.env["GITHUB_EVENT_NAME"] === "push") {
-    process.stdout.write(`${COLORS.dim}check-changeset skipped (push event)${COLORS.reset}
-`);
-    process.exitCode = 0;
-    return;
-  }
-  const cwd = process.cwd();
-  let changedFiles;
-  try {
-    const proc = Bun.spawnSync(["git", "diff", "--name-only", "origin/main...HEAD"], { cwd });
-    if (proc.exitCode !== 0) {
-      process.exitCode = 0;
-      return;
-    }
-    changedFiles = proc.stdout.toString().trim().split(`
-`).filter((line) => line.length > 0);
-  } catch {
-    process.exitCode = 0;
-    return;
-  }
-  const changedPackages = getChangedPackagePaths(changedFiles);
-  if (changedPackages.length === 0) {
-    process.stdout.write(`${COLORS.green}No package source changes detected.${COLORS.reset}
-`);
-    process.exitCode = 0;
-    return;
-  }
-  const changesetFiles = getChangedChangesetFiles(changedFiles);
-  const check = checkChangesetRequired(changedPackages, changesetFiles);
-  if (!check.ok) {
-    process.stderr.write(`${COLORS.yellow}No changeset found.${COLORS.reset} ` + "Consider adding one with `bun run changeset` for a custom changelog entry.\n\n");
-    process.stderr.write(`Packages with source changes:
-
-`);
-    for (const pkg of check.missingFor) {
-      process.stderr.write(`  ${COLORS.yellow}@outfitter/${pkg}${COLORS.reset}
-`);
-    }
-    process.stderr.write(`
-Run ${COLORS.blue}bun run changeset${COLORS.reset} for a custom changelog entry, ` + `or add ${COLORS.blue}release:none${COLORS.reset} to skip.
-`);
-  }
-  const ignoredReferences = getIgnoredReferencesForChangedChangesets(cwd, changesetFiles);
-  if (ignoredReferences.length > 0) {
-    process.stderr.write(`${COLORS.red}Invalid changeset package reference(s).${COLORS.reset}
-
-`);
-    process.stderr.write(`Changesets must not reference packages listed in .changeset/config.json ignore:
-
-`);
-    for (const reference of ignoredReferences) {
-      process.stderr.write(`  ${COLORS.yellow}${reference.file}${COLORS.reset}
-`);
-      for (const pkg of reference.packages) {
-        process.stderr.write(`    - ${pkg}
-`);
-      }
-    }
-    process.stderr.write(`
-Update the affected changeset files to remove ignored packages before merging.
-`);
-    process.exitCode = 1;
-    return;
-  }
-  process.stdout.write(`${COLORS.green}Changeset found for ${changedPackages.length} changed package(s).${COLORS.reset}
-`);
-  process.exitCode = 0;
-}
-
-export { getChangedPackagePaths, getChangedChangesetFiles, checkChangesetRequired, parseIgnoredPackagesFromChangesetConfig, parseChangesetFrontmatterPackageNames, findIgnoredPackageReferences, runCheckChangeset };

package/dist/shared/@outfitter/tooling-h04te11c.js

@@ -1,231 +0,0 @@
-// @bun
-// packages/tooling/src/cli/check-exports.ts
-import { resolve } from "path";
-function entryToSubpath(entry) {
-  const stripped = entry.replace(/^src\//, "").replace(/\.[cm]?[jt]sx?$/, "");
-  if (stripped === "index") {
-    return ".";
-  }
-  if (stripped.endsWith("/index")) {
-    return `./${stripped.slice(0, -"/index".length)}`;
-  }
-  return `./${stripped}`;
-}
-function compareExports(input) {
-  const { name, actual, expected, path } = input;
-  const actualKeys = new Set(Object.keys(actual));
-  const expectedKeys = new Set(Object.keys(expected));
-  const added = [];
-  const removed = [];
-  const changed = [];
-  for (const key of expectedKeys) {
-    if (!actualKeys.has(key)) {
-      added.push(key);
-    }
-  }
-  for (const key of actualKeys) {
-    if (!expectedKeys.has(key)) {
-      removed.push(key);
-    }
-  }
-  for (const key of actualKeys) {
-    if (expectedKeys.has(key)) {
-      const actualValue = actual[key];
-      const expectedValue = expected[key];
-      if (JSON.stringify(actualValue) !== JSON.stringify(expectedValue)) {
-        changed.push({ key, expected: expectedValue, actual: actualValue });
-      }
-    }
-  }
-  added.sort();
-  removed.sort();
-  changed.sort((a, b) => a.key.localeCompare(b.key));
-  if (added.length === 0 && removed.length === 0 && changed.length === 0) {
-    return { name, status: "ok" };
-  }
-  return {
-    name,
-    status: "drift",
-    drift: {
-      package: name,
-      path: path ?? "",
-      added,
-      removed,
-      changed
-    }
-  };
-}
-function matchesExclude(subpath, excludes) {
-  return excludes.some((pattern) => new Bun.Glob(pattern).match(subpath));
-}
-var CLI_EXCLUSION_PATTERNS = [
-  "**/cli.ts",
-  "**/cli/index.ts",
-  "**/bin.ts",
-  "**/bin/index.ts"
-];
-function isCliEntrypoint(entry) {
-  return CLI_EXCLUSION_PATTERNS.some((pattern) => new Bun.Glob(pattern).match(entry));
-}
-function buildExportValue(entry) {
-  const distPath = entry.replace(/^src\//, "").replace(/\.[cm]?[jt]sx?$/, "");
-  return {
-    import: {
-      types: `./dist/${distPath}.d.ts`,
-      default: `./dist/${distPath}.js`
-    }
-  };
-}
-function discoverEntries(packageRoot) {
-  const glob = new Bun.Glob("src/**/*.ts");
-  const entries = [];
-  for (const match of glob.scanSync({ cwd: packageRoot, dot: false })) {
-    if (match.includes("__tests__") || match.endsWith(".test.ts")) {
-      continue;
-    }
-    entries.push(match);
-  }
-  return entries.toSorted();
-}
-function addConfigFileExports(expected, pkg) {
-  const CONFIG_RE = /\.(json|jsonc|yml|yaml|toml)$/;
-  const configFiles = (pkg.files ?? []).filter((file) => CONFIG_RE.test(file) && file !== "package.json");
-  for (const file of configFiles) {
-    expected[`./${file}`] = `./${file}`;
-    let base = file.replace(CONFIG_RE, "");
-    const match = base.match(/^(.+)\.preset(?:\.(.+))?$/);
-    if (match?.[1]) {
-      base = match[2] ? `${match[1]}-${match[2]}` : match[1];
-    }
-    if (base !== file) {
-      expected[`./${base}`] = `./${file}`;
-    }
-  }
-}
-function computeExpectedExports(packageRoot, workspace, pkg) {
-  const entries = discoverEntries(packageRoot);
-  const exportsConfig = typeof workspace.config?.exports === "object" ? workspace.config.exports : undefined;
-  const excludes = exportsConfig?.exclude ?? [];
-  const customExports = exportsConfig?.customExports ?? {};
-  const expected = {};
-  const subpathEntries = new Map;
-  for (const entry of entries) {
-    if (isCliEntrypoint(entry))
-      continue;
-    const subpath = entryToSubpath(entry);
-    if (matchesExclude(subpath, excludes))
-      continue;
-    const existing = subpathEntries.get(subpath);
-    if (existing) {
-      if (!existing.endsWith("/index.ts") && entry.endsWith("/index.ts")) {
-        continue;
-      }
-    }
-    subpathEntries.set(subpath, entry);
-  }
-  for (const [subpath, entry] of subpathEntries) {
-    expected[subpath] = buildExportValue(entry);
-  }
-  for (const [key, value] of Object.entries(customExports)) {
-    expected[`./${key.replace(/^\.\//, "")}`] = value;
-  }
-  addConfigFileExports(expected, pkg);
-  expected["./package.json"] = "./package.json";
-  return expected;
-}
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m"
-};
-function resolveJsonMode(options = {}) {
-  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
-}
-async function runCheckExports(options = {}) {
-  const cwd = process.cwd();
-  const configPath = resolve(cwd, "bunup.config.ts");
-  let workspaces;
-  try {
-    const configModule = await import(configPath);
-    const rawConfig = configModule.default;
-    if (!Array.isArray(rawConfig)) {
-      process.stderr.write(`bunup.config.ts must export a workspace array
-`);
-      process.exitCode = 1;
-      return;
-    }
-    workspaces = rawConfig;
-  } catch {
-    process.stderr.write(`Could not load bunup.config.ts from ${cwd}
-`);
-    process.exitCode = 1;
-    return;
-  }
-  const results = [];
-  for (const workspace of workspaces) {
-    const packageRoot = resolve(cwd, workspace.root);
-    const pkgPath = resolve(packageRoot, "package.json");
-    let pkg;
-    try {
-      pkg = await Bun.file(pkgPath).json();
-    } catch {
-      results.push({ name: workspace.name, status: "ok" });
-      continue;
-    }
-    const actual = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
-    const expected = computeExpectedExports(packageRoot, workspace, pkg);
-    results.push(compareExports({
-      name: workspace.name,
-      actual,
-      expected,
-      path: workspace.root
-    }));
-  }
-  const checkResult = {
-    ok: results.every((r) => r.status === "ok"),
-    packages: results
-  };
-  if (resolveJsonMode(options)) {
-    process.stdout.write(`${JSON.stringify(checkResult, null, 2)}
-`);
-  } else {
-    const drifted = results.filter((r) => r.status === "drift");
-    if (drifted.length === 0) {
-      process.stdout.write(`${COLORS.green}All ${results.length} packages have exports in sync.${COLORS.reset}
-`);
-    } else {
-      process.stderr.write(`${COLORS.red}Export drift detected in ${drifted.length} package(s):${COLORS.reset}
-
-`);
-      for (const result of drifted) {
-        const drift = result.drift;
-        if (!drift)
-          continue;
-        process.stderr.write(`  ${COLORS.yellow}${result.name}${COLORS.reset} ${COLORS.dim}(${drift.path})${COLORS.reset}
-`);
-        for (const key of drift.added) {
-          process.stderr.write(`    ${COLORS.green}+ ${key}${COLORS.reset}  ${COLORS.dim}(missing from package.json)${COLORS.reset}
-`);
-        }
-        for (const key of drift.removed) {
-          process.stderr.write(`    ${COLORS.red}- ${key}${COLORS.reset}  ${COLORS.dim}(not in source)${COLORS.reset}
-`);
-        }
-        for (const entry of drift.changed) {
-          process.stderr.write(`    ${COLORS.yellow}~ ${entry.key}${COLORS.reset}  ${COLORS.dim}(value mismatch)${COLORS.reset}
-`);
-        }
-        process.stderr.write(`
-`);
-      }
-      process.stderr.write(`Run ${COLORS.blue}bun run build${COLORS.reset} to regenerate exports.
-`);
-    }
-  }
-  process.exitCode = checkResult.ok ? 0 : 1;
-}
-
-export { entryToSubpath, compareExports, resolveJsonMode, runCheckExports };

package/dist/shared/@outfitter/tooling-njw4z34x.d.ts

@@ -1,140 +0,0 @@
-import ts from "typescript";
-import { ZodType } from "zod";
-/** Coverage classification for a single declaration. */
-type CoverageLevel = "documented" | "partial" | "undocumented";
-/** Result for a single exported declaration. */
-interface DeclarationCoverage {
-	readonly name: string;
-	readonly kind: string;
-	readonly level: CoverageLevel;
-	readonly file: string;
-	readonly line: number;
-}
-/** Coverage summary statistics. */
-interface CoverageSummary {
-	readonly documented: number;
-	readonly partial: number;
-	readonly undocumented: number;
-	readonly total: number;
-	readonly percentage: number;
-}
-/** Per-package TSDoc coverage stats. */
-interface PackageCoverage {
-	readonly name: string;
-	readonly path: string;
-	readonly declarations: readonly DeclarationCoverage[];
-	readonly documented: number;
-	readonly partial: number;
-	readonly undocumented: number;
-	readonly total: number;
-	readonly percentage: number;
-}
-/** Aggregated result across all packages. */
-interface TsDocCheckResult {
-	readonly ok: boolean;
-	readonly packages: readonly PackageCoverage[];
-	readonly summary: CoverageSummary;
-}
-/** Zod schema for {@link CoverageLevel}. */
-declare const coverageLevelSchema: ZodType<CoverageLevel>;
-/** Zod schema for {@link DeclarationCoverage}. */
-declare const declarationCoverageSchema: ZodType<DeclarationCoverage>;
-/** Zod schema for {@link CoverageSummary}. */
-declare const coverageSummarySchema: ZodType<CoverageSummary>;
-/** Zod schema for {@link PackageCoverage}. */
-declare const packageCoverageSchema: ZodType<PackageCoverage>;
-/** Zod schema for {@link TsDocCheckResult}. */
-declare const tsDocCheckResultSchema: ZodType<TsDocCheckResult>;
-/** Options for the check-tsdoc command. */
-interface CheckTsDocOptions {
-	readonly strict?: boolean | undefined;
-	readonly json?: boolean | undefined;
-	readonly minCoverage?: number | undefined;
-	readonly cwd?: string | undefined;
-	readonly paths?: readonly string[] | undefined;
-}
-/**
-* Check whether a node is an exported declaration worth checking.
-*
-* Returns true for function, interface, type alias, class, enum, and variable
-* declarations that carry the `export` keyword. Re-exports (`{ ... } from`)
-* and `*` are excluded since TSDoc belongs at the definition site.
-*/
-declare function isExportedDeclaration(node: ts.Node): boolean;
-/**
-* Extract the name of a declaration node.
-*
-* For variable statements, returns the name of the first variable declarator.
-* Returns `undefined` for anonymous declarations (e.g., `function() {}`).
-*/
-declare function getDeclarationName(node: ts.Node): string | undefined;
-/**
-* Determine the kind label for a declaration node.
-*
-* Maps AST node types to human-readable kind strings used in coverage reports.
-*/
-declare function getDeclarationKind(node: ts.Node): string;
-/**
-* Classify a declaration's TSDoc coverage level.
-*
-* - `"documented"` -- has a JSDoc comment with a description. For interfaces
-*   and classes, all members must also have JSDoc comments.
-* - `"partial"` -- the declaration has a JSDoc comment but some members
-*   (in interfaces/classes) lack documentation.
-* - `"undocumented"` -- no JSDoc comment at all.
-*/
-declare function classifyDeclaration(node: ts.Node, sourceFile: ts.SourceFile): CoverageLevel;
-/**
-* Analyze all exported declarations in a source file for TSDoc coverage.
-*
-* Walks top-level statements, filters to exported declarations, and
-* classifies each for documentation coverage.
-*/
-declare function analyzeSourceFile(sourceFile: ts.SourceFile): DeclarationCoverage[];
-/**
-* Calculate aggregate coverage statistics from declaration results.
-*
-* Partial documentation counts as half coverage in the percentage calculation.
-* An empty array returns 100% (no declarations to check).
-*/
-declare function calculateCoverage(declarations: readonly DeclarationCoverage[]): {
-	documented: number;
-	partial: number;
-	undocumented: number;
-	total: number;
-	percentage: number;
-};
-/** Resolve whether JSON output mode is active. */
-declare function resolveJsonMode(options?: CheckTsDocOptions): boolean;
-/**
-* Analyze TSDoc coverage across workspace packages.
-*
-* Pure function that discovers packages, analyzes TSDoc coverage on exported
-* declarations, and returns the aggregated result. Does not print output or
-* call `process.exit()`.
-*
-* @param options - Analysis options (paths, strict mode, coverage threshold)
-* @returns Aggregated coverage result across all packages, or `null` if no packages found
-*/
-declare function analyzeCheckTsdoc(options?: CheckTsDocOptions): TsDocCheckResult | null;
-/**
-* Print a TSDoc coverage result in human-readable format.
-*
-* Renders a bar chart per package with summary statistics. Writes to stdout/stderr.
-*
-* @param result - The coverage result to print
-* @param options - Display options (strict mode, coverage threshold for warning)
-*/
-declare function printCheckTsdocHuman(result: TsDocCheckResult, options?: {
-	strict?: boolean | undefined;
-	minCoverage?: number | undefined;
-}): void;
-/**
-* Run check-tsdoc across workspace packages.
-*
-* Discovers packages with `src/index.ts` entry points, analyzes TSDoc
-* coverage on exported declarations, and reports per-package statistics.
-* Calls `process.exit()` on completion.
-*/
-declare function runCheckTsdoc(options?: CheckTsDocOptions): Promise<void>;
-export { CoverageLevel, DeclarationCoverage, CoverageSummary, PackageCoverage, TsDocCheckResult, coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema, CheckTsDocOptions, isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, resolveJsonMode, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc };