@sse-ui/builder 1.0.0 → 1.0.2

package/dist/config.d.ts

@@ -0,0 +1,39 @@
+import { B as BundleType } from './build-DZbrXe0V.js';
+
+interface BuildOptions {
+    /** The bundles to build. */
+    bundle: BundleType[];
+    /** The large files to build. */
+    hasLargeFiles: boolean;
+    /** Whether to skip generating a package.json file in the /esm folder. */
+    skipBundlePackageJson: boolean;
+    /** Whether to enable verbose logging. */
+    verbose: boolean;
+    /** Whether to build types for the package. */
+    buildTypes: boolean;
+    /** Whether to build types for the package. */
+    skipTsc: boolean;
+    /** Whether to skip checking for Babel runtime dependencies in the package. */
+    skipBabelRuntimeCheck: boolean;
+    /** Whether to skip generating the package.json file in the bundle output. */
+    skipPackageJson: boolean;
+    /** Whether to skip checking for main field in package.json. */
+    skipMainCheck: boolean;
+    /** Globs to be ignored by Babel. */
+    ignore: string[];
+    /** Files/Directories to be copied. Can be a glob pattern. */
+    copy: string[];
+    /** Whether to use the React compiler. */
+    enableReactCompiler: boolean;
+    /** Whether to build types using typescript native (tsgo). */
+    tsgo: boolean;
+    /** Builds the package in a flat structure without subdirectories for each module type. */
+    flat: boolean;
+}
+
+/**
+ * Helper to provide autocomplete and type checking for the sse-tools config.
+ */
+declare function defineConfig(config: BuildOptions): BuildOptions;
+
+export { type BuildOptions, defineConfig };

package/dist/config.js

@@ -0,0 +1,7 @@
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  defineConfig
+};

package/dist/typescript-CS6YZCMJ.js

@@ -0,0 +1,217 @@
+import {
+  getOutExtension,
+  mapConcurrently
+} from "./chunk-5S2N5WDQ.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 * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+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 MUI_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("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(
+      `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(
+      `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("failed to transform", dtsFile);
+          }
+        })
+      );
+      if (isFlat && !writesToOriginalPath) {
+        await fs.unlink(nativeDtsFile);
+      }
+    },
+    30
+  );
+}
+async function createTypes({
+  bundles,
+  srcDir,
+  buildDir,
+  cwd,
+  skipTsc,
+  useTsgo = false,
+  isFlat = false,
+  packageType,
+  verbose
+}) {
+  const tmpDir = await fs.mkdtemp(
+    path.join(os.tmpdir(), "code-infra-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}'`
+        );
+      }
+      console.log(`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,14 +1,16 @@
 {
   "name": "@sse-ui/builder",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Builder By SSE",
   "type": "module",
   "scripts": {
     "build": "tsup",
     "prepublish": "npm run build"
   },
+  "main": "./bin/sse-tools.js",
+  "files": ["bin", "dist"],
   "bin": {
-    "@sse-ui/builder": "./bin/sse-tools.js"
+    "sse-tool": "./bin/sse-tools.js"
   },
   "exports": {
     "./babel-config": {

package/src/cli.ts

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { buildCommand } from "./core/build";
-import { publishCommand } from "./core/publish";
-import { cleanCommand } from "./core/clean";
-import { typecheckCommand } from "./core/typecheck";
-import { packCommand } from "./core/pack";
-import { versionCommand } from "./core/version";
-import { infoCommand } from "./core/info";
-import { linkCommand } from "./core/link";
-import { checkExportsCommand } from "./core/check-exports";
-import { watchCommand } from "./core/watch";
-
-async function main() {
-  const program = new Command();
-
-  program
-    .name("sse-tools")
-    .description("CLI utilities for managing and building MUI packages")
-    .version("1.0.0");
-
-  program.addCommand(buildCommand);
-  program.addCommand(publishCommand);
-  program.addCommand(cleanCommand);
-  program.addCommand(typecheckCommand);
-  program.addCommand(packCommand);
-  program.addCommand(versionCommand);
-  program.addCommand(infoCommand);
-  program.addCommand(linkCommand);
-  program.addCommand(checkExportsCommand);
-  program.addCommand(watchCommand);
-
-  try {
-    await program.parseAsync(process.argv);
-  } catch (error) {
-    console.error("Error executing command:");
-    if (error instanceof Error) {
-      console.error(error.message);
-    }
-    process.exit(1);
-  }
-}
-
-main();

package/src/config.ts

@@ -1,10 +0,0 @@
-import { BuildOptions } from "./core/build";
-
-export type { BuildOptions };
-
-/**
- * Helper to provide autocomplete and type checking for the sse-tools config.
- */
-export function defineConfig(config: BuildOptions): BuildOptions {
-  return config;
-}