@sse-ui/builder 1.0.0

package/src/utils/build.ts

@@ -0,0 +1,609 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { globby } from "globby";
+import { minimatch } from "minimatch";
+import * as semver from "semver";
+import { PackageJson } from "../core/packageJson";
+
+export type BundleType = "esm" | "cjs";
+export type PackageType = "module" | "commonjs";
+
+interface GetOutExtensionOptions {
+  isType?: boolean;
+  isFlat?: boolean;
+  packageType?: PackageType;
+}
+
+export function getOutExtension(
+  bundle: BundleType,
+  options: GetOutExtensionOptions = {},
+) {
+  const { isType = false, isFlat = false, packageType = "commonjs" } = options;
+  const normalizedPackageType: PackageType =
+    packageType === "module" ? "module" : "commonjs";
+
+  if (!isFlat) {
+    return isType ? ".d.ts" : ".js";
+  }
+
+  if (isType) {
+    if (normalizedPackageType === "module") {
+      return bundle === "esm" ? ".d.ts" : ".d.cts";
+    }
+    return bundle === "cjs" ? ".d.ts" : ".d.mts";
+  }
+
+  if (normalizedPackageType === "module") {
+    return bundle === "esm" ? ".js" : ".cjs";
+  }
+
+  return bundle === "cjs" ? ".js" : ".mjs";
+}
+
+interface CreateExportsFor {
+  importPath: NonNullable<PackageJson.Exports>;
+  key: string;
+  cwd: string;
+  dir: string;
+  type: string;
+  newExports: PackageJson.ExportConditions;
+  typeOutExtension: string;
+  outExtension: string;
+  addTypes: boolean;
+}
+
+async function createExportsFor({
+  importPath,
+  key,
+  cwd,
+  dir,
+  type,
+  newExports,
+  typeOutExtension,
+  outExtension,
+  addTypes,
+}: CreateExportsFor): Promise<void> {
+  if (Array.isArray(importPath)) {
+    throw new Error(
+      `Array form of package.json exports is not supported yet. Found in export "${key}".`,
+    );
+  }
+
+  let srcPath =
+    typeof importPath === "string" ? importPath : importPath["sse-src"];
+  const rest = typeof importPath === "string" ? {} : { ...importPath };
+  delete rest["sse-src"];
+
+  if (typeof srcPath !== "string") {
+    throw new Error(
+      `Unsupported export for "${key}". Only a string or an object with "sse-src" field is supported for now.`,
+    );
+  }
+
+  const exportFileExists = srcPath.includes("*")
+    ? true
+    : await fs.stat(path.join(cwd, srcPath)).then(
+        (stats) => stats.isFile() || stats.isDirectory(),
+        () => false,
+      );
+
+  if (!exportFileExists) {
+    throw new Error(
+      `The import path "${srcPath}" for export "${key}" does not exist in the package. Either remove the export or add the file/folder to the package.`,
+    );
+  }
+
+  srcPath = srcPath.replace(/\.\/src\//, `./${dir === "." ? "" : `${dir}/`}`);
+  const ext = path.extname(srcPath);
+
+  if (ext === ".css") {
+    newExports[key] = srcPath;
+    return;
+  }
+
+  if (typeof newExports[key] === "string" || Array.isArray(newExports[key])) {
+    throw new Error(
+      `The export "${key}" is already defined as a string or Array.`,
+    );
+  }
+
+  newExports[key] ??= {};
+  const exportPath = srcPath.replace(ext, outExtension);
+  newExports[key][type === "cjs" ? "require" : "import"] = addTypes
+    ? {
+        ...rest,
+        types: srcPath.replace(ext, typeOutExtension),
+        default: exportPath,
+      }
+    : Object.keys(rest).length
+      ? {
+          ...rest,
+          default: exportPath,
+        }
+      : exportPath;
+}
+
+interface GlobEntry {
+  value: PackageJson.Exports;
+  srcPattern: string;
+  srcPrefix: string;
+  srcSuffix: string;
+  keyPrefix: string;
+  keySuffix: string;
+}
+
+/**
+ * Expands glob patterns (containing `*`) in package.json export keys/values
+ * into concrete entries by resolving them against actual files on disk.
+ */
+async function expandExportGlobs(
+  originalExports: PackageJson.ExportConditions,
+  cwd: string,
+) {
+  const expandedExports: PackageJson.ExportConditions = {};
+  const globEntries: GlobEntry[] = [];
+  const negationPatterns: string[] = [];
+
+  for (const [key, value] of Object.entries(originalExports)) {
+    if (value === null) {
+      if (key.includes("*")) {
+        negationPatterns.push(key);
+      } else {
+        delete expandedExports[key];
+      }
+      continue;
+    }
+
+    if (!key.includes("*")) {
+      expandedExports[key] = value;
+      continue;
+    }
+
+    // Extract the source pattern from the value
+    let srcPattern: string | undefined;
+    if (typeof value === "string") {
+      srcPattern = value;
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      srcPattern = value["sse-src"] as string | undefined;
+    }
+
+    if (typeof srcPattern !== "string" || !srcPattern.includes("*")) {
+      expandedExports[key] = value;
+      continue;
+    }
+
+    // Split patterns around the * wildcard
+    const srcStarIndex = srcPattern.indexOf("*");
+    const srcPrefix = srcPattern.substring(0, srcStarIndex);
+    const srcSuffix = srcPattern.substring(srcStarIndex + 1);
+
+    const keyStarIndex = key.indexOf("*");
+    const keyPrefix = key.substring(0, keyStarIndex);
+    const keySuffix = key.substring(keyStarIndex + 1);
+
+    globEntries.push({
+      value,
+      srcPattern,
+      srcPrefix,
+      srcSuffix,
+      keyPrefix,
+      keySuffix,
+    });
+  }
+
+  // Resolve all globby calls in parallel
+  const globResults = await Promise.all(
+    globEntries.map(({ srcPattern }) => globby(srcPattern, { cwd })),
+  );
+
+  for (let i = 0; i < globEntries.length; i += 1) {
+    const { value, srcPrefix, srcSuffix, keyPrefix, keySuffix } =
+      globEntries[i];
+    const matches = globResults[i];
+
+    const stems = [];
+    for (const match of matches) {
+      if (match.startsWith(srcPrefix) && match.endsWith(srcSuffix)) {
+        const stem =
+          srcSuffix.length > 0
+            ? match.substring(srcPrefix.length, match.length - srcSuffix.length)
+            : match.substring(srcPrefix.length);
+        if (stem.length > 0) {
+          stems.push(stem);
+        }
+      }
+    }
+
+    stems.sort();
+
+    for (const stem of stems) {
+      const expandedKey = `${keyPrefix}${stem}${keySuffix}`;
+      const expandedSrcPath = `${srcPrefix}${stem}${srcSuffix}`;
+
+      if (typeof value === "string") {
+        expandedExports[expandedKey] = expandedSrcPath;
+      } else {
+        expandedExports[expandedKey] = {
+          ...value,
+          "sse-src": expandedSrcPath,
+        };
+      }
+    }
+  }
+
+  // Apply negation patterns: remove any expanded keys that match a null-valued glob.
+  // If no keys matched, preserve the pattern itself with null to block that path at runtime.
+  for (const pattern of negationPatterns) {
+    let matched = false;
+    for (const expandedKey of Object.keys(expandedExports)) {
+      if (minimatch(expandedKey, pattern)) {
+        delete expandedExports[expandedKey];
+        matched = true;
+      }
+    }
+    if (!matched) {
+      expandedExports[pattern] = null;
+    }
+  }
+
+  return expandedExports;
+}
+
+interface CreatePackageExports {
+  exports: PackageJson["exports"];
+  bundles: { type: BundleType; dir: string }[];
+  outputDir: string;
+  cwd: string;
+  addTypes: boolean;
+  isFlat: boolean;
+  packageType: PackageType;
+}
+
+export async function createPackageExports({
+  exports: packageExports,
+  bundles,
+  outputDir,
+  cwd,
+  addTypes = false,
+  isFlat = false,
+  packageType = "commonjs",
+}: CreatePackageExports) {
+  const resolvedPackageType = packageType === "module" ? "module" : "commonjs";
+  const rawExports: PackageJson.ExportConditions =
+    typeof packageExports === "string" || Array.isArray(packageExports)
+      ? { ".": packageExports }
+      : packageExports || {};
+
+  const originalExports = isFlat
+    ? await expandExportGlobs(rawExports, cwd)
+    : rawExports;
+
+  const newExports: PackageJson.ExportConditions = {
+    "./package.json": "./package.json",
+  };
+
+  const result: {
+    main?: string;
+    types?: string;
+    exports: PackageJson.ExportConditions;
+  } = {
+    exports: newExports,
+  };
+
+  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) {
+        // skip `packageJson.module` to support parcel and some older bundlers
+        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;
+      }
+      if (typeFileExists && type === "cjs") {
+        result.types = typeExportDir;
+      }
+      const exportKeys = Object.keys(originalExports);
+      // need to maintain the order of exports
+      for (const key of exportKeys) {
+        const importPath = originalExports[key];
+        if (!importPath) {
+          newExports[key] = null;
+          continue;
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await createExportsFor({
+          importPath,
+          key,
+          cwd,
+          dir,
+          type,
+          newExports,
+          typeOutExtension,
+          outExtension,
+          addTypes,
+        });
+      }
+    }),
+  );
+
+  bundles.forEach(({ dir }) => {
+    if (dir !== ".") {
+      newExports[`./${dir}`] = null;
+    }
+  });
+
+  Object.keys(newExports).forEach((key) => {
+    const exportVal = newExports[key];
+    if (Array.isArray(exportVal)) {
+      throw new Error(
+        `Array form of package.json exports is not supported yet. Found in export "${key}".`,
+      );
+    }
+    if (
+      exportVal &&
+      typeof exportVal === "object" &&
+      (exportVal.import || exportVal.require)
+    ) {
+      // Use ESM (import) for default if available, otherwise use require
+      const defaultExport = exportVal.import || exportVal.require;
+
+      if (addTypes) {
+        exportVal.default = defaultExport;
+      } else {
+        exportVal.default =
+          defaultExport &&
+          typeof defaultExport === "object" &&
+          "default" in defaultExport
+            ? defaultExport.default
+            : defaultExport;
+      }
+    }
+  });
+
+  return result;
+}
+
+interface CreatePackageBin {
+  bin: PackageJson["bin"];
+  bundles: { type: BundleType; dir: string }[];
+  cwd: string;
+  isFlat: boolean;
+  packageType: PackageType;
+}
+
+export async function createPackageBin({
+  bin,
+  bundles,
+  cwd,
+  isFlat = false,
+  packageType,
+}: CreatePackageBin): Promise<string | Record<string, string> | undefined> {
+  if (!bin) {
+    return undefined;
+  }
+
+  const bundleToUse = bundles.find((b) => b.type === "esm") || bundles[0];
+  const binOutExtension = getOutExtension(bundleToUse.type, {
+    isFlat,
+    packageType,
+  });
+
+  const binsToProcess = typeof bin === "string" ? { __bin__: bin } : bin;
+  const newBin: Record<string, string> = {};
+
+  for (const [binKey, binPath] of Object.entries(binsToProcess)) {
+    // make sure the actual file exists
+    const binFileExists =
+      binPath &&
+      // eslint-disable-next-line no-await-in-loop
+      (await fs.stat(path.join(cwd, binPath)).then(
+        (stats) => stats.isFile(),
+        () => false,
+      ));
+    if (!binFileExists) {
+      throw new Error(
+        `The bin file "${binPath}" for key "${binKey}" does not exist in the package. Please fix the "bin" field in package.json and point it to the source file.`,
+      );
+    }
+    if (typeof binPath !== "string") {
+      throw new Error(`The bin path for "${binKey}" should be a string.`);
+    }
+    const ext = path.extname(binPath);
+    newBin[binKey] = binPath
+      .replace(
+        /(\.\/)?src\//,
+        bundleToUse.dir === "." ? "./" : `./${bundleToUse.dir}/`,
+      )
+      .replace(new RegExp(`\\${ext}$`), binOutExtension);
+  }
+
+  if (Object.keys(newBin).length === 1 && newBin.__bin__) {
+    return newBin.__bin__;
+  }
+
+  return newBin;
+}
+
+/**
+ * Validates the package.json before building.
+ */
+export function validatePkgJson(
+  packageJson: Record<string, any>,
+  options: { skipMainCheck?: boolean; enableReactCompiler?: boolean } = {},
+): void {
+  const { skipMainCheck = false, enableReactCompiler = false } = options;
+  const errors: string[] = [];
+  const buildDirBase = packageJson.publishConfig?.directory;
+  if (!buildDirBase) {
+    errors.push(
+      `No build directory specified in "${packageJson.name}" package.json. Specify it in the "publishConfig.directory" field.`,
+    );
+  }
+
+  if (packageJson.private === false) {
+    errors.push(
+      `Remove the field "private": false from "${packageJson.name}" package.json. This is redundant.`,
+    );
+  }
+
+  if (!skipMainCheck) {
+    if (packageJson.main) {
+      errors.push(
+        `Remove the field "main" from "${packageJson.name}" package.json. Add it as "exports["."]" instead.`,
+      );
+    }
+
+    if (packageJson.module) {
+      errors.push(
+        `Remove the field "module" from "${packageJson.name}" package.json. Add it as "exports["."]" instead.`,
+      );
+    }
+
+    if (packageJson.types || packageJson.typings) {
+      errors.push(
+        `Remove the field "types/typings" from "${packageJson.name}" package.json. Add it as "exports["."]" instead.`,
+      );
+    }
+  }
+
+  const reactVersion = packageJson.peerDependencies?.react;
+  if (enableReactCompiler) {
+    if (!reactVersion) {
+      errors.push(
+        'When building with React compiler, "react" must be specified as a peerDependency in package.json.',
+      );
+    }
+    const minSupportedReactVersion = semver.minVersion(reactVersion);
+    if (!minSupportedReactVersion) {
+      errors.push(
+        `Unable to determine the minimum supported React version from the peerDependency range: "${reactVersion}".`,
+      );
+    } else if (
+      semver.lt(minSupportedReactVersion, "19.0.0") &&
+      !packageJson.peerDependencies?.["react-compiler-runtime"] &&
+      !packageJson.dependencies?.["react-compiler-runtime"]
+    ) {
+      errors.push(
+        'When building with React compiler for React versions below 19, "react-compiler-runtime" must be specified as a dependency or peerDependency in package.json.',
+      );
+    }
+  }
+
+  if (errors.length > 0) {
+    const error = new Error(errors.join("\n"));
+    throw error;
+  }
+}
+
+/**
+ * Marks the start and end of a function execution for performance measurement.
+ * Uses the Performance API to create marks and measure the duration.
+ */
+export async function markFn<F extends () => Promise<any>>(
+  label: string,
+  fn: () => ReturnType<F>,
+): Promise<ReturnType<F>> {
+  const startMark = `${label}-start`;
+  const endMark = `${label}-end`;
+  performance.mark(startMark);
+  const result = await fn();
+  performance.mark(endMark);
+  performance.measure(label, startMark, endMark);
+  return result;
+}
+
+export function measureFn(label: string) {
+  const startMark = `${label}-start`;
+  const endMark = `${label}-end`;
+  return performance.measure(label, startMark, endMark);
+}
+
+export const BASE_IGNORES = [
+  "**/*.test.js",
+  "**/*.test.ts",
+  "**/*.test.tsx",
+  "**/*.spec.js",
+  "**/*.spec.ts",
+  "**/*.spec.tsx",
+  "**/*.d.ts",
+  "**/*.test/*.*",
+  "**/test-cases/*.*",
+];
+
+/**
+ * A utility to map a function over an array of items in a worker pool.
+ *
+ * This function will create a pool of workers and distribute the items to be processed among them.
+ * Each worker will process items sequentially, but multiple workers will run in parallel.
+ */
+export async function mapConcurrently<T, R>(
+  items: T[],
+  mapper: (item: T) => Promise<R>,
+  concurrency: number,
+): Promise<(R | Error)[]> {
+  if (!items.length) {
+    return Promise.resolve([]);
+  }
+
+  const itemIterator = items.entries();
+  const count = Math.min(concurrency, items.length);
+  const workers = [];
+
+  const results: (R | Error)[] = new Array(items.length);
+  for (let i = 0; i < count; i += 1) {
+    const worker = Promise.resolve().then(async () => {
+      for (const [index, item] of itemIterator) {
+        // eslint-disable-next-line no-await-in-loop
+        const res = await mapper(item);
+        results[index] = res;
+      }
+    });
+    workers.push(worker);
+  }
+
+  await Promise.all(workers);
+  return results;
+}

package/src/utils/loadConfig.ts

@@ -0,0 +1,22 @@
+import { loadConfig as loadC12Config } from "c12";
+import { BuildOptions } from "../config";
+
+export async function loadConfig(): Promise<BuildOptions> {
+  try {
+    const { config, configFile } = await loadC12Config<BuildOptions>({
+      name: "sse",
+      rcFile: false,
+      globalRc: false,
+    });
+
+    if (configFile) {
+      console.log(`📝 Loaded config from ${configFile}`);
+    }
+
+    return config || {};
+  } catch (error) {
+    console.error(`❌ Failed to parse configuration:`);
+    console.error(error);
+    process.exit(1);
+  }
+}