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

package/build.js

@@ -1,9 +1,9 @@
-import { DigigovCommand, logger } from "@digigov/cli/lib";
+import { logger } from '@digigov/cli/lib';
 
-import assert from "assert";
-import path from "path";
-import fs from "fs-extra";
-import baseEsbuild from "esbuild";
+import assert from 'assert';
+import path from 'path';
+import fs from 'fs-extra';
+import baseEsbuild from 'esbuild';
 
 /**
  * Generate TypeScript declaration files
@@ -13,24 +13,24 @@ import baseEsbuild from "esbuild";
  * @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
+ * @param {import("@digigov/cli/lib").DigigovCommand} ctx - The command context
  */
 export async function generateTypeDeclarationFiles(project, tsconfig, ctx) {
-  logger.debug("Building types...");
+  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",
+  await ctx.exec('tsc', [
+    '--emitDeclarationOnly',
+    '--outDir',
+    'dist',
+    '--project',
     tsconfig,
   ]);
 
   const projectBasePath = path.join(distDir, projectBasename);
-  logger.debug("Project base path", projectBasePath);
+  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);
@@ -39,19 +39,19 @@ export async function generateTypeDeclarationFiles(project, tsconfig, ctx) {
     await Promise.all([
       // Move src files to dist
       ...paths.map((p) => {
-        logger.debug("Moving types file", 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);
+        logger.debug('Removing types directory', typesDir);
         fs.rm(path.join(distDir, typesDir), { recursive: true });
       }),
     ]).catch((err) => {
-      logger.error("Error while building types", err);
+      logger.error('Error while building types', err);
     });
   }
-  logger.debug("Types built.");
+  logger.debug('Types built.');
 }
 
 /**
@@ -62,11 +62,19 @@ export async function generateTypeDeclarationFiles(project, tsconfig, ctx) {
  * @param {string | undefined} options.tsconfig - The tsconfig path
  * @param {"esm" | "cjs"} options.format - The module format
  * @param {string} options.outdir - The output directory
+ * @param {boolean | undefined} [options.noLogs] - Whether to log debug information
  */
-export function buildFormat({ files: entryPoints, tsconfig, format, outdir }) {
-  assert(format === "esm" || format === "cjs", "Invalid format");
+export function buildFormat({
+  files: entryPoints,
+  tsconfig,
+  format,
+  outdir,
+  noLogs,
+}) {
+  assert(format === 'esm' || format === 'cjs', 'Invalid format');
 
-  logger.log(`Running: esbuild for ${format.toUpperCase()} format`);
+  if (!noLogs)
+    logger.log(`Running: esbuild for ${format.toUpperCase()} format`);
   return baseEsbuild.build({
     ...BASE_OPTIONS,
     entryPoints,
@@ -78,8 +86,8 @@ export function buildFormat({ files: entryPoints, tsconfig, format, outdir }) {
 
 /** @type {baseEsbuild.BuildOptions} */
 export const BASE_OPTIONS = {
-  logLevel: "error",
-  platform: "node",
+  logLevel: 'error',
+  platform: 'node',
   sourcemap: true,
-  target: ["esnext"],
+  target: ['esnext'],
 };

package/common.js

@@ -1,7 +1,7 @@
-import fs from "fs-extra";
-import path from "path";
+import fs from 'fs-extra';
+import path from 'path';
 
-const POSSIBLE_TS_CONFIGS = ["tsconfig.production.json", "tsconfig.json"];
+const POSSIBLE_TS_CONFIGS = ['tsconfig.production.json', 'tsconfig.json'];
 
 /**
  * Get the tsconfig path for the given project

package/copy-files.js

@@ -1,7 +1,7 @@
-import { logger, resolveProject } from "@digigov/cli/lib";
-import fs from "fs-extra";
-import path from "path";
-import glob from "globby";
+import { logger, resolveProject } from '@digigov/cli/lib';
+import fs from 'fs-extra';
+import path from 'path';
+import glob from 'globby';
 
 const packagePath = process.cwd();
 const project = resolveProject();
@@ -20,14 +20,14 @@ function includeFileInBuild(file) {
 }
 
 function copyRegistryFilesToSrc() {
-  const registryPath = path.resolve(buildPath, "registry/index.js");
-  const lazyPath = path.resolve(buildPath, "lazy/index.js");
+  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");
+  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"));
+  fs.copySync(registryPath, path.resolve(srcPath, 'registry.js'));
+  fs.copySync(lazyPath, path.resolve(srcPath, 'lazy.js'));
 }
 
 /**
@@ -35,21 +35,23 @@ function copyRegistryFilesToSrc() {
  */
 function createRootPackageFile() {
   const packageData = fs.readFileSync(
-    path.resolve(packagePath, "./package.json"),
-    "utf8",
+    path.resolve(packagePath, './package.json'),
+    'utf8'
   );
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const { nyc, scripts, devDependencies, workspaces, ...packageDataOther } =
     JSON.parse(packageData);
   const newPackageData = {
     ...packageDataOther,
     private: false,
-    main: "./cjs/index.js",
-    module: "./index.js",
-    typings: "./index.d.ts",
+    main: './cjs/index.js',
+    module: './index.js',
+    typings: './index.d.ts',
   };
-  const targetPath = path.resolve(buildPath, "./package.json");
+  const targetPath = path.resolve(buildPath, './package.json');
 
-  fs.writeFileSync(targetPath, JSON.stringify(newPackageData, null, 2), "utf8");
+  fs.writeFileSync(targetPath, JSON.stringify(newPackageData, null, 2), 'utf8');
   logger.debug(`Created package.json in build directory`);
 
   return newPackageData;
@@ -60,24 +62,24 @@ function createRootPackageFile() {
  *
  */
 function createNestedPackageFiles() {
-  const indexPaths = glob.sync(path.join(buildPath, "**/index.js"), {
-    ignore: [path.join(buildPath, "cjs/**")],
+  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;
+    if (indexPath === path.join(buildPath, 'index.js')) return;
     const packageData = {
       sideEffects: false,
-      module: "./index.js",
-      types: "./index.d.ts",
+      module: './index.js',
+      types: './index.d.ts',
       main: path.relative(
         path.dirname(indexPath),
-        indexPath.replace(buildPath, path.join(buildPath, "/cjs")),
+        indexPath.replace(buildPath, path.join(buildPath, '/cjs'))
       ),
     };
     fs.writeFileSync(
-      path.join(path.dirname(indexPath), "package.json"),
-      JSON.stringify(packageData, null, 2),
+      path.join(path.dirname(indexPath), 'package.json'),
+      JSON.stringify(packageData, null, 2)
     );
   });
 }
@@ -89,8 +91,8 @@ function createNestedPackageFiles() {
  * @param {string} string - The string to prepend
  */
 function prepend(file, string) {
-  const data = fs.readFileSync(file, "utf8");
-  fs.writeFileSync(file, string + data, "utf8");
+  const data = fs.readFileSync(file, 'utf8');
+  fs.writeFileSync(file, string + data, 'utf8');
   logger.debug(`Prepended license to ${file}`);
 }
 
@@ -100,21 +102,21 @@ function prepend(file, string) {
  * @param {object} packageData - The package data
  */
 function addLicense(packageData) {
-  const license = `/** @license Digigov v${packageData["version"]}
+  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.
  */
 `;
-  ["./index.js", "./index.mjs"].map(async (file) => {
+  ['./index.js', './index.mjs'].map(async (file) => {
     try {
       prepend(path.resolve(buildPath, file), license);
     } catch (err) {
       if (
-        typeof err === "object" &&
+        typeof err === 'object' &&
         err &&
-        "code" in err &&
-        err.code === "ENOENT"
+        'code' in err &&
+        err.code === 'ENOENT'
       ) {
         logger.debug(`Skipped license for ${file}`);
       } else {
@@ -128,13 +130,13 @@ function addLicense(packageData) {
  * Create separate index modules for each directory
  */
 function createSeparateIndexModules() {
-  const files = glob.sync(path.join(buildPath, "**/*.js"), {
-    ignore: [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'));
   });
 }
 
@@ -150,10 +152,10 @@ export default function run() {
   [
     // 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);
+    './src',
+    './README.md',
+    './CHANGELOG.md',
+    '../../LICENSE',
+  ].map((file) => includeFileInBuild(file));
+  addLicense(packageData);
 }

package/eslint.config.js

@@ -0,0 +1,3 @@
+import config from '@digigov/cli-lint/eslint.config';
+
+export default [...config];

package/generate-registry.js

@@ -1,86 +1,39 @@
-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
+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';
+
+/** @typedef {Object} Project - Represents the project to be built
+ * @property {string} root - The project root directory
+ * @property {string} name - The project name as in package.json
+ * @property {string} distDir - The project build directory
  */
-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
+ * Generate registry file 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} 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 {Project} project - The project object
+ * @param {string} [registryFilename="registry.js"] - The name of the registry file
  * @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
+ * @returns {Promise<string>} - The path to the generated registry file
  */
-export function generateRegistryFileContent(
+export async function generateRegistry(
   project,
   absoluteFilePaths,
-  includeStories = false,
+  registryFilename = 'registry.js'
 ) {
+  const registryPath = ensureRegistryPath(project, registryFilename);
+
   const relativePaths = absoluteFilePaths.map((path) => {
     assert(
       path.startsWith(project.root),
-      "Expected path to be in project root",
+      'Expected path to be in project root'
     );
     return toNodeResolvablePath(
-      path.replace(`${project.root}/src/`, `${project.name}/`),
+      path.replace(`${project.root}/src/`, `${project.name}/`)
     );
   });
   let registryPaths = relativePaths.map((path) => ({
@@ -90,25 +43,22 @@ export function generateRegistryFileContent(
 
   if (registryPaths.length === 0)
     throw new Error(
-      "Could not generate registry. No exportable modules found.",
+      'Could not generate registry. No exportable modules found.'
     );
 
   const importStatements = registryPaths.map(
-    (file) => `import * as ${file.uid} from "${file.path}";`,
+    (file) => `import * as ${file.uid} from "${file.path}";`
   );
-  const exportStatements = registryPaths.map(
-    (file) => `  '${file.path}': lazyImport(${file.uid})`,
+  const componentsToExport = 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`);
-  }
+  logger.debug(
+    `Including ${componentsToExport.length} items in ${registryPath}`
+  );
 
-  let out = `
-${importStatements.join("\n")}
+  let registryFileContent = `
+${importStatements.join('\n')}
 function lazyImport(pkgImport) {
   return new Proxy(
     {},
@@ -128,73 +78,29 @@ function lazyImport(pkgImport) {
   )
 }
 export default {
-${components.join(",\n")}
-};
-`;
-
-  if (includeStories) {
-    out += `
-
-export const stories = {
-${stories.join(",\n")}
+${componentsToExport.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, "_");
-}
+  await fs.writeFile(registryPath, registryFileContent);
 
-/**
- * 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];
+  return registryPath;
 }
 
 /**
- * Generate lazy component registry file content for the given project
+ * Generate a lazy registry file 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 {Project} project - The project object
  * @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
+ * @param {string} [lazyFilename="lazy.js"] - The name of the registry file
+ * @returns {Promise<string>} - The path to the generated lazy registry file
  */
-export function generateLazyFileContent(project, filePaths) {
+export async function generateLazyRegistry(
+  project,
+  filePaths,
+  lazyFilename = 'lazy.js'
+) {
+  const lazyPath = ensureRegistryPath(project, lazyFilename);
+
   const tsMorphProject = new TsMorphProject({
     tsConfigFilePath: getProjectTsconfig(project.root),
   });
@@ -211,7 +117,7 @@ export function generateLazyFileContent(project, filePaths) {
 
     for (const exportedComponent of exports) {
       if (
-        exportedComponent !== "default" &&
+        exportedComponent !== 'default' &&
         exportedComponent.match(/^[A-Z]/)
       ) {
         if (
@@ -219,7 +125,7 @@ export function generateLazyFileContent(project, filePaths) {
           allComponents[exportedComponent].length < filePath.length // Make import path more specific
         ) {
           allComponents[exportedComponent] = toNodeResolvablePath(
-            filePath.replace(`${project.root}/src/`, `${project.name}/`),
+            filePath.replace(`${project.root}/src/`, `${project.name}/`)
           );
         }
       }
@@ -230,23 +136,63 @@ export function generateLazyFileContent(project, filePaths) {
 
   if (componentCount === 0)
     throw new Error(
-      "Could not generate lazy registry. No exportable components found.",
+      'Could not generate lazy registry. No exportable components found.'
     );
 
-  logger.debug(`Including ${componentCount} components in lazy registry`);
+  logger.debug(`Including ${componentCount} components in ${lazyPath}`);
 
-  const content = Object.entries(allComponents)
+  const componentsToExport = Object.entries(allComponents)
     .map(
       ([component, filePath]) =>
-        `  '${component}': lazy(() => import('${filePath}').then((module) => ({ default: module['${component}'] })))`,
+        `  '${component}': lazy(() => import('${filePath}').then((module) => ({ default: module['${component}'] })))`
     )
-    .join(",\n");
+    .join(',\n');
 
-  return `import { lazy } from 'react';
+  const lazyFileContent = `import { lazy } from 'react';
 export default {
-${content}
+${componentsToExport}
 };
 `;
+
+  await fs.writeFile(lazyPath, lazyFileContent);
+
+  return lazyPath;
+}
+
+/**
+ * Ensure that the registry file does not already exist at the given path
+ *
+ * @param {Project} project - The project object
+ * @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;
+}
+
+/**
+ * Extract a node-resolvable path
+ *
+ * @param {string} inputPath - The file path
+ * @returns {string} - The node-resolvable path
+ */
+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
+ */
+function createUid(inputPath) {
+  return inputPath.replace(/[/@\-.]/g, '_');
 }
 
 /**