@sse-ui/builder 1.3.0 → 1.3.1

package/README.md

@@ -0,0 +1,76 @@
+# @sse-ui/builder (sse-tools)
+
+`sse-tools` is a high-performance CLI utility designed for managing, building, and publishing software packages within the SSE ecosystem. It provides a unified interface for library development, supporting both Babel for individual file transpilation and esbuild for high-speed bundling.
+
+## ✨ Features
+
+- **Hybrid Builder Engine**: Seamlessly switch between Babel for detailed transpilation or esbuild for rapid bundling via simple configuration.
+- **Vite-style Watch Mode**: Features an incremental watcher that rebuilds only the specific files you change, significantly speeding up development loops.
+- **Intelligent Export Management**: Automatically generates and optimizes your package.json exports field based on your build output, supporting both flat and nested structures.
+- **TypeScript-First**: Built-in support for generating and bundling .d.ts declaration files using either standard tsc or the high-performance tsgo compiler.
+- **React Compiler Support**: Integrated support for the React compiler, including automatic environment configuration and peer-dependency validation.
+- **Interactive Versioning**: A CLI-guided versioning system that helps you bump package versions safely using SemVer standards.
+
+## 🚀 Installation
+
+Install the package as a development dependency:
+
+```bash
+npm install --save-dev @sse-ui/builder
+```
+
+## 🛠 Usage
+
+Once installed, you can access the utility via the `sse-tools` command.
+
+### Core Commands
+
+| Command         | Description                                                                          |
+| --------------- | ------------------------------------------------------------------------------------ |
+| `build`         | Compiles the package for production using Babel or esbuild.                          |
+| `watch`         | Starts an incremental rebuild watcher for rapid development.                         |
+| `typecheck`     | Validates TypeScript types across the project without emitting files.                |
+| `check-exports` | Verifies that all files declared in package.json actually exist in the build folder. |
+| `version`       | Interactively bumps the package version (patch, minor, major).                       |
+| `publish`       | Publishes the built package directly from your specified build directory.            |
+| `info`          | Displays size and file statistics for your built package.                            |
+| `clean`         | Safely removes the build directory to ensure a fresh start.                          |
+
+## ⚙️ Configuration
+
+`sse-tools` uses `c12` for robust configuration loading. You can define your configuration in `sse.config.ts`, `sse.config.js`, or within your `package.json`.
+
+```typescript
+import { defineConfig } from "@sse-ui/builder/config";
+
+export default defineConfig({
+  bundle: ["esm", "cjs"],
+  buildTypes: true,
+  flat: false,
+
+  // Use esbuild for bundling single files
+  esbuild: {
+    entry: "src/index.ts",
+    target: "es2022",
+  },
+});
+```
+
+### Build Options
+
+- `bundle`: Specify output formats, such as `["esm", "cjs"]`.
+- `flat`: When enabled, builds a flat structure instead of using format-specific subdirectories.
+- `copy`: Define an array of glob patterns to copy static assets or documentation into the build folder.
+- `tsgo`: Toggle between `tsc` and `tsgo` for faster type generation.
+
+## Docs
+
+Go to the Docs [click here](./docs)
+
+## Example
+
+Go to the Example [Click Here](./example)
+
+## 📄 License
+
+This project is licensed under the `MIT` License.

package/dist/{babel-6NHCDM3A.js → babel-2PBTAJV6.js}

@@ -4,7 +4,6 @@ import {
   getVersionEnvVariables
 } from "./chunk-6NNEV5YX.js";
 import "./chunk-N46AJ2OI.js";
-import "./chunk-MLKGABMK.js";
 export {
   build,
   cjsCopy,

package/dist/babel-config.js

@@ -1,5 +1,3 @@
-import "./chunk-MLKGABMK.js";
-
 // src/babel-config.ts
 import pluginTransformRuntime from "@ssets/babel/plugin/transform-runtime";
 import presetEnv from "@ssets/babel/preset/env";

package/dist/cli.js

@@ -9,7 +9,6 @@ import {
   validatePkgJson,
   writePackageJson
 } from "./chunk-N46AJ2OI.js";
-import "./chunk-MLKGABMK.js";
 
 // src/cli.ts
 import chalk11 from "chalk";
@@ -248,7 +247,7 @@ var buildCommand = new Command("build").description(chalk.cyan("Builds the packa
   } else {
     if (isVerbose)
       console.log(chalk.green("\u{1F4E6} Transpiling package via Babel..."));
-    const { build: babelBuild, cjsCopy } = await import("./babel-6NHCDM3A.js");
+    const { build: babelBuild, cjsCopy } = await import("./babel-2PBTAJV6.js");
     const hasLargeFiles = cliOptions.hasLargeFiles ?? fileConfig.babel?.hasLargeFiles ?? false;
     const extraIgnores = [
       ...fileConfig.babel?.ignore || [],
@@ -316,7 +315,7 @@ var buildCommand = new Command("build").description(chalk.cyan("Builds the packa
   if (buildTypes === true) {
     if (isVerbose)
       console.log(chalk.cyan("\u{1F4DD} Generating TypeScript declarations..."));
-    const tsMod = await import("./typescript-42L4XZEH.js");
+    const tsMod = await import("./typescript-2XUZHHI2.js");
     const bundleMap = bundles.map((type) => ({
       type,
       dir: relativeOutDirs[type]

package/dist/config.js

@@ -1,5 +1,3 @@
-import "./chunk-MLKGABMK.js";
-
 // src/config.ts
 function defineConfig(config) {
   return config;

package/dist/typescript-2XUZHHI2.js

@@ -0,0 +1,286 @@
+import {
+  getOutExtension,
+  mapConcurrently
+} from "./chunk-N46AJ2OI.js";
+
+// src/utils/typescript.ts
+import * as babel from "@babel/core";
+import pluginTypescriptSyntax from "@ssets/babel/plugin/syntax-typescript";
+import pluginResolveImports from "@ssets/babel/plugin/resolve-imports";
+import { findWorkspacesRoot } from "find-workspaces";
+import pluginRemoveImports from "@ssets/babel/plugin/transform-remove-imports";
+import { $ } from "execa";
+import { globby } from "globby";
+import { generateDtsBundle } from "@ssets/dts";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+import chalk from "chalk";
+var $$ = $({ stdio: "inherit" });
+async function findTsgo(cwd) {
+  const workspaceDir = await findWorkspacesRoot(cwd);
+  if (!workspaceDir) {
+    return null;
+  }
+  const tsgoPath = path.join(
+    workspaceDir.location,
+    "node_modules",
+    ".bin",
+    "tsgo"
+  );
+  const exists = await fs.stat(tsgoPath).then(
+    (stat2) => stat2.isFile(),
+    () => false
+  );
+  return exists ? tsgoPath : null;
+}
+async function emitDeclarations(tsconfig, outDir, options = {}) {
+  const { useTsgo = false } = options ?? {};
+  const tsconfigDir = path.dirname(tsconfig);
+  const rootDir = path.resolve(tsconfigDir, "./src");
+  const tsgoPath = useTsgo ? await findTsgo(tsconfigDir) : null;
+  if (useTsgo && !tsgoPath) {
+    throw new Error(
+      '--tsgo flag was passed or SSE_USE_TSGO environment was set but no tsgo cli was found. Either remove the flag to use tsc or install the native package "@typescript/native-preview" at the workspace level to use tsgo.'
+    );
+  }
+  if (tsgoPath) {
+    console.log(chalk.cyan("Using tsgo for declaration emit"));
+    await $$`${tsgoPath}
+      -p ${tsconfig}
+      --rootDir ${rootDir}
+      --outDir ${outDir}
+      --declaration
+      --emitDeclarationOnly
+      --noEmit false
+      --composite false
+      --incremental false
+      --declarationMap false`;
+  } else {
+    await $$`tsc
+      -p ${tsconfig}
+      --rootDir ${rootDir}
+      --outDir ${outDir}
+      --declaration
+      --emitDeclarationOnly
+      --noEmit false
+      --composite false
+      --incremental false
+      --declarationMap false`;
+  }
+}
+async function copyDeclarations(sourceDirectory, destinationDirectory, options = {}) {
+  const fullSourceDirectory = path.resolve(sourceDirectory);
+  const fullDestinationDirectory = path.resolve(destinationDirectory);
+  if (options.verbose) {
+    console.log(
+      chalk.gray(
+        `Copying declarations from ${fullSourceDirectory} to ${fullDestinationDirectory}`
+      )
+    );
+  }
+  await fs.cp(fullSourceDirectory, fullDestinationDirectory, {
+    recursive: true,
+    filter: async (src) => {
+      if (path.basename(src).startsWith(".")) {
+        return false;
+      }
+      const stats = await fs.stat(src);
+      if (stats.isDirectory()) {
+        return true;
+      }
+      return src.endsWith(".d.ts") || src.endsWith(".d.mts") || src.endsWith(".d.cts");
+    }
+  });
+}
+async function moveAndTransformDeclarations({
+  inputDir,
+  buildDir,
+  bundles,
+  isFlat,
+  packageType
+}) {
+  const toCopyDir = bundles.length === 1 ? path.join(buildDir, bundles[0].dir) : buildDir;
+  await fs.cp(inputDir, toCopyDir, {
+    recursive: true,
+    force: false
+  });
+  const dtsFiles = await globby("**/*.d.ts", {
+    absolute: true,
+    cwd: toCopyDir
+  });
+  if (dtsFiles.length === 0) {
+    console.log(
+      chalk.yellow(
+        `No d.ts files found in ${toCopyDir}. Skipping transformation.`
+      )
+    );
+    return;
+  }
+  await mapConcurrently(
+    dtsFiles,
+    async (dtsFile) => {
+      const nativeDtsFile = path.normalize(dtsFile);
+      const content = await fs.readFile(nativeDtsFile, "utf8");
+      const relativePath = path.relative(toCopyDir, nativeDtsFile);
+      const writesToOriginalPath = isFlat && bundles.some((bundle) => {
+        const newFileExtension = getOutExtension(bundle.type, {
+          isFlat,
+          isType: true,
+          packageType
+        });
+        const outFileRelative = relativePath.replace(
+          /\.d\.ts$/,
+          newFileExtension
+        );
+        const outFilePath = path.join(buildDir, bundle.dir, outFileRelative);
+        return path.resolve(outFilePath) === path.resolve(nativeDtsFile);
+      });
+      await Promise.all(
+        bundles.map(async (bundle) => {
+          const importExtension = getOutExtension(bundle.type, {
+            isFlat,
+            packageType
+          });
+          const newFileExtension = getOutExtension(bundle.type, {
+            isFlat,
+            isType: true,
+            packageType
+          });
+          const outFileRelative = isFlat ? relativePath.replace(/\.d\.ts$/, newFileExtension) : relativePath;
+          const outFilePath = path.join(buildDir, bundle.dir, outFileRelative);
+          const babelPlugins = [
+            [pluginTypescriptSyntax, { dts: true }],
+            [pluginResolveImports, { outExtension: importExtension }],
+            [pluginRemoveImports, { test: /\.css$/ }]
+          ];
+          const result = await babel.transformAsync(content, {
+            configFile: false,
+            plugins: babelPlugins,
+            filename: nativeDtsFile
+          });
+          if (typeof result?.code === "string") {
+            await fs.mkdir(path.dirname(outFilePath), { recursive: true });
+            await fs.writeFile(outFilePath, result.code);
+          } else {
+            console.error(
+              chalk.red("failed to transform"),
+              chalk.gray(dtsFile)
+            );
+          }
+        })
+      );
+      if (isFlat && !writesToOriginalPath) {
+        await fs.unlink(nativeDtsFile);
+      }
+    },
+    30
+  );
+}
+async function createTypes({
+  bundles,
+  srcDir,
+  buildDir,
+  cwd,
+  skipTsc,
+  useTsgo = false,
+  isFlat = false,
+  packageType,
+  verbose,
+  builder,
+  entryPoints
+}) {
+  if (builder === "esbuild" && entryPoints && !skipTsc) {
+    if (verbose) console.log(chalk.blue("\u{1F4E6} Bundling TypeScript declarations"));
+    const tmpDir2 = await fs.mkdtemp(path.join(os.tmpdir(), "sse-dts-bundle-"));
+    try {
+      const tsconfigPath = path.join(cwd, "tsconfig.build.json");
+      await emitDeclarations(tsconfigPath, tmpDir2, { useTsgo });
+      await Promise.all(
+        entryPoints.map(async (entry) => {
+          const absoluteEntryPath = path.resolve(cwd, entry);
+          const entryName = path.basename(entry, path.extname(entry));
+          const [bundledTypes] = generateDtsBundle(
+            [
+              {
+                filePath: absoluteEntryPath,
+                output: {
+                  noBanner: false,
+                  inlineDeclareGlobals: true
+                }
+              }
+            ],
+            {
+              preferredConfigPath: tsconfigPath
+            }
+          );
+          await Promise.all(
+            bundles.map(async (bundleItem) => {
+              const outExt = getOutExtension(bundleItem.type, {
+                isFlat,
+                isType: true,
+                packageType
+              });
+              const outFilePath = path.join(
+                buildDir,
+                bundleItem.dir,
+                `${entryName}${outExt}`
+              );
+              await fs.mkdir(path.dirname(outFilePath), { recursive: true });
+              await fs.writeFile(outFilePath, bundledTypes, "utf-8");
+              if (verbose) {
+                console.log(
+                  chalk.green(
+                    `\u2705 Generated bundled types for ${bundleItem.type}: ${outFilePath}`
+                  )
+                );
+              }
+            })
+          );
+        })
+      );
+    } catch (err) {
+      console.error(
+        chalk.red(`\u274C Failed to bundle types for ${entryPoints.join(", ")}`)
+      );
+      console.error(chalk.red(err.message));
+    }
+    return;
+  }
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sse-build-tsc-"));
+  try {
+    await copyDeclarations(srcDir, tmpDir, { verbose });
+    const tsconfigPath = path.join(cwd, "tsconfig.build.json");
+    const tsconfigExists = await fs.stat(tsconfigPath).then(
+      (file) => file.isFile(),
+      () => false
+    );
+    if (!skipTsc) {
+      if (!tsconfigExists) {
+        throw new Error(
+          `Unable to find a tsconfig to build this project. The package root needs to contain a 'tsconfig.build.json'. The package root is '${cwd}'`
+        );
+      }
+      if (verbose)
+        console.log(
+          chalk.cyan(`Building types for ${tsconfigPath} in ${tmpDir}`)
+        );
+      await emitDeclarations(tsconfigPath, tmpDir, { useTsgo });
+    }
+    await moveAndTransformDeclarations({
+      inputDir: tmpDir,
+      buildDir,
+      bundles,
+      isFlat,
+      packageType
+    });
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+export {
+  copyDeclarations,
+  createTypes,
+  emitDeclarations,
+  moveAndTransformDeclarations
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sse-ui/builder",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Builder By SSE",
   "type": "module",
   "scripts": {
@@ -30,8 +30,6 @@
     "@types/node": "^25.4.0",
     "@types/resolve": "^1.20.6",
     "@types/semver": "^7.7.1",
-    "prettier": "^3.8.1",
-    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
   "dependencies": {
@@ -40,6 +38,7 @@
     "@babel/preset-react": "^7.28.5",
     "@babel/preset-typescript": "^7.28.5",
     "@ssets/babel": "*",
+    "@ssets/dts": "*",
     "babel-plugin-optimize-clsx": "^2.6.2",
     "babel-plugin-react-compiler": "^1.0.0",
     "babel-plugin-transform-import-meta": "^2.3.3",