@sse-ui/builder 1.2.0 → 1.3.1

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.2.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",