@xylabs/ts-scripts-yarn3 7.0.0-rc.9 → 7.0.1

package/dist/actions/package/recompile.mjs

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/actions/package/clean-outputs.ts
 import path from "path";
 import chalk2 from "chalk";
@@ -5,12 +8,15 @@ import chalk2 from "chalk";
 // src/lib/deleteGlob.ts
 import fs from "fs";
 import { glob } from "glob";
-var deleteGlob = (globPath) => {
+var deleteGlob = /* @__PURE__ */ __name((globPath) => {
   const files = glob.sync(globPath);
   for (const file of files) {
-    fs.rmSync(file, { recursive: true, force: true });
+    fs.rmSync(file, {
+      recursive: true,
+      force: true
+    });
   }
-};
+}, "deleteGlob");
 
 // src/lib/loadConfig.ts
 import chalk from "chalk";
@@ -18,116 +24,114 @@ import { cosmiconfig } from "cosmiconfig";
 import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
 import deepmerge from "deepmerge";
 var config;
-var loadConfig = async (params) => {
-  if (config) {
-    return deepmerge(config, params ?? {});
-  }
-  const cosmicConfigResult = await cosmiconfig("xy", { cache: true, loaders: { ".ts": TypeScriptLoader() } }).search();
-  config = cosmicConfigResult?.config;
-  const configFilePath = cosmicConfigResult?.filepath;
-  if (configFilePath) {
-    console.log(chalk.gray(`Loading config from ${configFilePath}`));
+var loadConfig = /* @__PURE__ */ __name(async (params) => {
+  if (config === void 0) {
+    const cosmicConfigResult = await cosmiconfig("xy", {
+      cache: true,
+      loaders: {
+        ".ts": TypeScriptLoader()
+      }
+    }).search();
+    config = cosmicConfigResult?.config;
+    const configFilePath = cosmicConfigResult?.filepath;
+    if (configFilePath !== void 0) {
+      console.log(chalk.green(`Loaded config from ${configFilePath}`));
+      if (config.verbose) {
+        console.log(chalk.gray(`${JSON.stringify(config, null, 2)}`));
+      }
+    }
   }
   return deepmerge(config, params ?? {});
-};
+}, "loadConfig");
 
 // src/actions/package/clean-outputs.ts
-var packageCleanOutputs = () => {
+var packageCleanOutputs = /* @__PURE__ */ __name(() => {
   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")];
+  const folders = [
+    path.join(pkg, "dist"),
+    path.join(pkg, "build"),
+    path.join(pkg, "docs")
+  ];
   console.log(chalk2.green(`Cleaning Outputs [${pkgName}]`));
   for (let folder of folders) {
     deleteGlob(folder);
   }
   return 0;
-};
+}, "packageCleanOutputs");
 
 // src/actions/package/clean-typescript.ts
 import path2 from "path";
 import chalk3 from "chalk";
-var packageCleanTypescript = () => {
+var packageCleanTypescript = /* @__PURE__ */ __name(() => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
   console.log(chalk3.green(`Cleaning Typescript [${pkgName}]`));
-  const files = [path2.join(pkg, "*.tsbuildinfo"), path2.join(pkg, ".tsconfig.*"), path2.join(pkg, ".eslintcache")];
+  const files = [
+    path2.join(pkg, "*.tsbuildinfo"),
+    path2.join(pkg, ".tsconfig.*"),
+    path2.join(pkg, ".eslintcache")
+  ];
   for (let file of files) {
     deleteGlob(file);
   }
   return 0;
-};
+}, "packageCleanTypescript");
 
 // src/actions/package/clean.ts
-var packageClean = async () => {
-  return (await Promise.all([packageCleanOutputs(), packageCleanTypescript()])).reduce((prev, value) => prev + value, 0);
-};
+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 chalk5 from "chalk";
-
-// src/actions/package/publint.ts
-import { promises as fs2 } from "fs";
-import chalk4 from "chalk";
-import sortPackageJson from "sort-package-json";
-var packagePublint = async (params) => {
-  const pkgDir = process.env.INIT_CWD;
-  const sortedPkg = sortPackageJson(await fs2.readFile(`${pkgDir}/package.json`, "utf8"));
-  await fs2.writeFile(`${pkgDir}/package.json`, sortedPkg);
-  const pkg = JSON.parse(await fs2.readFile(`${pkgDir}/package.json`, "utf8"));
-  console.log(chalk4.green(`Publint: ${pkg.name}`));
-  console.log(chalk4.gray(pkgDir));
-  const { publint } = await import("publint");
-  const { messages } = await publint({
-    level: "suggestion",
-    pkgDir,
-    strict: true
-  });
-  const { formatMessage } = await import("publint/utils");
-  const validMessage = (_message) => {
-    return true;
-  };
-  const validMessages = messages.filter(validMessage);
-  for (const message of validMessages) {
-    switch (message.type) {
-      case "error": {
-        console.error(chalk4.red(`[${message.code}] ${formatMessage(message, pkg)}`));
-        break;
-      }
-      case "warning": {
-        console.warn(chalk4.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
-        break;
-      }
-      default: {
-        console.log(chalk4.white(`[${message.code}] ${formatMessage(message, pkg)}`));
-        break;
-      }
-    }
-  }
-  if (params?.verbose) {
-    console.log(chalk4.gray(`Publint [Finish]: ${pkgDir} [${validMessages.length}]`));
-  }
-  return validMessages.filter((message) => message.type === "error").length;
-};
+import chalk8 from "chalk";
 
 // src/actions/package/compile/packageCompileTsup.ts
+import chalk7 from "chalk";
 import { build, defineConfig } from "tsup";
 
 // src/actions/package/compile/inputs.ts
+import chalk4 from "chalk";
 import { glob as glob2 } from "glob";
-var getAllInputs = (folder) => {
-  return glob2.sync(`${folder}/**/*.*`, { posix: true });
-};
+var getAllInputs = /* @__PURE__ */ __name((srcDir, verbose = false) => {
+  return [
+    ...glob2.sync(`${srcDir}/**/*.ts`, {
+      posix: true
+    }).map((file) => {
+      const result = file.slice(Math.max(0, srcDir.length + 1));
+      if (verbose) {
+        console.log(chalk4.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      }
+      return result;
+    }),
+    ...glob2.sync(`${srcDir}/**/*.tsx`, {
+      posix: true
+    }).map((file) => {
+      const result = file.slice(Math.max(0, srcDir.length + 1));
+      if (verbose) {
+        console.log(chalk4.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      }
+      return result;
+    })
+  ];
+}, "getAllInputs");
 
 // src/actions/package/compile/buildEntries.ts
-var buildEntries = (folder, entryMode = "single", options, excludeSpecAndStories = true, verbose = false) => {
+var buildEntries = /* @__PURE__ */ __name((srcDir, entryMode = "single", options, excludeSpecAndStories = true, verbose = false) => {
   let entries = [];
   switch (entryMode) {
     case "platform": {
-      entries = [`${folder}/index-node.ts`, `${folder}/index-browser.ts`];
+      entries = [
+        "index-node.ts",
+        "index-browser.ts"
+      ];
       break;
     }
     case "all": {
-      entries = excludeSpecAndStories ? getAllInputs(folder).filter((entry) => !entry.includes(".spec.") && !entry.includes(".stories.")) : getAllInputs(folder);
+      entries = (excludeSpecAndStories ? getAllInputs(srcDir).filter((entry) => !entry.includes(".spec.") && !entry.includes(".stories.")) : getAllInputs(srcDir)).filter((entry) => !entry.endsWith(".d.ts"));
       break;
     }
     case "custom": {
@@ -135,7 +139,9 @@ var buildEntries = (folder, entryMode = "single", options, excludeSpecAndStories
       break;
     }
     default: {
-      entries = [`${folder}/index.ts`];
+      entries = [
+        "index.ts"
+      ];
       break;
     }
   }
@@ -144,7 +150,7 @@ var buildEntries = (folder, entryMode = "single", options, excludeSpecAndStories
   }
   if (verbose) console.log(`buildEntries [${entryMode}] ${entries.length}`);
   return entries;
-};
+}, "buildEntries");
 
 // src/actions/package/compile/deepMerge.ts
 function deepMerge(target, source) {
@@ -161,6 +167,7 @@ function deepMerge(target, source) {
   }
   return target;
 }
+__name(deepMerge, "deepMerge");
 function deepMergeObjects(objects) {
   const result = {};
   for (const obj of objects) {
@@ -168,180 +175,343 @@ function deepMergeObjects(objects) {
   }
   return result;
 }
+__name(deepMergeObjects, "deepMergeObjects");
 
-// src/actions/package/compile/packageCompileTscTypes.ts
+// src/actions/package/compile/packageCompileTsc.ts
+import { cwd as cwd2 } from "process";
+import chalk5 from "chalk";
+import { createProgramFromConfig } from "tsc-prog";
+import ts, { DiagnosticCategory, formatDiagnosticsWithColorAndContext, getPreEmitDiagnostics, sys } from "typescript";
+
+// src/actions/package/compile/getCompilerOptions.ts
 import { cwd } from "process";
+import deepmerge2 from "deepmerge";
+import { getTsconfig } from "get-tsconfig";
+var getCompilerOptions = /* @__PURE__ */ __name((options = {}, fileName = "tsconfig.json") => {
+  const resolvedTsConfigCompilerOptions = getTsconfig(cwd(), fileName)?.config?.compilerOptions ?? {};
+  return deepmerge2(resolvedTsConfigCompilerOptions, options);
+}, "getCompilerOptions");
+
+// src/actions/package/compile/packageCompileTsc.ts
+var packageCompileTsc = /* @__PURE__ */ __name((platform, entries, srcDir = "src", outDir = "dist", compilerOptionsParam, verbose = false) => {
+  const pkg = process.env.INIT_CWD ?? cwd2();
+  if (verbose) {
+    console.log(chalk5.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
+  }
+  const configFilePath = ts.findConfigFile("./", ts.sys.fileExists, "tsconfig.json");
+  if (configFilePath === void 0) {
+    throw new Error("Could not find tsconfig.json");
+  }
+  const compilerOptions = {
+    ...getCompilerOptions({
+      removeComments: false,
+      skipDefaultLibCheck: true,
+      skipLibCheck: true,
+      sourceMap: false
+    }),
+    ...compilerOptionsParam,
+    outDir: `${outDir}/${platform}`,
+    emitDeclarationOnly: true,
+    noEmit: false
+  };
+  console.log(chalk5.cyan(`Validating Files: ${entries.length}`));
+  if (verbose) {
+    for (const entry of entries) {
+      console.log(chalk5.grey(`Validating: ${entry}`));
+    }
+  }
+  try {
+    if (entries.length > 0) {
+      const program = createProgramFromConfig({
+        configFilePath,
+        basePath: pkg ?? cwd2(),
+        compilerOptions,
+        files: entries.map((entry) => `${srcDir}/${entry}`),
+        include: [
+          `${srcDir}/**/*.*`
+        ]
+      });
+      const diagnostics = getPreEmitDiagnostics(program);
+      if (diagnostics.length > 0) {
+        const formattedDiagnostics = formatDiagnosticsWithColorAndContext(diagnostics, {
+          getCanonicalFileName: /* @__PURE__ */ __name((fileName) => fileName, "getCanonicalFileName"),
+          getCurrentDirectory: /* @__PURE__ */ __name(() => srcDir, "getCurrentDirectory"),
+          getNewLine: /* @__PURE__ */ __name(() => sys.newLine, "getNewLine")
+        });
+        console.error(formattedDiagnostics);
+      }
+      program.emit();
+      return diagnostics.reduce((acc, diag) => acc + (diag.category === DiagnosticCategory.Error ? 1 : 0), 0);
+    }
+    return 0;
+  } finally {
+    if (verbose) {
+      console.log(chalk5.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+    }
+  }
+}, "packageCompileTsc");
+
+// src/actions/package/compile/packageCompileTscTypes.ts
+import path3 from "path";
+import { cwd as cwd3 } from "process";
+import chalk6 from "chalk";
 import { rollup } from "rollup";
 import dts from "rollup-plugin-dts";
 import nodeExternals from "rollup-plugin-node-externals";
-async function bundleDts(inputPath, outputPath, platform) {
-  const nodePlugIns = platform === "node" ? [nodeExternals()] : [];
-  const bundle = await rollup({
-    input: inputPath,
-    plugins: [dts(), ...nodePlugIns],
-    onwarn(warning, warn) {
-      if (warning.code === "UNUSED_EXTERNAL_IMPORT") return;
-      warn(warning);
-    }
-  });
-  await bundle.write({
-    file: outputPath,
-    format: "es"
-  });
-  console.log(`Bundled declarations written to ${outputPath}`);
+var ignoredWarningCodes = /* @__PURE__ */ new Set([
+  "EMPTY_BUNDLE",
+  "UNRESOLVED_IMPORT"
+]);
+async function bundleDts(inputPath, outputPath, platform, options, verbose = false) {
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const tsconfigPath = path3.resolve(pkg, "tsconfig.json");
+  const nodePlugIns = platform === "node" ? [
+    nodeExternals()
+  ] : [];
+  try {
+    const bundle = await rollup({
+      input: inputPath,
+      plugins: [
+        dts({
+          ...options,
+          tsconfig: tsconfigPath,
+          compilerOptions: {
+            emitDeclarationOnly: true,
+            noEmit: false,
+            declarationMap: true
+          }
+        }),
+        ...nodePlugIns
+      ],
+      onwarn(warning, warn) {
+        if (ignoredWarningCodes.has(warning.code ?? "")) {
+          return;
+        }
+        console.warn(chalk6.yellow(`[${warning.code}] ${warning.message}`));
+        console.warn(chalk6.gray(inputPath));
+        warn(warning);
+      }
+    });
+    await bundle.write({
+      file: outputPath,
+      format: "es"
+    });
+  } catch (ex) {
+    const error = ex;
+    console.warn(chalk6.red(error));
+    console.warn(chalk6.gray(inputPath));
+  }
+  if (verbose) {
+    console.log(`Bundled declarations written to ${outputPath}`);
+  }
 }
-var packageCompileTscTypes = async (entries, outDir, platform, folder = "src") => {
-  const pkg = process.env.INIT_CWD ?? cwd();
-  const srcRoot = `${pkg}/${folder}`;
-  const entryNameToTypeName = (entry) => {
+__name(bundleDts, "bundleDts");
+var packageCompileTscTypes = /* @__PURE__ */ __name(async (entries, outDir, platform, srcDir = "build", verbose = false) => {
+  if (verbose) {
+    console.log(chalk6.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(`Entries: ${entries.join(", ")}`);
+  }
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const srcRoot = `${pkg}/${srcDir}/${platform}`;
+  const entryNameToTypeName = /* @__PURE__ */ __name((entry) => {
     const splitEntryName = entry.split(".");
     const newEntryExtension = "d." + splitEntryName.at(-1);
-    return [...splitEntryName.slice(0, -1), newEntryExtension].join(".");
-  };
-  const entryNames = entries.map((entry) => entry.split(`${folder}/`).at(-1) ?? entry);
+    return [
+      ...splitEntryName.slice(0, -1),
+      newEntryExtension
+    ].join(".");
+  }, "entryNameToTypeName");
+  const compilerOptions = getCompilerOptions({
+    removeComments: false,
+    skipDefaultLibCheck: true,
+    skipLibCheck: true,
+    declarationMap: true,
+    emitDeclarationOnly: true,
+    noEmit: true
+  });
+  const entryNames = entries.map((entry) => entry.split(`${srcDir}/`).at(-1) ?? entry);
   await Promise.all(entryNames.map(async (entryName) => {
-    await bundleDts(`${srcRoot}/${entryName}`, outDir + "/" + entryNameToTypeName(entryName), platform);
+    const entryTypeName = entryNameToTypeName(entryName);
+    await bundleDts(`${srcRoot}/${entryTypeName}`, `${outDir}/${entryTypeName}`, platform, {
+      compilerOptions
+    }, verbose);
   }));
+  if (verbose) {
+    console.log(chalk6.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+  }
   return 0;
-};
+}, "packageCompileTscTypes");
 
 // src/actions/package/compile/packageCompileTsup.ts
-var compileFolder = async (folder, entries, options, verbose) => {
+var compileFolder = /* @__PURE__ */ __name(async (srcDir, entries, buildDir, options, bundleTypes = false, verbose) => {
   const outDir = options?.outDir ?? "dist";
   if (verbose) {
-    console.log(`compileFolder [${folder}]`);
+    console.log(`compileFolder [${srcDir}, ${options?.outDir}]`);
   }
-  const optionsResult = defineConfig({
-    bundle: true,
-    cjsInterop: true,
-    clean: true,
-    dts: false,
-    entry: entries,
-    format: ["esm"],
-    outDir,
-    silent: true,
-    sourcemap: true,
-    splitting: 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();
+  if (entries.length === 0) {
+    console.warn(chalk7.yellow(`No entries found in ${srcDir} to compile`));
+    return 0;
+  }
+  if (verbose) {
+    console.log(chalk7.gray(`buildDir [${buildDir}]`));
+  }
+  const validationResult = packageCompileTsc(options?.platform ?? "neutral", entries, srcDir, buildDir, void 0, verbose);
+  if (validationResult !== 0) {
+    console.error(chalk7.red(`Compile:Validation had ${validationResult} errors`));
+    return validationResult;
+  }
+  const optionsParams = tsupOptions([
+    {
+      bundle: true,
+      cjsInterop: true,
+      clean: false,
+      dts: false,
+      format: [
+        "esm"
+      ],
+      outDir,
+      silent: true,
+      sourcemap: true,
+      splitting: false,
+      tsconfig: "tsconfig.json",
+      ...options,
+      entry: entries.map((entry) => `${srcDir}/${entry}`)
+    }
+  ]);
+  const optionsResult = defineConfig(optionsParams);
+  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();
   if (verbose) {
-    console.log(`TSUP:build:start [${folder}]`);
+    console.log(chalk7.cyan(`TSUP:build:start [${srcDir}]`));
+    console.log(chalk7.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
   }
   await Promise.all(optionsList.map((options2) => build(options2)));
   if (verbose) {
-    console.log(`TSUP:build:stop [${folder}]`);
+    console.log(chalk7.cyan(`TSUP:build:stop [${srcDir}]`));
+  }
+  if (bundleTypes) {
+    await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", buildDir, verbose);
   }
-  await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", folder);
   return 0;
-};
-var tsupOptions = (options = []) => {
+}, "compileFolder");
+var tsupOptions = /* @__PURE__ */ __name((options = []) => {
   const standardLoaders = {
     ".gif": "copy",
     ".html": "copy",
     ".jpg": "copy",
     ".json": "json",
     ".png": "copy",
-    ".svg": "copy",
+    ".svg": "text",
     ".webp": "copy"
   };
   const standardOptions = {
     bundle: true,
-    format: ["esm"],
+    format: [
+      "esm"
+    ],
     loader: standardLoaders,
-    outExtension: ({ format }) => format === "esm" ? { js: ".mjs" } : { js: ".cjs" },
+    outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+      js: ".mjs"
+    } : {
+      js: ".cjs"
+    }, "outExtension"),
     skipNodeModulesBundle: true,
     sourcemap: true,
     target: "esnext"
   };
-  return deepMergeObjects([standardOptions, ...options]);
-};
-var packageCompileTsup = async (config2) => {
+  return deepMergeObjects([
+    standardOptions,
+    ...options
+  ]);
+}, "tsupOptions");
+var packageCompileTsup = /* @__PURE__ */ __name(async (config2) => {
   const compile = config2?.compile;
   const verbose = config2?.verbose ?? false;
+  const outDirAsBuildDir = compile?.outDirAsBuildDir ?? true;
+  const bundleTypes = compile?.bundleTypes ?? 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: {} };
-  if (verbose) {
-    console.log("Calling packageCompileTscTypes");
+    console.log("Compiling with TSUP");
   }
-  return (await Promise.all(
-    Object.entries(compileForNode).map(async ([folder, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile?.node?.esbuildOptions === "object" ? compile?.node?.esbuildOptions : {};
-      return typeof folder === "string" ? await compileFolder(
-        folder,
-        buildEntries(folder, compile?.entryMode, options, true, verbose),
-        tsupOptions([
-          inEsBuildOptions,
-          compile?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "node", outDir: optionsObject.outDir ?? "dist/node" }
-        ]),
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
-    Object.entries(compileForBrowser).map(async ([folder, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile?.browser?.esbuildOptions === "object" ? compile?.browser?.esbuildOptions : {};
-      return typeof folder === "string" ? await compileFolder(
-        folder,
-        buildEntries(folder, compile?.entryMode, options, true, verbose),
-        tsupOptions([
-          inEsBuildOptions,
-          compile?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "browser", outDir: optionsObject.outDir ?? "dist/browser" }
-        ]),
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
-    Object.entries(compileForNeutral).map(async ([folder, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile?.neutral?.esbuildOptions === "object" ? compile?.neutral?.esbuildOptions : {};
-      return typeof folder === "string" ? await compileFolder(
-        folder,
-        buildEntries(folder, compile?.entryMode, options, true, verbose),
-        tsupOptions([
-          inEsBuildOptions,
-          compile?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "neutral", outDir: optionsObject.outDir ?? "dist/neutral" }
-        ]),
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + 0;
-};
+  const compileForNode = compile?.node ?? {
+    src: {}
+  };
+  const compileForBrowser = compile?.browser ?? {
+    src: {}
+  };
+  const compileForNeutral = compile?.neutral ?? {
+    src: {}
+  };
+  return (await Promise.all(Object.entries(compileForNode).map(async ([srcDir, options]) => {
+    const optionsObject = typeof options === "object" ? options : {};
+    const inEsBuildOptions = typeof compile?.node?.esbuildOptions === "object" ? compile?.node?.esbuildOptions : {};
+    const entry = buildEntries(srcDir, compile?.entryMode, options, true, verbose);
+    const platform = "node";
+    const rootOutDir = optionsObject.outDir ?? "dist";
+    const outDir = rootOutDir + "/" + platform;
+    return typeof srcDir === "string" ? await compileFolder(srcDir, entry, outDirAsBuildDir ? rootOutDir : "build", tsupOptions([
+      inEsBuildOptions,
+      compile?.tsup?.options ?? {},
+      typeof options === "object" ? options : {},
+      {
+        platform: "node",
+        outDir
+      }
+    ]), bundleTypes, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) + (await Promise.all(Object.entries(compileForBrowser).map(async ([srcDir, options]) => {
+    const optionsObject = typeof options === "object" ? options : {};
+    const inEsBuildOptions = typeof compile?.browser?.esbuildOptions === "object" ? compile?.browser?.esbuildOptions : {};
+    const entry = buildEntries(srcDir, compile?.entryMode, options, true, verbose);
+    const platform = "browser";
+    const rootOutDir = optionsObject.outDir ?? "dist";
+    const outDir = rootOutDir + "/" + platform;
+    return typeof srcDir === "string" ? await compileFolder(srcDir, entry, outDirAsBuildDir ? rootOutDir : "build", tsupOptions([
+      inEsBuildOptions,
+      compile?.tsup?.options ?? {},
+      typeof options === "object" ? options : {},
+      {
+        platform: "browser",
+        outDir
+      }
+    ]), bundleTypes, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) + (await Promise.all(Object.entries(compileForNeutral).map(async ([srcDir, options]) => {
+    const optionsObject = typeof options === "object" ? options : {};
+    const inEsBuildOptions = typeof compile?.neutral?.esbuildOptions === "object" ? compile?.neutral?.esbuildOptions : {};
+    const entry = buildEntries(srcDir, compile?.entryMode, options, true, verbose);
+    const platform = "neutral";
+    const rootOutDir = optionsObject.outDir ?? "dist";
+    const outDir = rootOutDir + "/" + platform;
+    return typeof srcDir === "string" ? await compileFolder(srcDir, entry, outDirAsBuildDir ? rootOutDir : "build", tsupOptions([
+      inEsBuildOptions,
+      compile?.tsup?.options ?? {},
+      typeof options === "object" ? options : {},
+      {
+        platform: "neutral",
+        outDir
+      }
+    ]), bundleTypes, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) + 0;
+}, "packageCompileTsup");
 
 // src/actions/package/compile/compile.ts
-var packageCompile = async (inConfig = {}) => {
+var packageCompile = /* @__PURE__ */ __name(async (inConfig = {}) => {
   const pkg = process.env.INIT_CWD;
-  console.log(chalk5.green(`Compiling ${pkg}`));
+  console.log(chalk8.green(`Compiling ${pkg}`));
   const config2 = await loadConfig(inConfig);
-  const publint = config2.publint;
-  const tsupResults = await packageCompileTsup(config2);
-  if (tsupResults > 0) {
-    return tsupResults;
-  }
-  return publint ? await packagePublint(config2) : 0;
-};
+  return await packageCompileTsup(config2);
+}, "packageCompile");
 
 // src/actions/package/recompile.ts
-var packageRecompile = async () => {
+var packageRecompile = /* @__PURE__ */ __name(async () => {
   return await packageClean() || await packageCompile();
-};
+}, "packageRecompile");
 export {
   packageRecompile
 };