@xylabs/ts-scripts-yarn3 3.14.1 → 3.15.0

package/dist/actions/package/index.mjs

@@ -1,10 +1,916 @@
-export * from "./clean";
-export * from "./clean-outputs";
-export * from "./clean-typescript";
-export * from "./compile";
-export * from "./copy-assets";
-export * from "./deps";
-export * from "./gen-docs";
-export * from "./publint";
-export * from "./recompile";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/actions/package/clean-outputs.ts
+import path from "node:path";
+import chalk from "chalk";
+import { rimraf } from "rimraf";
+var packageCleanOutputs = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  const folders = [
+    path.join(pkg, "dist"),
+    path.join(pkg, "build"),
+    path.join(pkg, "docs")
+  ];
+  console.log(chalk.green(`Cleaning Outputs [${pkgName}]`));
+  await Promise.all(folders.map((folder) => rimraf(folder)));
+  return 0;
+}, "packageCleanOutputs");
+
+// src/actions/package/clean-typescript.ts
+import path2 from "node:path";
+import chalk2 from "chalk";
+import { rimraf as rimraf2 } from "rimraf";
+var packageCleanTypescript = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  console.log(chalk2.green(`Cleaning Typescript [${pkgName}]`));
+  const files = [
+    path2.join(pkg, "*.tsbuildinfo"),
+    path2.join(pkg, ".tsconfig.*"),
+    path2.join(pkg, ".eslintcache")
+  ];
+  await Promise.all(files.map((file) => rimraf2(file)));
+  return 0;
+}, "packageCleanTypescript");
+
+// src/actions/package/clean.ts
+var packageClean = /* @__PURE__ */ __name(async () => {
+  return (await Promise.all([
+    packageCleanOutputs(),
+    packageCleanTypescript()
+  ])).reduce((prev, value) => prev + value, 0);
+}, "packageClean");
+
+// src/actions/package/compile/compile.ts
+import chalk8 from "chalk";
+
+// src/lib/checkResult.ts
+import chalk3 from "chalk";
+var checkResult = /* @__PURE__ */ __name((name, result, level = "error", exitOnFail = false) => {
+  if (result) {
+    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
+    const chalkFunc = level === "error" ? chalk3.red : chalk3.yellow;
+    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
+    if (exitOnFail) {
+      process.exit(result);
+    }
+  }
+}, "checkResult");
+
+// src/lib/loadConfig.ts
+import chalk4 from "chalk";
+import { cosmiconfig } from "cosmiconfig";
+import { merge } from "lodash-es";
+var config;
+var loadConfig = /* @__PURE__ */ __name(async (params) => {
+  if (config) {
+    return merge({}, config, params);
+  }
+  const cosmicConfigResult = await cosmiconfig("xy", {
+    cache: true
+  }).search();
+  config = cosmicConfigResult?.config;
+  const configFilePath = cosmicConfigResult?.filepath;
+  if (configFilePath) {
+    console.log(chalk4.gray(`Loading config from ${configFilePath}`));
+  }
+  return merge({}, config, params);
+}, "loadConfig");
+
+// src/actions/package/publint.ts
+import { promises as fs } from "node:fs";
+import chalk5 from "chalk";
+var packagePublint = /* @__PURE__ */ __name(async (params) => {
+  const pkgDir = process.env.INIT_CWD;
+  const pkg = JSON.parse(await fs.readFile(`${pkgDir}/package.json`, "utf8"));
+  console.log(chalk5.green(`Publint: ${pkg.name}`));
+  console.log(chalk5.gray(pkgDir));
+  const { publint } = await import("publint");
+  const { messages } = await publint({
+    level: "suggestion",
+    pkgDir,
+    strict: true
+  });
+  const { formatMessage } = await import("publint/utils");
+  const validMessage = /* @__PURE__ */ __name((_message) => {
+    return true;
+  }, "validMessage");
+  const validMessages = messages.filter(validMessage);
+  for (const message of validMessages) {
+    switch (message.type) {
+      case "error": {
+        console.error(chalk5.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      case "warning": {
+        console.warn(chalk5.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      default: {
+        console.log(chalk5.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+    }
+  }
+  if (params?.verbose) {
+    console.log(chalk5.gray(`Publint [Finish]: ${pkgDir} [${validMessages.length}]`));
+  }
+  return validMessages.filter((message) => message.type === "error").length;
+}, "packagePublint");
+
+// src/actions/package/compile/packageCompileTsc.ts
+import { cwd } from "node:process";
+import chalk6 from "chalk";
+import { createProgramFromConfig } from "tsc-prog";
+import { DiagnosticCategory, formatDiagnosticsWithColorAndContext, getLineAndCharacterOfPosition, getPreEmitDiagnostics } from "typescript";
+
+// src/actions/package/compile/getCompilerOptions.ts
+import { createRequire } from "node:module";
+import { merge as merge2 } from "lodash-es";
+import { findConfigFile, readConfigFile, sys } from "typescript";
+var getCompilerOptionsJSONFollowExtends = /* @__PURE__ */ __name((filename) => {
+  let opts = {};
+  const config2 = readConfigFile(filename, sys.readFile).config;
+  if (config2.extends) {
+    const require2 = createRequire(import.meta.url);
+    opts = require2(config2.extends);
+  }
+  if (config2?.error) {
+    throw new Error(`getCompilerOptionsJSONFollowExtends failed ${JSON.stringify(config2?.error?.messageText, null, 2)}`);
+  }
+  return {
+    ...opts.compilerOptions,
+    ...config2.compilerOptions
+  };
+}, "getCompilerOptionsJSONFollowExtends");
+var getCompilerOptions = /* @__PURE__ */ __name(async (options, tsconfig = "tsconfig.json") => {
+  const configFileName = findConfigFile("./", sys.fileExists, tsconfig);
+  const configFileCompilerOptions = configFileName ? await getCompilerOptionsJSONFollowExtends(configFileName) : void 0;
+  return merge2({}, configFileCompilerOptions, options);
+}, "getCompilerOptions");
+
+// src/actions/package/compile/packageCompileTsc.ts
+var packageCompileTsc = /* @__PURE__ */ __name(async (noEmit, config2, compilerOptionsParam) => {
+  const pkg = process.env.INIT_CWD ?? cwd();
+  const publint = config2?.publint ?? true;
+  const verbose = config2?.verbose ?? false;
+  const formatHost = {
+    getCanonicalFileName: /* @__PURE__ */ __name((fileName) => fileName, "getCanonicalFileName"),
+    getCurrentDirectory: /* @__PURE__ */ __name(() => pkg, "getCurrentDirectory"),
+    getNewLine: /* @__PURE__ */ __name(() => "\n", "getNewLine")
+  };
+  if (verbose) {
+    console.log(`Compiling with NoEmit TSC [${pkg}]`);
+  }
+  const compilerOptions = {
+    ...await getCompilerOptions({
+      outDir: "dist",
+      removeComments: true,
+      rootDir: "src"
+    }),
+    ...compilerOptionsParam,
+    ...noEmit === void 0 ? {} : {
+      noEmit
+    }
+  };
+  const program = createProgramFromConfig({
+    basePath: pkg ?? cwd(),
+    compilerOptions,
+    exclude: [
+      "dist",
+      "docs",
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "src/**/spec/**/*"
+    ],
+    include: [
+      "src"
+    ]
+  });
+  const results = getPreEmitDiagnostics(program);
+  for (const diag of results) {
+    const lineAndChar = diag.file ? getLineAndCharacterOfPosition(diag.file, diag.start ?? 0) : {
+      character: 0,
+      line: 0
+    };
+    console.log(chalk6.cyan(`${diag.file?.fileName}:${lineAndChar.line + 1}:${lineAndChar.character + 1}`));
+    console.log(formatDiagnosticsWithColorAndContext([
+      diag
+    ], formatHost));
+  }
+  return results.reduce((prev, diag) => prev + diag.category === DiagnosticCategory.Error ? 1 : 0, 0) || (publint ? await packagePublint() : 0);
+}, "packageCompileTsc");
+
+// src/actions/package/compile/packageCompileTsup.ts
+import { merge as merge3 } from "lodash-es";
+import { build, defineConfig } from "tsup";
+
+// src/actions/package/compile/inputs.ts
+import { glob } from "glob";
+var getAllInputs2 = /* @__PURE__ */ __name((folder) => {
+  return glob.sync(`${folder}/**/*.*`, {
+    ignore: [
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "**/spec/**/*"
+    ],
+    posix: true
+  });
+}, "getAllInputs2");
+
+// src/actions/package/compile/buildEntries.ts
+var buildEntries = /* @__PURE__ */ __name((folder, entryMode, verbose = false) => {
+  switch (entryMode) {
+    case "platform": {
+      if (verbose) console.log("buildEntries [platform]");
+      return [
+        `${folder}/index-node.ts`,
+        `${folder}/index-browser.ts`
+      ];
+    }
+    case "all": {
+      if (verbose) console.log("buildEntries [all]");
+      return getAllInputs2(folder).filter((entry) => !entry.includes(".spec.") && !entry.includes(".story."));
+    }
+    default: {
+      if (verbose) console.log("buildEntries [single]");
+      return [
+        `${folder}/index.ts`
+      ];
+    }
+  }
+}, "buildEntries");
+
+// src/actions/package/compile/packageCompileTscTypes.ts
+import { cwd as cwd2 } from "node:process";
+import chalk7 from "chalk";
+import { createProgramFromConfig as createProgramFromConfig2 } from "tsc-prog";
+import { DiagnosticCategory as DiagnosticCategory2 } from "typescript";
+
+// src/actions/package/compile/copyTypeFiles.ts
+import { copyFile, readdir } from "node:fs/promises";
+import { Mutex } from "async-mutex";
+var copyFileMutex = new Mutex();
+var getDistTypeFiles = /* @__PURE__ */ __name(async (compilerOptions) => {
+  const outDir = compilerOptions.outDir ?? "dist";
+  return (await readdir(outDir, {
+    recursive: true
+  })).filter((file) => file.endsWith("d.ts")).map((file) => `${outDir}/${file}`);
+}, "getDistTypeFiles");
+var getDistTypeMapFiles = /* @__PURE__ */ __name(async (compilerOptions) => {
+  const outDir = compilerOptions.outDir ?? "dist";
+  return (await readdir(outDir, {
+    recursive: true
+  })).filter((file) => file.endsWith("d.ts.map")).map((file) => `${outDir}/${file}`);
+}, "getDistTypeMapFiles");
+var copyTypeFiles = /* @__PURE__ */ __name(async (compilerOptions) => {
+  await copyFileMutex.runExclusive(async () => {
+    const distTypeFiles = await getDistTypeFiles(compilerOptions);
+    await Promise.all(distTypeFiles.map(async (file) => {
+      await copyFile(file, file.replace("d.ts", "d.mts"));
+      await copyFile(file, file.replace("d.ts", "d.cts"));
+    }));
+    const distTypeMapFiles = await getDistTypeMapFiles(compilerOptions);
+    await Promise.all(distTypeMapFiles.map(async (file) => {
+      await copyFile(file, file.replace("d.ts.map", "d.mts.map"));
+      await copyFile(file, file.replace("d.ts.map", "d.cts.map"));
+    }));
+  });
+}, "copyTypeFiles");
+
+// src/actions/package/compile/packageCompileTscTypes.ts
+var packageCompileTscTypes = /* @__PURE__ */ __name(async (folder = "src", { verbose } = {}, compilerOptionsParam, generateMts = true) => {
+  const pkg = process.env.INIT_CWD ?? cwd2();
+  if (verbose) {
+    console.log(`Compiling types with TSC [${pkg}]`);
+  }
+  const compilerOptions = {
+    ...await getCompilerOptions({
+      declaration: true,
+      emitDeclarationOnly: true,
+      outDir: "dist",
+      removeComments: true,
+      skipDefaultLibCheck: true,
+      skipLibCheck: true,
+      sourceMap: true
+    }),
+    ...compilerOptionsParam
+  };
+  const files = buildEntries(folder, "all");
+  const result = createProgramFromConfig2({
+    basePath: pkg ?? cwd2(),
+    compilerOptions,
+    exclude: [
+      "dist",
+      "docs",
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "src/**/spec/**/*"
+    ],
+    files
+  }).emit();
+  const diagResults = result.diagnostics.length;
+  for (const diag of result.diagnostics) {
+    switch (diag.category) {
+      case DiagnosticCategory2.Error: {
+        console.error(chalk7.red(diag.messageText));
+        console.error(chalk7.grey(pkg));
+        console.error(chalk7.blue(diag.file?.fileName));
+        break;
+      }
+      case DiagnosticCategory2.Warning: {
+        console.error(chalk7.yellow(diag.messageText));
+        console.error(chalk7.grey(pkg));
+        console.error(chalk7.blue(diag.file?.fileName));
+        break;
+      }
+      case DiagnosticCategory2.Suggestion: {
+        console.error(chalk7.white(diag.messageText));
+        console.error(chalk7.grey(pkg));
+        console.error(chalk7.blue(diag.file?.fileName));
+        break;
+      }
+    }
+  }
+  if (generateMts) {
+    await copyTypeFiles(compilerOptions);
+  }
+  return diagResults;
+}, "packageCompileTscTypes");
+
+// src/actions/package/compile/packageCompileTsup.ts
+var compileFolder = /* @__PURE__ */ __name(async (folder, entryMode = "single", options, verbose) => {
+  const outDir = options?.outDir ?? "dist";
+  const entry = buildEntries(folder, entryMode);
+  const optionsResult = defineConfig({
+    bundle: true,
+    cjsInterop: true,
+    clean: true,
+    dts: false,
+    entry,
+    format: [
+      "cjs",
+      "esm"
+    ],
+    // minify: true,
+    outDir,
+    silent: true,
+    sourcemap: true,
+    splitting: false,
+    // terserOptions: { format: { comments: false } },
+    tsconfig: "tsconfig.json",
+    ...options
+  });
+  const optionsList = (await Promise.all((Array.isArray(optionsResult) ? optionsResult : [
+    optionsResult
+  ]).flatMap(async (options2) => {
+    const result = typeof options2 === "function" ? await options2({}) : [
+      options2
+    ];
+    return Array.isArray(result) ? result : [
+      result
+    ];
+  }))).flat();
+  await Promise.all(optionsList.map((options2) => build(options2)));
+  await packageCompileTscTypes(folder, {
+    verbose
+  }, {
+    outDir
+  });
+  return 0;
+}, "compileFolder");
+var packageCompileTsup = /* @__PURE__ */ __name(async (config2) => {
+  const compile = config2?.compile;
+  const publint = config2?.publint ?? true;
+  const verbose = config2?.verbose ?? false;
+  if (verbose) {
+    console.log(`Compiling with TSUP [Depth: ${compile?.depth}]`);
+  }
+  const compileForNode = compile?.node ?? {
+    src: {}
+  };
+  const compileForBrowser = compile?.browser ?? {
+    src: {}
+  };
+  const compileForNeutral = compile?.neutral ?? {
+    src: {}
+  };
+  return await packageCompileTsc(true, {
+    publint: false,
+    verbose
+  }) || (await Promise.all(Object.entries(compileForNode).map(async ([folder, options]) => {
+    const inEsBuildOptions = typeof compile?.node?.esbuildOptions === "object" ? compile?.node?.esbuildOptions : {};
+    return folder ? await compileFolder(folder, compile?.entryMode, {
+      bundle: true,
+      format: [
+        "cjs",
+        "esm"
+      ],
+      loader: merge3({}, {
+        ".gif": "copy",
+        ".html": "copy",
+        ".jpg": "copy",
+        ".json": "json",
+        ".png": "copy",
+        ".svg": "copy",
+        ".webp": "copy"
+      }, inEsBuildOptions?.loader),
+      // minify: true,
+      outDir: "dist/node",
+      platform: "node",
+      skipNodeModulesBundle: true,
+      sourcemap: true,
+      target: "node16",
+      // terserOptions: { format: { comments: false } },
+      ...compile?.tsup?.options,
+      ...typeof options === "object" ? options : {}
+    }, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) || (await Promise.all(Object.entries(compileForBrowser).map(async ([folder, options]) => {
+    const inEsBuildOptions = typeof compile?.browser?.esbuildOptions === "object" ? compile?.browser?.esbuildOptions : {};
+    return folder ? (await Promise.all([
+      compileFolder(folder, compile?.entryMode, {
+        bundle: true,
+        format: [
+          "cjs"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/browser",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "browser",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose),
+      compileFolder(folder, compile?.entryMode, {
+        bundle: true,
+        format: [
+          "esm"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/browser",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "browser",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose)
+    ])).reduce((prev, value) => prev + value, 0) : 0;
+  }))).reduce((prev, value) => prev + value, 0) || (await Promise.all(Object.entries(compileForNeutral).map(async ([folder, options]) => {
+    const inEsBuildOptions = typeof compile?.neutral?.esbuildOptions === "object" ? compile?.neutral?.esbuildOptions : {};
+    return folder ? (await Promise.all([
+      compileFolder(folder, compile?.entryMode, {
+        bundle: true,
+        format: [
+          "cjs"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/neutral",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "neutral",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose),
+      compileFolder(folder, compile?.entryMode, {
+        bundle: true,
+        format: [
+          "esm"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/neutral",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "neutral",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose)
+    ])).reduce((prev, value) => prev + value, 0) : 0;
+  }))).reduce((prev, value) => prev + value, 0) || (publint ? await packagePublint() : 0);
+}, "packageCompileTsup");
+
+// src/actions/package/compile/compile.ts
+var packageCompile = /* @__PURE__ */ __name(async (inConfig = {}) => {
+  const pkg = process.env.INIT_CWD;
+  console.log(chalk8.green(`Compiling ${pkg}`));
+  const config2 = await loadConfig(inConfig);
+  const publint = config2.publint;
+  const mode = config2.compile?.mode ?? "tsup";
+  let result = 0;
+  switch (mode) {
+    case "tsc": {
+      result += await packageCompileTsc(void 0, config2);
+      break;
+    }
+    case "tsup": {
+      result += await packageCompileTsup(config2);
+      break;
+    }
+  }
+  return result + (publint ? await packagePublint(config2) : 0);
+}, "packageCompile");
+
+// src/actions/package/copy-assets.ts
+import path3 from "node:path/posix";
+import chalk9 from "chalk";
+import cpy from "cpy";
+var copyTargetAssets = /* @__PURE__ */ __name(async (target, name, location) => {
+  try {
+    const values = await cpy([
+      "**/*.jpg",
+      "**/*.png",
+      "**/*.gif",
+      "**/*.svg",
+      "**/*.webp",
+      "**/*.sass",
+      "**/*.scss",
+      "**/*.gif",
+      "**/*.css"
+    ], `../dist/${target}`, {
+      cwd: path3.join(location, "src"),
+      parents: true
+    });
+    if (values.length > 0) {
+      console.log(chalk9.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+    }
+    for (const value of values) {
+      console.log(`${value.split("/").pop()} => ./dist/${target}`);
+    }
+    return 0;
+  } catch (ex) {
+    const error = ex;
+    console.log(`Copy Assets Failed: ${name}: ${error.message}`);
+    return 1;
+  }
+}, "copyTargetAssets");
+var packageCopyAssets = /* @__PURE__ */ __name(async ({ target }) => {
+  const pkg = process.env.INIT_CWD ?? "./";
+  const pkgName = process.env.npm_package_name ?? "Unknown";
+  switch (target) {
+    case "esm": {
+      return await copyTargetAssets("esm", pkgName, pkg);
+    }
+    case "cjs": {
+      return await copyTargetAssets("cjs", pkgName, pkg);
+    }
+    default: {
+      return await copyTargetAssets("esm", pkgName, pkg) || await copyTargetAssets("cjs", pkgName, pkg);
+    }
+  }
+}, "packageCopyAssets");
+
+// src/actions/package/deps.ts
+import { existsSync, readFileSync } from "node:fs";
+import { cwd as cwd3 } from "node:process";
+import chalk10 from "chalk";
+import depcheck from "depcheck";
+var special = depcheck.special;
+var defaultIgnorePatterns = [
+  "*.d.ts",
+  "dist",
+  ".*",
+  "node_modules"
+];
+var defaultIgnoreDevDeps = [
+  "@xylabs/ts-scripts-yarn3",
+  "@xylabs/tsconfig",
+  "@xylabs/tsconfig-dom",
+  "@xylabs/tsconfig-react",
+  "@xylabs/tsconfig-jest",
+  "typescript"
+];
+var defaultIgnoreDevPatterns = [
+  "*.stories.*",
+  "*.spec.*",
+  "spec",
+  "stories",
+  "tsconfig.json"
+];
+var reportUnused = /* @__PURE__ */ __name((name, unused) => {
+  if (unused.length > 0) {
+    const message = [
+      chalk10.yellow(`${unused.length} Unused ${name}`)
+    ];
+    for (const value of unused) message.push(chalk10.gray(`  ${value}`));
+    console.log(message.join("\n"));
+  }
+}, "reportUnused");
+var reportMissing = /* @__PURE__ */ __name((name, missing) => {
+  if (Object.keys(missing).length > 0) {
+    const message = [
+      chalk10.yellow(`${Object.entries(missing).length} Missing ${name}`)
+    ];
+    for (const [key, value] of Object.entries(missing)) {
+      message.push(`${key}`, chalk10.gray(`  ${value.at(0)}`));
+    }
+    console.log(chalk10.yellow(message.join("\n")));
+  }
+}, "reportMissing");
+var analyzeDeps = /* @__PURE__ */ __name(async (pkg, ignoreMatches) => {
+  const packageContent = existsSync(`${pkg}/package.json`) ? JSON.parse(readFileSync(`${pkg}/package.json`, {
+    encoding: "utf8"
+  })) : void 0;
+  const [srcUnused, allUnused] = await Promise.all([
+    depcheck(`${pkg}/src`, {
+      ignoreMatches,
+      ignorePatterns: [
+        ...defaultIgnoreDevPatterns,
+        ...defaultIgnorePatterns
+      ],
+      package: packageContent
+    }),
+    depcheck(`${pkg}/.`, {
+      ignoreMatches: [
+        ...ignoreMatches,
+        ...defaultIgnoreDevDeps
+      ],
+      ignorePatterns: [
+        ...defaultIgnorePatterns
+      ],
+      package: packageContent,
+      specials: [
+        special.eslint,
+        special.babel,
+        special.bin,
+        special.prettier,
+        special.jest,
+        special.mocha
+      ]
+    })
+  ]);
+  const unusedDeps = srcUnused.dependencies;
+  const unusedDevDeps = allUnused.devDependencies;
+  const usedDeps = srcUnused.using;
+  const usedDevDeps = allUnused.using;
+  const missing = {
+    ...srcUnused.missing,
+    ...allUnused.missing
+  };
+  const { invalidDirs, invalidFiles } = allUnused;
+  return {
+    invalidDirs,
+    invalidFiles,
+    missing,
+    unusedDeps,
+    unusedDevDeps,
+    usedDeps,
+    usedDevDeps
+  };
+}, "analyzeDeps");
+var packageDeps = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const pkgName = process.env.npm_package_name;
+  const packageContent = existsSync(`${pkg}/package.json`) ? JSON.parse(readFileSync(`${pkg}/package.json`, {
+    encoding: "utf8"
+  })) : void 0;
+  const rawIgnore = existsSync(`${pkg}/.depcheckrc`) ? readFileSync(`${pkg}/.depcheckrc`, {
+    encoding: "utf8"
+  }).replace("ignores:", '"ignores":') : void 0;
+  let ignoreMatches = [];
+  try {
+    ignoreMatches = rawIgnore ? JSON.parse(`{${rawIgnore}}`).ignores : [];
+  } catch (ex) {
+    const error = ex;
+    console.log(`${pkgName} [${error.message}] Failed to parse .depcheckrc [${rawIgnore}]`);
+  }
+  const { invalidDirs, invalidFiles, unusedDeps, unusedDevDeps, usedDeps, usedDevDeps, missing } = await analyzeDeps(pkg, ignoreMatches);
+  const declaredDeps = Object.keys(packageContent.dependencies ?? {});
+  const declaredPeerDeps = Object.keys(packageContent.peerDependencies ?? {});
+  const declaredDevDeps = Object.keys(packageContent.devDependencies ?? {});
+  const missingDeps = Object.keys(usedDeps).filter((key) => !declaredDeps.includes(key) && !declaredPeerDeps.includes(key) && !key.startsWith("@types/"));
+  const missingDevDeps = Object.keys(usedDevDeps).filter((key) => !declaredDevDeps.includes(key) && !declaredDeps.includes(key));
+  const missingDepsObject = {};
+  for (const key of missingDeps) {
+    missingDepsObject[key] = missing[key] ?? [
+      `devDep should be dep [${key}]`
+    ];
+  }
+  const missingDevDepsObject = {};
+  for (const key of missingDevDeps) {
+    if (missing[key]) {
+      missingDevDepsObject[key] = missing[key];
+    }
+  }
+  const errorCounts = [
+    unusedDeps.length,
+    unusedDevDeps.length,
+    Object.entries(invalidDirs).length,
+    Object.entries(invalidFiles).length,
+    Object.entries(missingDepsObject).length,
+    Object.entries(missingDevDepsObject).length
+  ];
+  const errorCount = errorCounts.reduce((prev, count) => prev + count, 0);
+  if (errorCount > 0) {
+    console.log(`Deps [${pkgName}] = (${JSON.stringify(errorCounts)})`);
+  } else {
+    console.log(`Deps [${pkgName}] - Ok`);
+  }
+  reportUnused("dependencies", unusedDeps);
+  reportUnused("devDependencies", unusedDevDeps);
+  if (Object.entries(invalidDirs).length > 0) {
+    for (const [key, value] of Object.entries(invalidDirs)) console.warn(chalk10.gray(`Invalid Dir: ${key}: ${value}`));
+  }
+  if (Object.entries(invalidFiles).length > 0) {
+    for (const [key, value] of Object.entries(invalidFiles)) console.warn(chalk10.gray(`Invalid File: ${key}: ${value}`));
+  }
+  reportMissing("dependencies", missingDepsObject);
+  reportMissing("devDependencies", missingDevDepsObject);
+  checkResult(`Deps [${pkgName}]`, errorCount, "warn", false);
+  return 0;
+}, "packageDeps");
+
+// src/actions/package/gen-docs.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path4 from "node:path";
+import chalk11 from "chalk";
+import { Application, ArgumentsReader, TSConfigReader, TypeDocReader } from "typedoc";
+var ExitCodes = {
+  CompileError: 3,
+  ExceptionThrown: 6,
+  NoEntryPoints: 2,
+  Ok: 0,
+  OptionError: 1,
+  OutputError: 5,
+  ValidationError: 4
+};
+var packageGenDocs = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD;
+  if (pkg && !existsSync2(path4.join(pkg, "typedoc.json"))) {
+    return;
+  }
+  const app = await Application.bootstrap({
+    entryPointStrategy: "merge",
+    entryPoints: [
+      `${pkg}/src/**/*.ts`,
+      `${pkg}/packages/*/dist/docs.json`
+    ],
+    excludeExternals: true,
+    json: `${pkg}/dist/docs.json`,
+    logLevel: "Error",
+    tsconfig: `${pkg}/tsconfig.json`
+  });
+  app.options.addReader(new ArgumentsReader(0));
+  app.options.addReader(new TypeDocReader());
+  app.options.addReader(new TSConfigReader());
+  app.options.addReader(new ArgumentsReader(300));
+  return await runTypeDoc(app);
+}, "packageGenDocs");
+var runTypeDoc = /* @__PURE__ */ __name(async (app) => {
+  const pkgName = process.env.npm_package_name;
+  if (app.options.getValue("version")) {
+    console.log(app.toString());
+    return ExitCodes.Ok;
+  }
+  if (app.options.getValue("showConfig")) {
+    console.log(app.options.getRawValues());
+    return ExitCodes.Ok;
+  }
+  if (app.logger.hasErrors()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("entryPoints").length === 0) {
+    app.logger.error("No entry points provided");
+    return ExitCodes.NoEntryPoints;
+  }
+  if (app.options.getValue("watch")) {
+    app.convertAndWatch(async (project2) => {
+      const out = app.options.getValue("out");
+      if (out) {
+        await app.generateDocs(project2, out);
+      }
+      const json = app.options.getValue("json");
+      if (json) {
+        await app.generateJson(project2, json);
+      }
+      if (!out && !json) {
+        await app.generateDocs(project2, "./docs");
+      }
+    });
+    return ExitCodes.Ok;
+  }
+  const project = await app.convert();
+  if (!project) {
+    return ExitCodes.CompileError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.CompileError;
+  }
+  app.validate(project);
+  if (app.logger.hasErrors()) {
+    return ExitCodes.ValidationError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.ValidationError;
+  }
+  if (app.options.getValue("emit") !== "none") {
+    const out = app.options.getValue("out");
+    if (out) {
+      await app.generateDocs(project, out);
+    }
+    const json = app.options.getValue("json");
+    if (json) {
+      await app.generateJson(project, json);
+    }
+    if (!out && !json) {
+      await app.generateDocs(project, "./docs");
+    }
+    if (app.logger.hasErrors()) {
+      return ExitCodes.OutputError;
+    }
+    if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+      return ExitCodes.OutputError;
+    }
+  }
+  console.log(chalk11.green(`${pkgName} - Ok`));
+  return ExitCodes.Ok;
+}, "runTypeDoc");
+
+// src/actions/package/recompile.ts
+var packageRecompile = /* @__PURE__ */ __name(async () => {
+  return (await Promise.all([
+    packageClean(),
+    packageCompile()
+  ])).reduce((prev, value) => prev + value, 0);
+}, "packageRecompile");
+export {
+  packageClean,
+  packageCleanOutputs,
+  packageCleanTypescript,
+  packageCompile,
+  packageCompileTsc,
+  packageCompileTsup,
+  packageCopyAssets,
+  packageDeps,
+  packageGenDocs,
+  packagePublint,
+  packageRecompile
+};
 //# sourceMappingURL=index.mjs.map