@outfitter/tooling 0.3.0 → 0.3.4

package/dist/shared/chunk-cmde0fwx.js

@@ -1,421 +0,0 @@
-import {
-  __require
-} from "./chunk-3s189drz.js";
-
-// src/cli/check-tsdoc.ts
-import { resolve } from "node:path";
-import ts from "typescript";
-import { z } from "zod";
-var coverageLevelSchema = z.enum([
-  "documented",
-  "partial",
-  "undocumented"
-]);
-var declarationCoverageSchema = z.object({
-  name: z.string(),
-  kind: z.string(),
-  level: coverageLevelSchema,
-  file: z.string(),
-  line: z.number()
-});
-var coverageSummarySchema = z.object({
-  documented: z.number(),
-  partial: z.number(),
-  undocumented: z.number(),
-  total: z.number(),
-  percentage: z.number()
-});
-var packageCoverageSchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  declarations: z.array(declarationCoverageSchema),
-  documented: z.number(),
-  partial: z.number(),
-  undocumented: z.number(),
-  total: z.number(),
-  percentage: z.number()
-});
-var tsDocCheckResultSchema = z.object({
-  ok: z.boolean(),
-  packages: z.array(packageCoverageSchema),
-  summary: coverageSummarySchema
-});
-function isExportedDeclaration(node) {
-  if (ts.isExportDeclaration(node))
-    return false;
-  if (ts.isExportAssignment(node))
-    return false;
-  const isDeclaration = ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
-  if (!isDeclaration)
-    return false;
-  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-  if (!modifiers)
-    return false;
-  return modifiers.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword);
-}
-function getDeclarationName(node) {
-  if (ts.isVariableStatement(node)) {
-    const decl = node.declarationList.declarations[0];
-    if (decl && ts.isIdentifier(decl.name)) {
-      return decl.name.text;
-    }
-    return;
-  }
-  if (ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)) {
-    return node.name?.text;
-  }
-  return;
-}
-function getDeclarationKind(node) {
-  if (ts.isFunctionDeclaration(node))
-    return "function";
-  if (ts.isInterfaceDeclaration(node))
-    return "interface";
-  if (ts.isTypeAliasDeclaration(node))
-    return "type";
-  if (ts.isClassDeclaration(node))
-    return "class";
-  if (ts.isEnumDeclaration(node))
-    return "enum";
-  if (ts.isVariableStatement(node))
-    return "variable";
-  return "unknown";
-}
-function hasJSDocComment(node, sourceFile) {
-  const sourceText = sourceFile.getFullText();
-  const ranges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
-  if (!ranges)
-    return false;
-  return ranges.some((range) => {
-    if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia)
-      return false;
-    const text = sourceText.slice(range.pos, range.end);
-    return text.startsWith("/**");
-  });
-}
-function memberHasJSDoc(member, sourceFile) {
-  const sourceText = sourceFile.getFullText();
-  const ranges = ts.getLeadingCommentRanges(sourceText, member.getFullStart());
-  if (!ranges)
-    return false;
-  return ranges.some((range) => {
-    if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia)
-      return false;
-    const text = sourceText.slice(range.pos, range.end);
-    return text.startsWith("/**");
-  });
-}
-function classifyDeclaration(node, sourceFile) {
-  const hasDoc = hasJSDocComment(node, sourceFile);
-  if (!hasDoc)
-    return "undocumented";
-  if (ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node)) {
-    const members = node.members;
-    if (members.length > 0) {
-      const allMembersDocumented = members.every((member) => memberHasJSDoc(member, sourceFile));
-      if (!allMembersDocumented)
-        return "partial";
-    }
-  }
-  return "documented";
-}
-function analyzeSourceFile(sourceFile) {
-  const results = [];
-  for (const statement of sourceFile.statements) {
-    if (!isExportedDeclaration(statement))
-      continue;
-    const name = getDeclarationName(statement);
-    if (!name)
-      continue;
-    const kind = getDeclarationKind(statement);
-    const level = classifyDeclaration(statement, sourceFile);
-    const { line } = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
-    results.push({
-      name,
-      kind,
-      level,
-      file: sourceFile.fileName,
-      line: line + 1
-    });
-  }
-  return results;
-}
-function calculateCoverage(declarations) {
-  const total = declarations.length;
-  if (total === 0) {
-    return {
-      documented: 0,
-      partial: 0,
-      undocumented: 0,
-      total: 0,
-      percentage: 100
-    };
-  }
-  const documented = declarations.filter((d) => d.level === "documented").length;
-  const partial = declarations.filter((d) => d.level === "partial").length;
-  const undocumented = declarations.filter((d) => d.level === "undocumented").length;
-  const score = documented + partial * 0.5;
-  const percentage = Math.round(score / total * 100);
-  return { documented, partial, undocumented, total, percentage };
-}
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m",
-  bold: "\x1B[1m"
-};
-function resolveJsonMode(options = {}) {
-  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
-}
-function bar(percentage, width = 20) {
-  const filled = Math.round(percentage / 100 * width);
-  const empty = width - filled;
-  const color = percentage >= 80 ? COLORS.green : percentage >= 50 ? COLORS.yellow : COLORS.red;
-  return `${color}${"█".repeat(filled)}${COLORS.dim}${"░".repeat(empty)}${COLORS.reset}`;
-}
-function discoverPackages(cwd) {
-  const packages = [];
-  const seenEntryPoints = new Set;
-  for (const pattern of ["packages/*/src/index.ts", "apps/*/src/index.ts"]) {
-    const glob = new Bun.Glob(pattern);
-    for (const match of glob.scanSync({ cwd, dot: false })) {
-      const parts = match.split("/");
-      const rootDir = parts[0];
-      const pkgDir = parts[1];
-      if (!rootDir || !pkgDir)
-        continue;
-      const entryPoint = resolve(cwd, match);
-      if (seenEntryPoints.has(entryPoint)) {
-        continue;
-      }
-      seenEntryPoints.add(entryPoint);
-      const pkgRoot = resolve(cwd, rootDir, pkgDir);
-      let pkgName = pkgDir;
-      try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
-        if (pkgJson.name)
-          pkgName = pkgJson.name;
-      } catch {}
-      packages.push({
-        name: pkgName,
-        path: pkgRoot,
-        entryPoint
-      });
-    }
-  }
-  if (packages.length === 0) {
-    const entryPoint = resolve(cwd, "src/index.ts");
-    try {
-      __require("node:fs").accessSync(entryPoint);
-      let pkgName = "root";
-      try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(cwd, "package.json"), "utf-8"));
-        if (pkgJson.name)
-          pkgName = pkgJson.name;
-      } catch {}
-      packages.push({
-        name: pkgName,
-        path: cwd,
-        entryPoint
-      });
-      seenEntryPoints.add(entryPoint);
-    } catch {}
-  }
-  return packages.sort((a, b) => a.name.localeCompare(b.name));
-}
-function collectReExportedSourceFiles(sourceFile, program, pkgPath) {
-  const result = [];
-  const seen = new Set;
-  for (const statement of sourceFile.statements) {
-    if (!ts.isExportDeclaration(statement))
-      continue;
-    if (!statement.moduleSpecifier)
-      continue;
-    if (!ts.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    const specifier = statement.moduleSpecifier.text;
-    if (!specifier.startsWith("."))
-      continue;
-    const resolvedModule = ts.resolveModuleName(specifier, sourceFile.fileName, program.getCompilerOptions(), ts.sys);
-    const resolvedFileName = resolvedModule.resolvedModule?.resolvedFileName;
-    if (!resolvedFileName)
-      continue;
-    if (!resolvedFileName.startsWith(pkgPath))
-      continue;
-    if (seen.has(resolvedFileName))
-      continue;
-    seen.add(resolvedFileName);
-    const sf = program.getSourceFile(resolvedFileName);
-    if (sf)
-      result.push(sf);
-  }
-  return result;
-}
-function analyzePackage(pkg, workspaceCwd) {
-  try {
-    __require("node:fs").accessSync(pkg.entryPoint);
-  } catch {
-    return {
-      name: pkg.name,
-      path: pkg.path,
-      declarations: [],
-      documented: 0,
-      partial: 0,
-      undocumented: 0,
-      total: 0,
-      percentage: 0
-    };
-  }
-  let tsconfigPath = resolve(pkg.path, "tsconfig.json");
-  try {
-    __require("node:fs").accessSync(tsconfigPath);
-  } catch {
-    tsconfigPath = resolve(workspaceCwd, "tsconfig.json");
-  }
-  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, pkg.path);
-  const program = ts.createProgram({
-    rootNames: [pkg.entryPoint],
-    options: parsedConfig.options,
-    host: ts.createCompilerHost(parsedConfig.options)
-  });
-  const sourceFile = program.getSourceFile(pkg.entryPoint);
-  if (!sourceFile) {
-    return {
-      name: pkg.name,
-      path: pkg.path,
-      declarations: [],
-      documented: 0,
-      partial: 0,
-      undocumented: 0,
-      total: 0,
-      percentage: 0
-    };
-  }
-  const declarations = analyzeSourceFile(sourceFile);
-  const reExportedFiles = collectReExportedSourceFiles(sourceFile, program, pkg.path);
-  for (const sf of reExportedFiles) {
-    declarations.push(...analyzeSourceFile(sf));
-  }
-  const stats = calculateCoverage(declarations);
-  return {
-    name: pkg.name,
-    path: pkg.path,
-    declarations,
-    ...stats
-  };
-}
-function analyzeCheckTsdoc(options = {}) {
-  const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
-  const minCoverage = options.minCoverage ?? 0;
-  let packages;
-  if (options.paths && options.paths.length > 0) {
-    packages = options.paths.map((p) => {
-      const absPath = resolve(cwd, p);
-      const entryPoint = resolve(absPath, "src/index.ts");
-      let name = p;
-      try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(absPath, "package.json"), "utf-8"));
-        if (pkgJson.name)
-          name = pkgJson.name;
-      } catch {}
-      return { name, path: absPath, entryPoint };
-    });
-  } else {
-    packages = discoverPackages(cwd);
-  }
-  if (packages.length === 0) {
-    return null;
-  }
-  const packageResults = [];
-  for (const pkg of packages) {
-    packageResults.push(analyzePackage(pkg, cwd));
-  }
-  const allDeclarations = packageResults.flatMap((p) => p.declarations);
-  const summary = calculateCoverage(allDeclarations);
-  const ok = !options.strict || summary.percentage >= minCoverage;
-  return {
-    ok,
-    packages: packageResults,
-    summary
-  };
-}
-function printCheckTsdocHuman(result, options) {
-  process.stdout.write(`
-${COLORS.bold}TSDoc Coverage Report${COLORS.reset}
-
-`);
-  for (const pkg of result.packages) {
-    const color = pkg.percentage >= 80 ? COLORS.green : pkg.percentage >= 50 ? COLORS.yellow : COLORS.red;
-    process.stdout.write(`  ${color}${pkg.percentage.toString().padStart(3)}%${COLORS.reset} ${bar(pkg.percentage)} ${pkg.name}
-`);
-    if (pkg.total > 0) {
-      const parts = [];
-      if (pkg.documented > 0)
-        parts.push(`${COLORS.green}${pkg.documented} documented${COLORS.reset}`);
-      if (pkg.partial > 0)
-        parts.push(`${COLORS.yellow}${pkg.partial} partial${COLORS.reset}`);
-      if (pkg.undocumented > 0)
-        parts.push(`${COLORS.red}${pkg.undocumented} undocumented${COLORS.reset}`);
-      process.stdout.write(`       ${COLORS.dim}${pkg.total} declarations:${COLORS.reset} ${parts.join(", ")}
-`);
-    } else {
-      process.stdout.write(`       ${COLORS.dim}no exported declarations${COLORS.reset}
-`);
-    }
-  }
-  const { summary } = result;
-  process.stdout.write(`
-  ${COLORS.bold}Summary:${COLORS.reset} ${summary.percentage}% coverage (${summary.documented} documented, ${summary.partial} partial, ${summary.undocumented} undocumented of ${summary.total} total)
-`);
-  const minCoverage = options?.minCoverage ?? 0;
-  if (options?.strict && summary.percentage < minCoverage) {
-    process.stderr.write(`
-  ${COLORS.red}Coverage ${summary.percentage}% is below minimum threshold of ${minCoverage}%${COLORS.reset}
-`);
-  }
-  process.stdout.write(`
-`);
-}
-async function runCheckTsdoc(options = {}) {
-  const result = analyzeCheckTsdoc(options);
-  if (!result) {
-    process.stderr.write(`No packages found with src/index.ts entry points.
-` + `Searched: packages/*/src/index.ts, apps/*/src/index.ts, src/index.ts
-` + `Use --package <path> to specify a package path explicitly.
-`);
-    process.exit(1);
-  }
-  if (resolveJsonMode(options)) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}
-`);
-  } else {
-    printCheckTsdocHuman(result, {
-      strict: options.strict,
-      minCoverage: options.minCoverage
-    });
-  }
-  process.exit(result.ok ? 0 : 1);
-}
-
-// src/version.ts
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-var DEFAULT_VERSION = "0.0.0";
-function readPackageVersion() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const pkgPath = require2.resolve("@outfitter/tooling/package.json");
-    const packageJson = JSON.parse(readFileSync(pkgPath, "utf8"));
-    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-      return packageJson.version;
-    }
-  } catch {}
-  return DEFAULT_VERSION;
-}
-var VERSION = readPackageVersion();
-
-export { coverageLevelSchema, declarationCoverageSchema, packageCoverageSchema, tsDocCheckResultSchema, analyzeSourceFile, calculateCoverage, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc, VERSION };