@sse-ui/builder 1.0.3 → 1.2.0

package/dist/babel-RJOLF3H5.js

@@ -0,0 +1,12 @@
+import {
+  build,
+  cjsCopy,
+  getVersionEnvVariables
+} from "./chunk-MBPIJFGX.js";
+import "./chunk-B6FMAT44.js";
+import "./chunk-MLKGABMK.js";
+export {
+  build,
+  cjsCopy,
+  getVersionEnvVariables
+};

package/dist/babel-config.js

@@ -1,3 +1,5 @@
+import "./chunk-MLKGABMK.js";
+
 // src/babel-config.ts
 import pluginTransformRuntime from "@ssets/babel/plugin/transform-runtime";
 import presetEnv from "@ssets/babel/preset/env";
@@ -43,11 +45,11 @@ function getBaseConfig({
       pluginTransformInlineEnvVars,
       {
         include: [
-          "MUI_VERSION",
-          "MUI_MAJOR_VERSION",
-          "MUI_MINOR_VERSION",
-          "MUI_PATCH_VERSION",
-          "MUI_PRERELEASE"
+          "SSE_VERSION",
+          "SSE_MAJOR_VERSION",
+          "SSE_MINOR_VERSION",
+          "SSE_PATCH_VERSION",
+          "SSE_PRERELEASE"
         ]
       },
       "babel-plugin-transform-inline-environment-variables"
@@ -139,16 +141,16 @@ function getBabelConfig(api) {
     noResolveImports = api.noResolveImports || false;
   }
   return getBaseConfig({
-    debug: process.env.MUI_BUILD_VERBOSE === "true",
+    debug: process.env.SSE_BUILD_VERBOSE === "true",
     bundle,
-    outExtension: process.env.MUI_OUT_FILE_EXTENSION || null,
+    outExtension: process.env.SSE_OUT_FILE_EXTENSION || null,
     // any package needs to declare 7.25.0 as a runtime dependency. default is ^7.0.0
-    runtimeVersion: process.env.MUI_BABEL_RUNTIME_VERSION || "^7.25.0",
-    optimizeClsx: process.env.MUI_OPTIMIZE_CLSX === "true",
-    removePropTypes: process.env.MUI_REMOVE_PROP_TYPES === "true",
+    runtimeVersion: process.env.SSE_BABEL_RUNTIME_VERSION || "^7.25.0",
+    optimizeClsx: process.env.SSE_OPTIMIZE_CLSX === "true",
+    removePropTypes: process.env.SSE_REMOVE_PROP_TYPES === "true",
     noResolveImports,
-    reactCompilerReactVersion: process.env.MUI_REACT_COMPILER_REACT_VERSION,
-    reactCompilerMode: process.env.MUI_REACT_COMPILER_MODE
+    reactCompilerReactVersion: process.env.SSE_REACT_COMPILER_REACT_VERSION,
+    reactCompilerMode: process.env.SSE_REACT_COMPILER_MODE
   });
 }
 export {

package/dist/{chunk-5S2N5WDQ.js → chunk-B6FMAT44.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,33 @@ 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();
+  let exportableFileCount = 0;
+  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));
+      exportableFileCount++;
+    } else {
+      if (normalizedFile.endsWith("package.json")) continue;
+      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);
+  const hasOnlyRootIndex = exportableFileCount === 1 && rootIndexExists;
+  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 +216,161 @@ 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 (dir === "." && hasOnlyRootIndex) {
+      continue;
+    }
+    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 subExportKeys = Object.keys(originalExports);
+        for (const subKey of subExportKeys) {
+          const subImportPath = originalExports[subKey];
+          if (!subImportPath) {
+            newExports[subKey] = null;
+            continue;
+          }
+          if (subKey === ".") continue;
+          await createExportsFor({
+            importPath: subImportPath,
+            key: subKey,
+            cwd,
+            dir,
+            type,
+            newExports,
+            typeOutExtension,
+            outExtension,
+            addTypes
+          });
+        }
+      })
+    );
+  }
   bundles.forEach(({ dir }) => {
     if (dir !== ".") {
+      newExports[`./${dir}/package.json`] = null;
       newExports[`./${dir}`] = null;
+      newExports[`./${dir}/*`] = null;
     }
   });
   Object.keys(newExports).forEach((key) => {
@@ -390,12 +518,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/{babel-VTL3CZAT.js → chunk-MBPIJFGX.js}

@@ -1,6 +1,6 @@
 import {
   BASE_IGNORES
-} from "./chunk-5S2N5WDQ.js";
+} from "./chunk-B6FMAT44.js";
 
 // src/utils/babel.ts
 import { findWorkspacesRoot } from "find-workspaces";
@@ -19,11 +19,11 @@ function getVersionEnvVariables(pkgVersion) {
     throw new Error(`Couldn't parse version from package.json`);
   }
   return {
-    MUI_VERSION: pkgVersion,
-    MUI_MAJOR_VERSION: major,
-    MUI_MINOR_VERSION: minor,
-    MUI_PATCH_VERSION: patch,
-    MUI_PRERELEASE: prerelease
+    SSE_VERSION: pkgVersion,
+    SSE_MAJOR_VERSION: major,
+    SSE_MINOR_VERSION: minor,
+    SSE_PATCH_VERSION: patch,
+    SSE_PRERELEASE: prerelease
   };
 }
 async function cjsCopy({ from, to }) {
@@ -53,9 +53,11 @@ async function build({
   ignores = [],
   reactCompiler
 }) {
-  console.log(
-    `Transpiling files to "${path.relative(path.dirname(sourceDir), outDir)}" for "${bundle}" bundle.`
-  );
+  if (verbose) {
+    console.log(
+      `Transpiling files to "${path.relative(path.dirname(sourceDir), outDir)}" for "${bundle}" bundle.`
+    );
+  }
   const workspaceDir = await findWorkspacesRoot(cwd);
   const rootDir = workspaceDir ? workspaceDir.location : cwd;
   let configFile = path.join(rootDir, "babel.config.js");
@@ -67,14 +69,14 @@ async function build({
   const env = {
     NODE_ENV: "production",
     BABEL_ENV: bundle === "esm" ? "stable" : "node",
-    MUI_BUILD_VERBOSE: verbose ? "true" : void 0,
-    MUI_OPTIMIZE_CLSX: optimizeClsx ? "true" : void 0,
-    MUI_REMOVE_PROP_TYPES: removePropTypes ? "true" : void 0,
-    MUI_BABEL_RUNTIME_VERSION: babelRuntimeVersion,
-    MUI_OUT_FILE_EXTENSION: outExtension ?? ".js",
+    SSE_BUILD_VERBOSE: verbose ? "true" : void 0,
+    SSE_OPTIMIZE_CLSX: optimizeClsx ? "true" : void 0,
+    SSE_REMOVE_PROP_TYPES: removePropTypes ? "true" : void 0,
+    SSE_BABEL_RUNTIME_VERSION: babelRuntimeVersion,
+    SSE_OUT_FILE_EXTENSION: outExtension ?? ".js",
     ...getVersionEnvVariables(pkgVersion),
-    MUI_REACT_COMPILER: reactVersion ? "1" : "0",
-    MUI_REACT_COMPILER_REACT_VERSION: reactVersion
+    SSE_REACT_COMPILER: reactVersion ? "1" : "0",
+    SSE_REACT_COMPILER_REACT_VERSION: reactVersion
   };
   const resolvedOutExtension = outExtension ?? ".js";
   const res = await $({
@@ -103,8 +105,9 @@ ${res.stdout}`
     );
   }
 }
+
 export {
-  build,
+  getVersionEnvVariables,
   cjsCopy,
-  getVersionEnvVariables
+  build
 };

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};