@sse-ui/builder 1.0.2 → 1.1.0

package/dist/{babel-VTL3CZAT.js → babel-QBNMMXUJ.js}

@@ -1,6 +1,6 @@
 import {
   BASE_IGNORES
-} from "./chunk-5S2N5WDQ.js";
+} from "./chunk-44E7L73Q.js";
 
 // src/utils/babel.ts
 import { findWorkspacesRoot } from "find-workspaces";

package/dist/{chunk-5S2N5WDQ.js → chunk-44E7L73Q.js}

@@ -168,7 +168,8 @@ async function createPackageExports({
   cwd,
   addTypes = false,
   isFlat = false,
-  packageType = "commonjs"
+  packageType = "commonjs",
+  exportExtensions = [".js", ".mjs", ".cjs"]
 }) {
   const resolvedPackageType = packageType === "module" ? "module" : "commonjs";
   const rawExports = typeof packageExports === "string" || Array.isArray(packageExports) ? { ".": packageExports } : packageExports || {};
@@ -179,8 +180,29 @@ async function createPackageExports({
   const result = {
     exports: newExports
   };
-  await Promise.all(
-    bundles.map(async ({ type, dir }) => {
+  const baseBundle = bundles.find((b) => b.type === "esm") || bundles[0];
+  const scanDir = isFlat ? outputDir : path.join(outputDir, baseBundle.dir);
+  const buildFiles = await globby("**/*", { cwd: scanDir });
+  const jsDirs = /* @__PURE__ */ new Set();
+  const otherFiles = /* @__PURE__ */ new Set();
+  for (const file of buildFiles) {
+    if (file.endsWith(".d.ts") || file.endsWith(".d.mts") || file.endsWith(".d.cts")) {
+      continue;
+    }
+    const ext = path.extname(file);
+    const normalizedFile = file.split(path.sep).join(path.posix.sep);
+    if (exportExtensions.includes(ext)) {
+      jsDirs.add(path.posix.dirname(normalizedFile));
+    } else {
+      otherFiles.add(normalizedFile);
+    }
+  }
+  const getIndexFileName = (type) => `index${getOutExtension(type, { isFlat, packageType: resolvedPackageType })}`;
+  const rootIndexExists = await fs.stat(path.join(scanDir, getIndexFileName(baseBundle.type))).then((s) => s.isFile()).catch(() => false);
+  if (rootIndexExists && originalExports["."] === void 0) {
+    newExports["."] ??= {};
+    const rootConditions = newExports["."];
+    for (const { type, dir: bundleDir } of bundles) {
       const outExtension = getOutExtension(type, {
         isFlat,
         packageType: resolvedPackageType
@@ -190,59 +212,157 @@ async function createPackageExports({
         isType: true,
         packageType: resolvedPackageType
       });
-      const indexFileExists = await fs.stat(path.join(outputDir, dir, `index${outExtension}`)).then(
-        (stats) => stats.isFile(),
-        () => false
-      );
-      const typeFileExists = addTypes && await fs.stat(path.join(outputDir, dir, `index${typeOutExtension}`)).then(
-        (stats) => stats.isFile(),
-        () => false
-      );
-      const dirPrefix = dir === "." ? "" : `${dir}/`;
-      const exportDir = `./${dirPrefix}index${outExtension}`;
-      const typeExportDir = `./${dirPrefix}index${typeOutExtension}`;
-      if (indexFileExists) {
-        if (type === "cjs") {
-          result.main = exportDir;
-        }
-        if (typeof newExports["."] === "string" || Array.isArray(newExports["."])) {
-          throw new Error(
-            `The export "." is already defined as a string or Array.`
-          );
-        }
-        newExports["."] ??= {};
-        newExports["."][type === "cjs" ? "require" : "import"] = typeFileExists ? {
-          types: typeExportDir,
-          default: exportDir
-        } : exportDir;
+      const dirPrefix = bundleDir === "." ? "" : `${bundleDir}/`;
+      const exportPath = `./${dirPrefix}index${outExtension}`;
+      const typeExportPath = `./${dirPrefix}index${typeOutExtension}`;
+      const typeExists = addTypes && await fs.stat(path.join(outputDir, bundleDir, `index${typeOutExtension}`)).then((s) => s.isFile()).catch(() => false);
+      const conditionKey = type === "cjs" ? "require" : "import";
+      rootConditions[conditionKey] = typeExists ? { types: typeExportPath, default: exportPath } : exportPath;
+      if (type === "cjs" || type === "esm" && bundles.length === 1) {
+        result.main = exportPath;
+        if (typeExists) result.types = typeExportPath;
       }
-      if (typeFileExists && type === "cjs") {
-        result.types = typeExportDir;
+    }
+  }
+  for (const dir of jsDirs) {
+    const globKey = dir === "." ? "./*" : `./${dir}/*`;
+    if (originalExports[globKey] === void 0) {
+      newExports[globKey] ??= {};
+      const globConditions = newExports[globKey];
+      for (const { type, dir: bundleDir } of bundles) {
+        const outExtension = getOutExtension(type, {
+          isFlat,
+          packageType: resolvedPackageType
+        });
+        const typeOutExtension = getOutExtension(type, {
+          isFlat,
+          isType: true,
+          packageType: resolvedPackageType
+        });
+        const dirPrefix = bundleDir === "." ? "" : `${bundleDir}/`;
+        const basePath = dir === "." ? "" : `${dir}/`;
+        const exportPath = `./${dirPrefix}${basePath}*${outExtension}`;
+        const typeExportPath = `./${dirPrefix}${basePath}*${typeOutExtension}`;
+        const conditionKey = type === "cjs" ? "require" : "import";
+        globConditions[conditionKey] = addTypes ? { types: typeExportPath, default: exportPath } : exportPath;
       }
-      const exportKeys = Object.keys(originalExports);
-      for (const key of exportKeys) {
-        const importPath = originalExports[key];
-        if (!importPath) {
-          newExports[key] = null;
-          continue;
+    }
+    if (dir !== ".") {
+      const dirIndexExists = await fs.stat(path.posix.join(scanDir, dir, getIndexFileName(baseBundle.type))).then((s) => s.isFile()).catch(() => false);
+      const dirKey = `./${dir}`;
+      if (dirIndexExists && originalExports[dirKey] === void 0) {
+        newExports[dirKey] ??= {};
+        const dirConditions = newExports[dirKey];
+        for (const { type, dir: bundleDir } of bundles) {
+          const outExtension = getOutExtension(type, {
+            isFlat,
+            packageType: resolvedPackageType
+          });
+          const typeOutExtension = getOutExtension(type, {
+            isFlat,
+            isType: true,
+            packageType: resolvedPackageType
+          });
+          const dirPrefix = bundleDir === "." ? "" : `${bundleDir}/`;
+          const basePath = `${dir}/`;
+          const exportPath = `./${dirPrefix}${basePath}index${outExtension}`;
+          const typeExportPath = `./${dirPrefix}${basePath}index${typeOutExtension}`;
+          const typeExists = addTypes && await fs.stat(
+            path.join(
+              outputDir,
+              bundleDir,
+              dir,
+              `index${typeOutExtension}`
+            )
+          ).then((s) => s.isFile()).catch(() => false);
+          const conditionKey = type === "cjs" ? "require" : "import";
+          dirConditions[conditionKey] = typeExists ? { types: typeExportPath, default: exportPath } : exportPath;
         }
-        await createExportsFor({
-          importPath,
-          key,
-          cwd,
-          dir,
-          type,
-          newExports,
-          typeOutExtension,
-          outExtension,
-          addTypes
-        });
       }
-    })
-  );
+    }
+  }
+  for (const file of otherFiles) {
+    const exportKey = `./${file}`;
+    if (originalExports[exportKey] !== void 0) continue;
+    const dirPrefix = baseBundle.dir === "." ? "" : `${baseBundle.dir}/`;
+    newExports[exportKey] = `./${dirPrefix}${file}`;
+  }
+  const exportKeys = Object.keys(originalExports);
+  for (const key of exportKeys) {
+    const importPath = originalExports[key];
+    if (!importPath) {
+      newExports[key] = null;
+      continue;
+    }
+    if (key === ".") continue;
+    await Promise.all(
+      bundles.map(async ({ type, dir }) => {
+        const outExtension = getOutExtension(type, {
+          isFlat,
+          packageType: resolvedPackageType
+        });
+        const typeOutExtension = getOutExtension(type, {
+          isFlat,
+          isType: true,
+          packageType: resolvedPackageType
+        });
+        const indexFileExists = await fs.stat(path.join(outputDir, dir, `index${outExtension}`)).then(
+          (stats) => stats.isFile(),
+          () => false
+        );
+        const typeFileExists = addTypes && await fs.stat(path.join(outputDir, dir, `index${typeOutExtension}`)).then(
+          (stats) => stats.isFile(),
+          () => false
+        );
+        const dirPrefix = dir === "." ? "" : `${dir}/`;
+        const exportDir = `./${dirPrefix}index${outExtension}`;
+        const typeExportDir = `./${dirPrefix}index${typeOutExtension}`;
+        if (indexFileExists && originalExports["."] !== void 0) {
+          if (type === "cjs") {
+            result.main = exportDir;
+          }
+          if (typeof newExports["."] === "string" || Array.isArray(newExports["."])) {
+            throw new Error(
+              `The export "." is already defined as a string or Array.`
+            );
+          }
+          newExports["."] ??= {};
+          const rootConditions = newExports["."];
+          rootConditions[type === "cjs" ? "require" : "import"] = typeFileExists ? {
+            types: typeExportDir,
+            default: exportDir
+          } : exportDir;
+        }
+        if (typeFileExists && type === "cjs") {
+          result.types = typeExportDir;
+        }
+        const exportKeys2 = Object.keys(originalExports);
+        for (const key2 of exportKeys2) {
+          const importPath2 = originalExports[key2];
+          if (!importPath2) {
+            newExports[key2] = null;
+            continue;
+          }
+          if (key2 === ".") continue;
+          await createExportsFor({
+            importPath: importPath2,
+            key: key2,
+            cwd,
+            dir,
+            type,
+            newExports,
+            typeOutExtension,
+            outExtension,
+            addTypes
+          });
+        }
+      })
+    );
+  }
   bundles.forEach(({ dir }) => {
     if (dir !== ".") {
       newExports[`./${dir}`] = null;
+      newExports[`./${dir}/*`] = null;
     }
   });
   Object.keys(newExports).forEach((key) => {
@@ -390,12 +510,101 @@ async function mapConcurrently(items, mapper, concurrency) {
   await Promise.all(workers);
   return results;
 }
+async function addLicense({
+  name,
+  version,
+  license,
+  bundle,
+  outputDir,
+  isFlat,
+  packageType
+}) {
+  const outExtension = getOutExtension(bundle, { isFlat, packageType });
+  const file = path.join(outputDir, `index${outExtension}`);
+  if (!await fs.stat(file).then(
+    (stats) => stats.isFile(),
+    () => false
+  )) {
+    return;
+  }
+  const content = await fs.readFile(file, { encoding: "utf8" });
+  await fs.writeFile(
+    file,
+    `/**
+ * ${name} v${version}
+ *
+ * @license ${license}
+ * This source code is licensed under the ${license} license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+${content}`,
+    { encoding: "utf8" }
+  );
+  if (process.env.SSE_BUILD_VERBOSE) console.log(`License added to ${file}`);
+}
+async function writePackageJson({
+  packageJson,
+  bundles,
+  outputDir,
+  cwd,
+  addTypes = false,
+  isFlat = false,
+  packageType,
+  exportExtensions
+}) {
+  delete packageJson.scripts;
+  delete packageJson.publishConfig?.directory;
+  delete packageJson.devDependencies;
+  delete packageJson.imports;
+  const resolvedPackageType = packageType || packageJson.type || "commonjs";
+  packageJson.type = resolvedPackageType;
+  const originalExports = packageJson.exports;
+  delete packageJson.exports;
+  const originalBin = packageJson.bin;
+  delete packageJson.bin;
+  const {
+    exports: packageExports,
+    main,
+    types
+  } = await createPackageExports({
+    exports: originalExports,
+    bundles,
+    outputDir,
+    cwd,
+    addTypes,
+    isFlat,
+    packageType: resolvedPackageType,
+    exportExtensions
+  });
+  packageJson.exports = packageExports;
+  if (main) {
+    packageJson.main = main;
+  }
+  if (types) {
+    packageJson.types = types;
+  }
+  const bin = await createPackageBin({
+    bin: originalBin,
+    bundles,
+    cwd,
+    isFlat,
+    packageType: resolvedPackageType
+  });
+  if (bin) {
+    packageJson.bin = bin;
+  }
+  await fs.writeFile(
+    path.join(outputDir, "package.json"),
+    JSON.stringify(packageJson, null, 2),
+    "utf-8"
+  );
+}
 
 export {
   getOutExtension,
-  createPackageExports,
-  createPackageBin,
   validatePkgJson,
   BASE_IGNORES,
-  mapConcurrently
+  mapConcurrently,
+  addLicense,
+  writePackageJson
 };

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
-  createPackageBin,
-  createPackageExports,
+  addLicense,
   getOutExtension,
   mapConcurrently,
-  validatePkgJson
-} from "./chunk-5S2N5WDQ.js";
+  validatePkgJson,
+  writePackageJson
+} from "./chunk-44E7L73Q.js";
 
 // src/cli.ts
 import { Command as Command11 } from "commander";
@@ -19,6 +19,7 @@ import * as path from "path";
 import { sep as posixSep } from "path/posix";
 import * as semver from "semver";
 import { Command } from "commander";
+import { build as esbuild } from "esbuild";
 
 // src/utils/loadConfig.ts
 import { loadConfig as loadC12Config } from "c12";
@@ -41,93 +42,6 @@ async function loadConfig() {
 }
 
 // src/core/build.ts
-async function addLicense({
-  name,
-  version,
-  license,
-  bundle,
-  outputDir,
-  isFlat,
-  packageType
-}) {
-  const outExtension = getOutExtension(bundle, { isFlat, packageType });
-  const file = path.join(outputDir, `index${outExtension}`);
-  if (!await fs.stat(file).then(
-    (stats) => stats.isFile(),
-    () => false
-  )) {
-    return;
-  }
-  const content = await fs.readFile(file, { encoding: "utf8" });
-  await fs.writeFile(
-    file,
-    `/**
- * ${name} v${version}
- *
- * @license ${license}
- * This source code is licensed under the ${license} license found in the
- * LICENSE file in the root directory of this source tree.
- */
-${content}`,
-    { encoding: "utf8" }
-  );
-  console.log(`License added to ${file}`);
-}
-async function writePackageJson({
-  packageJson,
-  bundles,
-  outputDir,
-  cwd,
-  addTypes = false,
-  isFlat = false,
-  packageType
-}) {
-  delete packageJson.scripts;
-  delete packageJson.publishConfig?.directory;
-  delete packageJson.devDependencies;
-  delete packageJson.imports;
-  const resolvedPackageType = packageType || packageJson.type || "commonjs";
-  packageJson.type = resolvedPackageType;
-  const originalExports = packageJson.exports;
-  delete packageJson.exports;
-  const originalBin = packageJson.bin;
-  delete packageJson.bin;
-  const {
-    exports: packageExports,
-    main: main2,
-    types
-  } = await createPackageExports({
-    exports: originalExports,
-    bundles,
-    outputDir,
-    cwd,
-    addTypes,
-    isFlat,
-    packageType: resolvedPackageType
-  });
-  packageJson.exports = packageExports;
-  if (main2) {
-    packageJson.main = main2;
-  }
-  if (types) {
-    packageJson.types = types;
-  }
-  const bin = await createPackageBin({
-    bin: originalBin,
-    bundles,
-    cwd,
-    isFlat,
-    packageType: resolvedPackageType
-  });
-  if (bin) {
-    packageJson.bin = bin;
-  }
-  await fs.writeFile(
-    path.join(outputDir, "package.json"),
-    JSON.stringify(packageJson, null, 2),
-    "utf-8"
-  );
-}
 var buildCommand = new Command("build").description("Builds the package for publishing.").option("--bundle <bundles...>", "Bundles to output", ["esm", "cjs"]).option(
   "--hasLargeFiles",
   "Set to `true` if you know you are transpiling large files.",
@@ -164,6 +78,14 @@ var buildCommand = new Command("build").description("Builds the package for publ
   "--flat",
   "Builds the package in a flat structure without subdirectories for each module type.",
   process.env.SSE_BUILD_FLAT === "1"
+).option(
+  "--bundleSingleFile",
+  "Bundle all modules into single files using esbuild (tsup style)",
+  false
+).option(
+  "--exportExtensions <exts...>",
+  "Available extensions for generating exports wildcards.",
+  [".js", ".mjs", ".cjs"]
 ).option("--verbose", "Enable verbose logging.", false).action(async (cliOptions) => {
   const fileConfig = await loadConfig();
   const options = {
@@ -180,7 +102,9 @@ var buildCommand = new Command("build").description("Builds the package for publ
     verbose: cliOptions.verbose ?? fileConfig.verbose ?? false,
     skipBabelRuntimeCheck: false,
     skipPackageJson: false,
-    skipMainCheck: false
+    skipMainCheck: false,
+    bundleSingleFile: cliOptions.bundleSingleFile ?? fileConfig.bundleSingleFile ?? false,
+    exportExtensions: cliOptions.exportExtensions ?? fileConfig.exportExtensions ?? [".js", ".mjs", ".cjs"]
   };
   const {
     bundle: bundles,
@@ -193,7 +117,9 @@ var buildCommand = new Command("build").description("Builds the package for publ
     skipBabelRuntimeCheck = false,
     skipPackageJson = false,
     enableReactCompiler = false,
-    tsgo: useTsgo = false
+    tsgo: useTsgo = false,
+    bundleSingleFile,
+    exportExtensions
   } = options;
   const cwd = process.cwd();
   const pkgJsonPath = path.join(cwd, "package.json");
@@ -229,7 +155,7 @@ var buildCommand = new Command("build").description("Builds the package for publ
     );
     return;
   }
-  const { build: babelBuild, cjsCopy } = await import("./babel-VTL3CZAT.js");
+  const { build: babelBuild, cjsCopy } = await import("./babel-QBNMMXUJ.js");
   const relativeOutDirs = !options.flat ? {
     cjs: ".",
     esm: "esm"
@@ -245,67 +171,114 @@ var buildCommand = new Command("build").description("Builds the package for publ
       `[feature] Building with React compiler enabled. The compiler mode is "${mode}" right now.${mode === "opt-in" ? ' Use explicit "use memo" directives in your components to enable the React compiler for them.' : ""}`
     );
   }
-  await Promise.all(
-    bundles.map(async (bundle) => {
-      const outExtension = getOutExtension(bundle, {
-        isFlat: !!options.flat,
-        isType: false,
-        packageType
-      });
-      const relativeOutDir = relativeOutDirs[bundle];
-      const outputDir = path.join(buildDir, relativeOutDir);
-      await fs.mkdir(outputDir, { recursive: true });
-      const promises = [];
-      promises.push(
-        babelBuild({
-          cwd,
-          sourceDir,
-          outDir: outputDir,
-          babelRuntimeVersion,
-          hasLargeFiles,
-          bundle,
-          verbose,
-          optimizeClsx: packageJson.dependencies?.clsx !== void 0 || packageJson.dependencies?.classnames !== void 0,
-          removePropTypes: packageJson.dependencies?.["prop-types"] !== void 0,
-          pkgVersion: packageJson.version,
-          ignores: extraIgnores,
-          outExtension,
-          reactCompiler: enableReactCompiler ? {
-            reactVersion: reactVersion || "latest"
-          } : void 0
-        })
-      );
-      if (buildDir !== outputDir && !skipBundlePackageJson && !options.flat) {
-        promises.push(
-          fs.writeFile(
+  if (bundleSingleFile) {
+    if (verbose)
+      console.log("\u{1F4E6} Bundling package into single files via esbuild...");
+    await Promise.all(
+      bundles.map(async (bundle) => {
+        const outExtension = getOutExtension(bundle, {
+          isFlat: !!options.flat,
+          isType: false,
+          packageType
+        });
+        const relativeOutDir = relativeOutDirs[bundle];
+        const outputDir = path.join(buildDir, relativeOutDir);
+        await fs.mkdir(outputDir, { recursive: true });
+        await esbuild({
+          entryPoints: [path.join(sourceDir, "index.ts")],
+          bundle: true,
+          outfile: path.join(outputDir, `index${outExtension}`),
+          format: bundle === "esm" ? "esm" : "cjs",
+          target: ["es2020", "node14"],
+          minify: false,
+          external: [
+            ...Object.keys(packageJson.dependencies || {}),
+            ...Object.keys(packageJson.peerDependencies || {})
+          ]
+        });
+        if (buildDir !== outputDir && !skipBundlePackageJson && !options.flat) {
+          await fs.writeFile(
             path.join(outputDir, "package.json"),
             JSON.stringify({
               type: bundle === "esm" ? "module" : "commonjs",
               sideEffects: packageJson.sideEffects ?? false
             })
-          )
+          );
+        }
+        await addLicense({
+          bundle,
+          license: packageJson.license,
+          name: packageJson.name,
+          version: packageJson.version,
+          outputDir,
+          isFlat: !!options.flat,
+          packageType
+        });
+      })
+    );
+  } else {
+    await Promise.all(
+      bundles.map(async (bundle) => {
+        const outExtension = getOutExtension(bundle, {
+          isFlat: !!options.flat,
+          isType: false,
+          packageType
+        });
+        const relativeOutDir = relativeOutDirs[bundle];
+        const outputDir = path.join(buildDir, relativeOutDir);
+        await fs.mkdir(outputDir, { recursive: true });
+        const promises = [];
+        promises.push(
+          babelBuild({
+            cwd,
+            sourceDir,
+            outDir: outputDir,
+            babelRuntimeVersion,
+            hasLargeFiles,
+            bundle,
+            verbose,
+            optimizeClsx: packageJson.dependencies?.clsx !== void 0 || packageJson.dependencies?.classnames !== void 0,
+            removePropTypes: packageJson.dependencies?.["prop-types"] !== void 0,
+            pkgVersion: packageJson.version,
+            ignores: extraIgnores,
+            outExtension,
+            reactCompiler: enableReactCompiler ? {
+              reactVersion: reactVersion || "latest"
+            } : void 0
+          })
         );
-      }
-      if (!options.flat) {
-        promises.push(cjsCopy({ from: sourceDir, to: outputDir }));
-      }
-      await Promise.all(promises);
-      await addLicense({
-        bundle,
-        license: packageJson.license,
-        name: packageJson.name,
-        version: packageJson.version,
-        outputDir,
-        isFlat: !!options.flat,
-        packageType
-      });
-    })
-  );
-  if (options.flat) {
-    await cjsCopy({ from: sourceDir, to: buildDir });
+        if (buildDir !== outputDir && !skipBundlePackageJson && !options.flat) {
+          promises.push(
+            fs.writeFile(
+              path.join(outputDir, "package.json"),
+              JSON.stringify({
+                type: bundle === "esm" ? "module" : "commonjs",
+                sideEffects: packageJson.sideEffects ?? false
+              })
+            )
+          );
+        }
+        if (!options.flat) {
+          promises.push(cjsCopy({ from: sourceDir, to: outputDir }));
+        }
+        await Promise.all(promises);
+        await addLicense({
+          bundle,
+          license: packageJson.license,
+          name: packageJson.name,
+          version: packageJson.version,
+          outputDir,
+          isFlat: !!options.flat,
+          packageType
+        });
+      })
+    );
+    if (options.flat) {
+      await cjsCopy({ from: sourceDir, to: buildDir });
+    }
   }
   if (buildTypes) {
-    const tsMod = await import("./typescript-CS6YZCMJ.js");
+    const tsMod = await import("./typescript-3J237V7Q.js");
     const bundleMap = bundles.map((type) => ({
       type,
       dir: relativeOutDirs[type]
@@ -336,7 +309,8 @@ var buildCommand = new Command("build").description("Builds the package for publ
     outputDir: buildDir,
     addTypes: buildTypes,
     isFlat: !!options.flat,
-    packageType
+    packageType,
+    exportExtensions: options.exportExtensions
   });
   await copyHandler({
     cwd,

package/dist/config.d.ts

@@ -29,11 +29,18 @@ interface BuildOptions {
     tsgo: boolean;
     /** Builds the package in a flat structure without subdirectories for each module type. */
     flat: boolean;
+    /** Bundle the package into single files for each format using esbuild (tsup style). */
+    bundleSingleFile: boolean;
+    /**
+     * Available extensions for generating exports wildcards.
+     * @default [".js", ".mjs", ".cjs"]
+     */
+    exportExtensions: string[];
 }
 
 /**
  * Helper to provide autocomplete and type checking for the sse-tools config.
  */
-declare function defineConfig(config: BuildOptions): BuildOptions;
+declare function defineConfig(config: Partial<BuildOptions>): Partial<BuildOptions>;
 
 export { type BuildOptions, defineConfig };

package/dist/{typescript-CS6YZCMJ.js → typescript-3J237V7Q.js}

@@ -1,7 +1,7 @@
 import {
   getOutExtension,
   mapConcurrently
-} from "./chunk-5S2N5WDQ.js";
+} from "./chunk-44E7L73Q.js";
 
 // src/utils/typescript.ts
 import * as babel from "@babel/core";

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@sse-ui/builder",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Builder By SSE",
   "type": "module",
   "scripts": {
     "build": "tsup",
     "prepublish": "npm run build"
   },
-  "main": "./bin/sse-tools.js",
-  "files": ["bin", "dist"],
+  "main": "./dist/cli.js",
+  "files": [
+    "dist"
+  ],
   "bin": {
-    "sse-tool": "./bin/sse-tools.js"
+    "sse-tools": "./dist/cli.js"
   },
   "exports": {
     "./babel-config": {
@@ -45,9 +47,11 @@
     "babel-plugin-transform-react-remove-prop-types": "^0.4.24",
     "c12": "^4.0.0-beta.3",
     "commander": "^14.0.3",
+    "esbuild": "^0.27.4",
     "execa": "^9.6.1",
     "find-workspaces": "^0.3.1",
     "globby": "^16.1.1",
+    "jiti": "^2.6.1",
     "minimatch": "^10.2.4",
     "mismatch": "^1.2.0",
     "semver": "^7.7.4"

package/bin/sse-tools.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import "../dist/cli.js";