@digigov/cli-build 2.0.0-b4cd6916 → 2.0.0-d0adc9fb

package/.rush/temp/shrinkwrap-deps.json

@@ -1,16 +1,17 @@
 {
-  "../../tooling/cli-build": "../../tooling/cli-build:qTUBqXD27dl7fc7zPWxUDuD2EUBBs/CeE75+ZZm39l4=:",
-  "/@babel/cli@7.12.1(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
+  "../../tooling/cli-build": "../../tooling/cli-build:02YjlK6+1qui1+paVKGwEISZBfTmSHa5jCm7uK5t+7I=:",
+  "/@babel/cli@7.12.1(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
   "/@babel/compat-data@7.12.5": "Missing shrinkwrap entry!",
-  "/@babel/core@7.12.13": "Missing shrinkwrap entry!",
+  "/@babel/core@7.26.0": "Missing shrinkwrap entry!",
   "/@babel/helper-validator-identifier@7.9.5": "Missing shrinkwrap entry!",
-  "/@babel/plugin-proposal-class-properties@7.12.1(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
-  "/@babel/plugin-proposal-object-rest-spread@7.12.1(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
-  "/@babel/plugin-transform-object-assign@7.12.1(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
-  "/@babel/plugin-transform-runtime@7.12.1(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
-  "/@babel/preset-env@7.12.13(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
-  "/@babel/preset-react@7.12.13(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
-  "/@babel/preset-typescript@7.12.1(@babel/core@7.12.13)": "Missing shrinkwrap entry!",
+  "/@babel/plugin-proposal-class-properties@7.12.1(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
+  "/@babel/plugin-proposal-object-rest-spread@7.12.1(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
+  "/@babel/plugin-transform-object-assign@7.12.1(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
+  "/@babel/plugin-transform-runtime@7.12.1(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
+  "/@babel/preset-env@7.12.13(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
+  "/@babel/preset-react@7.12.13(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
+  "/@babel/preset-typescript@7.12.1(@babel/core@7.26.0)": "Missing shrinkwrap entry!",
+  "/@types/fs-extra@11.0.4": "Missing shrinkwrap entry!",
   "/@types/node@18.19.0": "Missing shrinkwrap entry!",
   "/babel-plugin-inline-import-data-uri@1.0.1": "Missing shrinkwrap entry!",
   "/babel-plugin-istanbul@7.0.0": "Missing shrinkwrap entry!",
@@ -20,11 +21,14 @@
   "/babel-plugin-transform-dev-warning@0.1.1": "Missing shrinkwrap entry!",
   "/babel-plugin-transform-react-constant-elements@6.23.0": "Missing shrinkwrap entry!",
   "/babel-plugin-transform-react-remove-prop-types@0.4.24": "Missing shrinkwrap entry!",
+  "/commander@12.1.0": "Missing shrinkwrap entry!",
   "/esbuild@0.23.0": "Missing shrinkwrap entry!",
   "/fs-extra@11.2.0": "Missing shrinkwrap entry!",
-  "/glob@7.1.6": "Missing shrinkwrap entry!",
-  "/next@13.1.1(@babel/core@7.12.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)": "Missing shrinkwrap entry!",
+  "/globby@11.0.0": "Missing shrinkwrap entry!",
+  "/next@13.1.1(@babel/core@7.26.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)": "Missing shrinkwrap entry!",
   "/publint@0.1.8": "Missing shrinkwrap entry!",
   "/rimraf@3.0.2": "Missing shrinkwrap entry!",
-  "/typescript@5.6.2": "Missing shrinkwrap entry!"
+  "/ts-morph@25.0.0": "Missing shrinkwrap entry!",
+  "/typescript@5.6.2": "Missing shrinkwrap entry!",
+  "/vitest@2.1.3(@types/node@18.19.0)(happy-dom@15.11.0)(jsdom@20.0.3)(lightningcss@1.22.0)(sass-embedded@1.81.0)(terser@5.33.0)": "Missing shrinkwrap entry!"
 }

package/{babel.common.js → babel.common.cjs}

@@ -4,7 +4,7 @@ const lib = require("@digigov/cli/lib");
 
 function makeBabelConfig(dir, opts = { docs: false, proptypes: false }) {
   const project = lib.resolveProject(dir);
-  const aliases = !project.externalLockFile ? lib.aliases(null, true) : {};
+  const aliases = !project.externalLockFile ? lib.aliases(true) : {};
 
   const BABEL_ENV = process.env.BABEL_ENV || "esm";
   const BABEL_PUBLISH = process.env.BABEL_PUBLISH || false;

package/babel.config.cjs

@@ -0,0 +1 @@
+module.exports = require("./babel.common.cjs").config;

package/build.js

@@ -0,0 +1,85 @@
+import { DigigovCommand, logger } from "@digigov/cli/lib";
+
+import assert from "assert";
+import path from "path";
+import fs from "fs-extra";
+import baseEsbuild from "esbuild";
+
+/**
+ * Generate TypeScript declaration files
+ *
+ * @param {object} project - The project object
+ * @param {string} project.root - The project root directory
+ * @param {string} project.src - The project source directory
+ * @param {string} project.distDir - The project build directory
+ * @param {string} tsconfig - The tsconfig path
+ * @param {DigigovCommand} ctx - The command context
+ */
+export async function generateTypeDeclarationFiles(project, tsconfig, ctx) {
+  logger.debug("Building types...");
+
+  const distDir = path.resolve(project.root, project.distDir);
+  const projectBasename = path.basename(project.root);
+
+  await ctx.exec("tsc", [
+    "--emitDeclarationOnly",
+    "--outDir",
+    "dist",
+    "--project",
+    tsconfig,
+  ]);
+
+  const projectBasePath = path.join(distDir, projectBasename);
+  logger.debug("Project base path", projectBasePath);
+  if (await fs.exists(projectBasePath)) {
+    const typesIncluded = await fs.readdir(path.join(distDir));
+    const srcPath = path.join(distDir, projectBasename, project.src);
+    const paths = await fs.readdir(srcPath);
+
+    await Promise.all([
+      // Move src files to dist
+      ...paths.map((p) => {
+        logger.debug("Moving types file", p);
+        fs.move(path.join(srcPath, p), path.join(distDir, p));
+      }),
+      // Remove dirs
+      ...typesIncluded.map((typesDir) => {
+        logger.debug("Removing types directory", typesDir);
+        fs.rm(path.join(distDir, typesDir), { recursive: true });
+      }),
+    ]).catch((err) => {
+      logger.error("Error while building types", err);
+    });
+  }
+  logger.debug("Types built.");
+}
+
+/**
+ * Run esbuild for the given options
+ *
+ * @param {object} options - The build options
+ * @param {string[]} options.files - The files to build
+ * @param {string | undefined} options.tsconfig - The tsconfig path
+ * @param {"esm" | "cjs"} options.format - The module format
+ * @param {string} options.outdir - The output directory
+ */
+export function buildFormat({ files: entryPoints, tsconfig, format, outdir }) {
+  assert(format === "esm" || format === "cjs", "Invalid format");
+
+  logger.log(`Running: esbuild for ${format.toUpperCase()} format`);
+  return baseEsbuild.build({
+    ...BASE_OPTIONS,
+    entryPoints,
+    tsconfig,
+    format,
+    outdir,
+  });
+}
+
+/** @type {baseEsbuild.BuildOptions} */
+export const BASE_OPTIONS = {
+  logLevel: "error",
+  platform: "node",
+  sourcemap: true,
+  target: ["esnext"],
+};

package/common.js

@@ -0,0 +1,20 @@
+import fs from "fs-extra";
+import path from "path";
+
+const POSSIBLE_TS_CONFIGS = ["tsconfig.production.json", "tsconfig.json"];
+
+/**
+ * Get the tsconfig path for the given project
+ *
+ * @param {string} projectRoot - The project root
+ * @returns {string | undefined} - The tsconfig path or undefined if not found
+ */
+export function getProjectTsconfig(projectRoot) {
+  for (const tsconfig of POSSIBLE_TS_CONFIGS) {
+    const tsconfigPath = path.join(projectRoot, tsconfig);
+    if (fs.existsSync(tsconfigPath)) {
+      return tsconfigPath;
+    }
+  }
+  return;
+}

package/copy-files.js

@@ -1,23 +1,40 @@
-/* eslint-disable no-console */
-const path = require("path");
-const fs = require("fs");
-const fse = require("fs-extra");
-const glob = require("glob");
-const { resolveProject } = require("@digigov/cli/lib");
+import { logger, resolveProject } from "@digigov/cli/lib";
+import fs from "fs-extra";
+import path from "path";
+import glob from "globby";
 
-const project = resolveProject();
 const packagePath = process.cwd();
+const project = resolveProject();
 const buildPath = path.join(project.root, project.distDir);
 
-async function includeFileInBuild(file) {
+/**
+ * Copy a file from the package to the build directory
+ *
+ * @param {string} file - The file to include in the build
+ */
+function includeFileInBuild(file) {
   const sourcePath = path.resolve(packagePath, file);
   const targetPath = path.resolve(buildPath, path.basename(file));
-  await fse.copy(sourcePath, targetPath);
-  console.log(`Copied ${sourcePath} to ${targetPath}`);
+  fs.copySync(sourcePath, targetPath);
+  logger.debug(`Copied ${sourcePath} to build directory`);
+}
+
+function copyRegistryFilesToSrc() {
+  const registryPath = path.resolve(buildPath, "registry/index.js");
+  const lazyPath = path.resolve(buildPath, "lazy/index.js");
+  if (!fs.existsSync(registryPath) || !fs.existsSync(lazyPath)) return;
+
+  const srcPath = path.resolve(buildPath, "src");
+  logger.debug(`Copying registry and lazy files to ${srcPath}`);
+  fs.copySync(registryPath, path.resolve(srcPath, "registry.js"));
+  fs.copySync(lazyPath, path.resolve(srcPath, "lazy.js"));
 }
 
-async function createRootPackageFile() {
-  const packageData = await fse.readFile(
+/**
+ * Create a package.json file in the build directory
+ */
+function createRootPackageFile() {
+  const packageData = fs.readFileSync(
     path.resolve(packagePath, "./package.json"),
     "utf8",
   );
@@ -32,18 +49,20 @@ async function createRootPackageFile() {
   };
   const targetPath = path.resolve(buildPath, "./package.json");
 
-  await fse.writeFile(
-    targetPath,
-    JSON.stringify(newPackageData, null, 2),
-    "utf8",
-  );
-  console.log(`Created package.json in ${targetPath}`);
+  fs.writeFileSync(targetPath, JSON.stringify(newPackageData, null, 2), "utf8");
+  logger.debug(`Created package.json in build directory`);
 
   return newPackageData;
 }
 
+/**
+ * Create nested package.json files in the build directory
+ *
+ */
 function createNestedPackageFiles() {
-  const indexPaths = glob.sync(path.join(buildPath, "!(cjs)/**/index.js"));
+  const indexPaths = glob.sync(path.join(buildPath, "**/index.js"), {
+    ignore: [path.join(buildPath, "cjs/**")],
+  });
 
   indexPaths.forEach((indexPath) => {
     if (indexPath === path.join(buildPath, "index.js")) return;
@@ -63,63 +82,78 @@ function createNestedPackageFiles() {
   });
 }
 
-async function prepend(file, string) {
-  const data = await fse.readFile(file, "utf8");
-  await fse.writeFile(file, string + data, "utf8");
+/**
+ * Prepend a string to a file
+ *
+ * @param {string} file - The file to prepend to
+ * @param {string} string - The string to prepend
+ */
+function prepend(file, string) {
+  const data = fs.readFileSync(file, "utf8");
+  fs.writeFileSync(file, string + data, "utf8");
+  logger.debug(`Prepended license to ${file}`);
 }
 
-async function addLicense(packageData) {
-  const license = `/** @license Digigov v${packageData.version}
+/**
+ * Add license to the top of the files
+ *
+ * @param {object} packageData - The package data
+ */
+function addLicense(packageData) {
+  const license = `/** @license Digigov v${packageData["version"]}
  *
  * This source code is licensed under the BSD-2-Clause license found in the
  * LICENSE file in the root directory of this source tree.
  */
 `;
-  await Promise.all(
-    ["./index.js", "./index.mjs"].map(async (file) => {
-      try {
-        await prepend(path.resolve(buildPath, file), license);
-      } catch (err) {
-        if (err.code === "ENOENT") {
-          console.log(`Skipped license for ${file}`);
-        } else {
-          throw err;
-        }
+  ["./index.js", "./index.mjs"].map(async (file) => {
+    try {
+      prepend(path.resolve(buildPath, file), license);
+    } catch (err) {
+      if (
+        typeof err === "object" &&
+        err &&
+        "code" in err &&
+        err.code === "ENOENT"
+      ) {
+        logger.debug(`Skipped license for ${file}`);
+      } else {
+        throw err;
       }
-    }),
-  );
+    }
+  });
 }
 
+/**
+ * Create separate index modules for each directory
+ */
 function createSeparateIndexModules() {
-  const files = glob.sync(path.join(buildPath, "**/!(index).js"));
+  const files = glob.sync(path.join(buildPath, "**/*.js"), {
+    ignore: [path.join(buildPath, "**/index.js")],
+  });
 
   files.forEach((file) => {
-    fs.mkdirSync(file.replace(".js", ""));
-    fs.renameSync(file, file.replace(".js", "/index.js"));
+    fs.mkdirSync(file.replace(/\.js$/, ""));
+    fs.renameSync(file, file.replace(/\.js$/, "/index.js"));
   });
 }
 
-async function run() {
-  try {
-    const packageData = await createRootPackageFile();
-    createSeparateIndexModules();
-    createNestedPackageFiles();
-
-    await Promise.all(
-      [
-        // use enhanced readme from workspace root for `@digigov/ui`
-        // packageData.name === '@digigov/ui' ? '../../README.md' : './README.md',
-        "./src",
-        "./README.md",
-        "./CHANGELOG.md",
-        "../../LICENSE",
-      ].map((file) => includeFileInBuild(file)),
-    );
+/**
+ * Run the copy files script
+ */
+export default function run() {
+  const packageData = createRootPackageFile();
+  createSeparateIndexModules();
+  createNestedPackageFiles();
+  copyRegistryFilesToSrc();
 
-    await addLicense(packageData);
-  } catch (err) {
-    console.error(err);
-  }
+  [
+    // use enhanced readme from workspace root for `@digigov/ui`
+    // packageData.name === '@digigov/ui' ? '../../README.md' : './README.md',
+    "./src",
+    "./README.md",
+    "./CHANGELOG.md",
+    "../../LICENSE",
+  ].map((file) => includeFileInBuild(file)),
+    addLicense(packageData);
 }
-
-run();

package/generate-registry.js

@@ -0,0 +1,268 @@
+import { logger } from "@digigov/cli/lib";
+import path from "path";
+import fs from "fs-extra";
+import { SyntaxKind, Project as TsMorphProject } from "ts-morph";
+import assert from "assert";
+
+import { getProjectTsconfig } from "./common.js";
+
+/**
+ * Generate registry files for the given project
+ *
+ * @param {object} project - The project object
+ * @param {string} project.root - The project root directory
+ * @param {string} project.distDir - The project build directory
+ * @param {string} project.name - The project name as in package.json
+ * @param {string[]} filePaths - The paths of the files to include in the registry
+ * @param {boolean} shouldGenerateStoriesRegistry - Whether to export stories in the registry
+ * @returns {Promise<[string, string]>} - The paths of the generated registry files
+ */
+export async function generateRegistryFiles(
+  project,
+  filePaths,
+  shouldGenerateStoriesRegistry = false,
+) {
+  const registryPath = ensureRegistryPath(project, "registry.js");
+  const lazyRegistryPath = ensureRegistryPath(project, "lazy.js");
+
+  const registry = generateRegistryFileContent(
+    project,
+    filePaths,
+    shouldGenerateStoriesRegistry,
+  );
+
+  const componentPathsOnly = filePaths.filter(
+    (path) => !path.includes("stories"),
+  );
+  const lazyRegistry = generateLazyFileContent(project, componentPathsOnly);
+
+  await Promise.all([
+    fs.writeFile(registryPath, registry),
+    fs.writeFile(lazyRegistryPath, lazyRegistry),
+  ]);
+
+  return [registryPath, lazyRegistryPath];
+}
+
+/**
+ * Ensure that the registry file does not already exist at the given path
+ *
+ * @param {object} project - The project object
+ * @param {string} project.root - The project root directory
+ * @param {string} project.distDir - The project build directory
+ * @param {string} fileName - The name of the registry file
+ */
+function ensureRegistryPath(project, fileName) {
+  const registryPath = path.join(project.root, project.distDir, fileName);
+  if (fs.existsSync(registryPath))
+    throw new Error(`A "${fileName}" file already exists at ${registryPath}.`);
+  return registryPath;
+}
+
+/**
+ * Generate registry file content for the given files
+ *
+ * @param {object} project - The project object
+ * @param {string} project.root - The project root directory
+ * @param {string} project.name - The project name as in package.json
+ * @param {string[]} absoluteFilePaths - The absolute paths of the files to include in the registry
+ * @param {boolean} includeStories - Whether to include stories in the registry
+ * @returns {string} - The registry file content or null if no components are found
+ */
+export function generateRegistryFileContent(
+  project,
+  absoluteFilePaths,
+  includeStories = false,
+) {
+  const relativePaths = absoluteFilePaths.map((path) => {
+    assert(
+      path.startsWith(project.root),
+      "Expected path to be in project root",
+    );
+    return toNodeResolvablePath(
+      path.replace(`${project.root}/src/`, `${project.name}/`),
+    );
+  });
+  let registryPaths = relativePaths.map((path) => ({
+    path,
+    uid: createUid(path),
+  }));
+
+  if (registryPaths.length === 0)
+    throw new Error(
+      "Could not generate registry. No exportable modules found.",
+    );
+
+  const importStatements = registryPaths.map(
+    (file) => `import * as ${file.uid} from "${file.path}";`,
+  );
+  const exportStatements = registryPaths.map(
+    (file) => `  '${file.path}': lazyImport(${file.uid})`,
+  );
+
+  const [components, stories] = splitStoriesExports(exportStatements);
+  logger.debug(`Including ${components.length} component modules in registry`);
+
+  if (includeStories) {
+    logger.debug(`Including ${stories.length} stories in registry`);
+  }
+
+  let out = `
+${importStatements.join("\n")}
+function lazyImport(pkgImport) {
+  return new Proxy(
+    {},
+    {
+      get: (_target, name) => {
+        if (name === '__esModule' || name === 'default') {
+          return pkgImport.default;
+        } else if(
+          name === '*'
+        ) {
+          return pkgImport;
+        } else {
+          return pkgImport[name];
+        }
+      },
+    }
+  )
+}
+export default {
+${components.join(",\n")}
+};
+`;
+
+  if (includeStories) {
+    out += `
+
+export const stories = {
+${stories.join(",\n")}
+};
+`;
+  }
+  return out;
+}
+
+/**
+ * Extract a node-resolvable path
+ *
+ * @param {string} inputPath - The file path
+ * @returns {string} - The node-resolvable path
+ */
+export function toNodeResolvablePath(inputPath) {
+  const dir = path.dirname(inputPath);
+  const base = path.basename(inputPath, path.extname(inputPath));
+
+  return base === "index" ? dir : path.join(dir, base);
+}
+
+/**
+ * Create a UID from a path
+ *
+ * @param {string} inputPath - The path
+ * @returns {string} - The UID
+ */
+export function createUid(inputPath) {
+  return inputPath.replace(/[\/@\-.]/g, "_");
+}
+
+/**
+ * Split the given files into components and stories
+ *
+ * @param {string[]} exportStatements - The export statements
+ * @returns {[string[], string[]]} - The split components and stories exports
+ */
+export function splitStoriesExports(exportStatements) {
+  const stories = [];
+  const components = [];
+  for (const exportStatement of exportStatements) {
+    if (exportStatement.includes("_stories")) {
+      stories.push(exportStatement);
+    } else {
+      components.push(exportStatement);
+    }
+  }
+  return [components, stories];
+}
+
+/**
+ * Generate lazy component registry file content for the given project
+ *
+ * @param {object} project - The project object
+ * @param {string} project.root - The project root directory
+ * @param {string} project.name - The project name as in package.json
+ * @param {string[]} filePaths - The files whose exports will be included in the lazy registry
+ * @returns {string} - The lazy component registry file content or null if no components are found
+ */
+export function generateLazyFileContent(project, filePaths) {
+  const tsMorphProject = new TsMorphProject({
+    tsConfigFilePath: getProjectTsconfig(project.root),
+  });
+
+  /** @type {Record<string, string>} */
+  let allComponents = {};
+
+  for (const filePath of filePaths) {
+    const sourceFile = tsMorphProject.addSourceFileAtPath(filePath);
+    const exports = sourceFile
+      .getExportSymbols()
+      .filter(isJsExport)
+      .map((symbol) => symbol.getName());
+
+    for (const exportedComponent of exports) {
+      if (
+        exportedComponent !== "default" &&
+        exportedComponent.match(/^[A-Z]/)
+      ) {
+        if (
+          !allComponents[exportedComponent] ||
+          allComponents[exportedComponent].length < filePath.length // Make import path more specific
+        ) {
+          allComponents[exportedComponent] = toNodeResolvablePath(
+            filePath.replace(`${project.root}/src/`, `${project.name}/`),
+          );
+        }
+      }
+    }
+  }
+
+  const componentCount = Object.keys(allComponents).length;
+
+  if (componentCount === 0)
+    throw new Error(
+      "Could not generate lazy registry. No exportable components found.",
+    );
+
+  logger.debug(`Including ${componentCount} components in lazy registry`);
+
+  const content = Object.entries(allComponents)
+    .map(
+      ([component, filePath]) =>
+        `  '${component}': lazy(() => import('${filePath}').then((module) => ({ default: module['${component}'] })))`,
+    )
+    .join(",\n");
+
+  return `import { lazy } from 'react';
+export default {
+${content}
+};
+`;
+}
+
+/**
+ * Check if a symbol is a JS export
+ *
+ * @param {import("ts-morph").Symbol} symbol - The symbol to check
+ */
+function isJsExport(symbol) {
+  const declarations = symbol.getDeclarations();
+  return declarations.some((declaration) => {
+    const kind = declaration.getKind();
+    return (
+      kind === SyntaxKind.FunctionDeclaration ||
+      kind === SyntaxKind.ClassDeclaration ||
+      kind === SyntaxKind.VariableDeclaration ||
+      kind === SyntaxKind.ExportSpecifier
+    );
+  });
+}

package/index.js

@@ -1,107 +1,106 @@
-const { Command } = require("@oclif/command");
-const execa = require("execa");
-const { resolveProject, DigigovCommand } = require("@digigov/cli/lib");
-const path = require("path");
-const fs = require("fs");
-const esbuild = require("esbuild");
-const glob = require("glob");
+import { DigigovCommand, resolveProject, logger } from "@digigov/cli/lib";
+import { buildFormat, generateTypeDeclarationFiles } from "./build.js";
+import { generateRegistryFiles } from "./generate-registry.js";
+import copyFiles from "./copy-files.js";
 
-module.exports = class Build extends DigigovCommand {
-  static description = "build digigov libraries";
-  static id = "build";
-  dirname = __dirname;
-  static examples = [`$ digigov build`];
-  static strict = false;
-  static load() {
-    return Build;
-  }
-  script = "babel";
-  async run() {
-    const { argv } = this.parse(Build);
-    try {
-      await this.exec("rimraf", ["dist"]);
-      const project = resolveProject();
-      const babelArgs = [
-        "--config-file",
-        path.join(__dirname, "babel.config.js"),
-        project.src,
-        "--extensions",
-        ".tsx,.ts,.js,.jsx",
-        "--copy-files",
-        "--out-dir",
-      ];
-      const distDir = path.resolve(project.root, project.distDir);
-      const basename = path.basename(project.root);
+import { Option } from "commander";
+import path from "path";
+import glob from "globby";
+import assert from "assert";
+import { getProjectTsconfig } from "./common.js";
+
+const command = new DigigovCommand("build", import.meta.url)
+  .option(
+    "--generate-registry",
+    "Generate a registry file for the build output",
+  )
+  .addOption(
+    new Option("--include-stories", "Include stories in the output").implies({
+      generateRegistry: true,
+    }),
+  )
+  .action(main);
+export default command;
+
+const SRC_GLOB = "src/**/*.{tsx,ts,js,jsx}";
+const TEST_GLOBS = [
+  "**/*.test.{js,jsx,ts,tsx}",
+  "**/*.spec.{js,jsx,ts,tsx}",
+  "**/__tests__/**/*.{js,jsx,ts,tsx}",
+];
+const STORIES_GLOBS = [
+  "**/*.stories.{js,jsx,ts,tsx}",
+  "**/__stories__/**/*.{js,jsxts,tsx}",
+];
+
+/**
+ * @param {object} options - The command options
+ * @param {boolean} options.generateRegistry - Generate a registry file for the build output
+ * @param {boolean} options.includeStories - Include stories in the generated registry file
+ * @param {DigigovCommand} ctx
+ */
+async function main(options, ctx) {
+  const project = resolveProject();
 
-      if (project.isTs) {
-        const tsconfigProduction = path.join(
-          project.root,
-          "tsconfig.production.json",
-        );
-        const tsArgs = [];
-        if (fs.existsSync(tsconfigProduction)) {
-          tsArgs.push("--project", tsconfigProduction);
-        }
-        await this.exec("tsc", [
-          "--emitDeclarationOnly",
-          "--outDir",
-          "dist",
-          ...tsArgs,
-        ]);
-        if (fs.existsSync(path.join(distDir, basename))) {
-          const typesIncluded = fs.readdirSync(path.join(distDir));
-          const paths = fs.readdirSync(
-            path.join(distDir, basename, project.src),
-          );
-          paths.forEach((p) => {
-            fs.renameSync(
-              path.join(distDir, basename, project.src, p),
-              path.join(distDir, p),
-            );
-          });
-          typesIncluded.forEach((typesDir) => {
-            fs.rmSync(path.join(distDir, typesDir), { recursive: true });
-          });
-        }
-      }
+  await ctx.exec("rimraf", [project.distDir]);
 
-      const files = glob.sync(
-        path.join(project.root, "src", "**/*.{tsx,ts,js,jsx}"),
-        {
-          ignore: "**/*.{spec,test}.{ts,tsx,js,jsx}",
-        },
-      );
-      const commonBuildOptions = {
-        entryPoints: files,
-        platform: "node",
-        sourcemap: true,
-        target: ["esnext"],
-        logLevel: "error",
-      };
-      if (fs.existsSync(path.join(project.root, "tsconfig.production.json"))) {
-        commonBuildOptions["tsconfig"] = "tsconfig.production.json";
-      } else if (fs.existsSync(path.join(project.root, "tsconfig.json"))) {
-        commonBuildOptions["tsconfig"] = "tsconfig.json";
-      }
+  /**
+   * The project tsconfig, or undefined if the project is not using TypeScript
+   * @type {string | undefined}
+   */
+  let tsconfig;
+  if (project.isTs) {
+    tsconfig = getProjectTsconfig(project.root);
+    assert(tsconfig, "Expected tsconfig to be in project");
+    await generateTypeDeclarationFiles(project, tsconfig, ctx);
+  }
+
+  const ignore = [...TEST_GLOBS];
+  if (options.includeStories) {
+    logger.debug("Including stories in the build");
+  } else {
+    ignore.push(...STORIES_GLOBS);
+  }
+  const filesToBuild = await glob(path.join(project.root, SRC_GLOB), {
+    ignore,
+  });
+  logger.debug("Bundling ESM and CJS...");
+  await Promise.all([
+    buildFormat({
+      files: filesToBuild,
+      tsconfig: tsconfig,
+      format: "cjs",
+      outdir: project.distDir + "/cjs",
+    }),
+    buildFormat({
+      files: filesToBuild,
+      tsconfig,
+      format: "esm",
+      outdir: project.distDir,
+    }),
+  ]);
+  logger.debug("Bundling done.");
 
-      await Promise.all([
-        esbuild.build({
-          ...commonBuildOptions,
-          format: "esm",
-          outdir: `dist`,
-        }),
-        esbuild.build({
-          ...commonBuildOptions,
-          format: "cjs",
-          outdir: `dist/cjs`,
-        }),
-      ]);
-      await execa("node", [path.join(__dirname, "copy-files.js")], {
-        env: {},
-        stdio: "inherit",
-      });
-    } catch (err) {
-      console.error(err);
-    }
+  if (options.generateRegistry) {
+    const registryFiles = filesToBuild.filter(
+      (file) => !(file.includes("native") || file.endsWith(".d.ts")),
+    );
+    logger.debug("Generating registry files...");
+    const registryFilePaths = await generateRegistryFiles(
+      project,
+      registryFiles,
+      options.includeStories,
+    );
+    await buildFormat({
+      files: registryFilePaths,
+      tsconfig: tsconfig,
+      format: "cjs",
+      outdir: project.distDir + "/cjs",
+    });
+    logger.log("Generated registry files");
   }
-};
+
+  logger.debug("Copying files to build directory...");
+  copyFiles();
+  logger.debug("Files copied.");
+}

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@digigov/cli-build",
-  "version": "2.0.0-b4cd6916",
+  "version": "2.0.0-d0adc9fb",
   "description": "Build plugin for Digigov CLI",
   "main": "./index.js",
+  "type": "module",
   "author": "GRNET Devs <devs@lists.grnet.gr>",
   "license": "BSD-2-Clause",
   "private": false,
   "dependencies": {
     "@babel/cli": "7.12.1",
     "@babel/compat-data": "7.12.5",
-    "@babel/core": "7.12.13",
+    "@babel/core": "7.26.0",
     "@babel/helper-validator-identifier": "7.9.5",
     "@babel/plugin-proposal-class-properties": "7.12.1",
     "@babel/plugin-proposal-object-rest-spread": "7.12.1",
@@ -26,22 +27,31 @@
     "babel-plugin-transform-react-constant-elements": "6.23.0",
     "babel-plugin-transform-react-remove-prop-types": "0.4.24",
     "fs-extra": "11.2.0",
-    "glob": "7.1.6",
-    "typescript": "5.6.2",
-    "@types/node": "18.19.0",
+    "globby": "11.0.0",
     "babel-plugin-istanbul": "7.0.0",
     "publint": "0.1.8",
+    "rimraf": "3.0.2",
     "esbuild": "0.23.0",
-    "@digigov/babel-ts-to-proptypes": "1.1.0"
+    "commander": "12.1.0",
+    "ts-morph": "25.0.0"
   },
   "devDependencies": {
-    "publint": "0.1.8"
+    "publint": "0.1.8",
+    "vitest": "2.1.3",
+    "@digigov/cli-test": "2.0.0-d0adc9fb",
+    "@types/fs-extra": "11.0.4",
+    "@types/node": "18.19.0",
+    "typescript": "5.6.2"
   },
   "peerDependencies": {
-    "@digigov/cli": "1.1.2-b4cd6916",
-    "rimraf": "3.0.2",
+    "@digigov/cli": "2.0.0-d0adc9fb",
     "next": "13.1.1"
   },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
   "scripts": {
     "publint": "publint"
   }

package/tsconfig.base.json

@@ -12,9 +12,6 @@
       "@digigov/auth/*": ["./auth/src/*"],
       "@digigov/auth/": ["./auth/src"],
       "@digigov/auth": ["./auth/src"],
-      "@digigov/benchmark/*": ["./benchmark/src/*"],
-      "@digigov/benchmark/": ["./benchmark/src"],
-      "@digigov/benchmark": ["./benchmark/src"],
       "@digigov/text-search/*": ["./text-search/src/*"],
       "@digigov/text-search/": ["./text-search/src"],
       "@digigov/text-search": ["./text-search/src"],
@@ -36,14 +33,15 @@
       "@digigov/react-experimental/*": ["../libs-ui/react-experimental/src/*"],
       "@digigov/react-experimental/": ["../libs-ui/react-experimental/src"],
       "@digigov/react-experimental": ["../libs-ui/react-experimental/src"],
-      "@digigov/storybook/*": ["../examples/storybook/stories/*"]
+      "@digigov/storybook/*": ["../examples/storybook/stories/*"],
+      "@uides/stepwise/*": ["./stepwise/src/*"],
+      "@uides/stepwise/": ["./stepwise/src"],
+      "@uides/stepwise": ["./stepwise/src"]
     }
   },
   "include": [
     "../../libs/auth/src/**/*.tsx",
     "../../libs/auth/src/*.tsx",
-    "../../libs/benchmark/src/**/*.tsx",
-    "../../libs/benchmark/src/*.tsx",
     "../../libs/text-search/src/**/*.tsx",
     "../../libs/text-search/src/*.tsx",
     "../../libs/text-search/src/**/*.ts",

package/tsconfig.json

@@ -1,45 +1,12 @@
 {
-  "extends": "./tsconfig.base.json",
+  "extends": "@digigov/cli/tsconfig.cli",
   "compilerOptions": {
     "types": [
-      "node"
-    ],
-    "outDir": "dist",
-    "paths": {
-      "@digigov/babel-ts-to-proptypes": [
-        "node_modules/@digigov/babel-ts-to-proptypes/src"
-      ],
-      "@digigov/babel-ts-to-proptypes/": [
-        "node_modules/@digigov/babel-ts-to-proptypes/src/"
-      ],
-      "@digigov/babel-ts-to-proptypes/*": [
-        "node_modules/@digigov/babel-ts-to-proptypes/src/*"
-      ],
-      "@digigov/cli": [
-        "node_modules/@digigov/cli/src"
-      ],
-      "@digigov/cli/": [
-        "node_modules/@digigov/cli/src/"
-      ],
-      "@digigov/cli/*": [
-        "node_modules/@digigov/cli/src/*"
-      ],
-      "@digigov/cli-build": [
-        "./src"
-      ],
-      "@digigov/cli-build/": [
-        "./src/"
-      ],
-      "@digigov/cli-build/*": [
-        "./src/*"
-      ]
-    },
-    "baseUrl": "./"
+      "vitest/globals"
+    ]
   },
   "include": [
-    "index.js"
-  ],
-  "exclude": [
-    "node_modules"
+    "./*.js",
+    "__tests__"
   ]
 }

package/babel.config.js

@@ -1 +0,0 @@
-module.exports = require('./babel.common').config