@digigov/cli-build 2.0.0-07ee8440 → 2.0.0-0b806366

package/index.js

@@ -1,36 +1,38 @@
-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";
-
-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)
+import { DigigovCommand, resolveProject, logger } from '@digigov/cli/lib';
+import { build } from '@rslib/core';
+import copyFiles from './copy-files.js';
+
+import { Option } from 'commander';
+import path from 'path';
+import glob from 'globby';
+import assert from 'assert';
+import { getProjectTsconfig } from './common.js';
+import { generateLazyRegistry, generateRegistry } from './generate-registry.js';
+import transformImportsPlugin from './transform-imports-plugin.js';
+
+const command = new DigigovCommand('build', import.meta.url)
   .option(
-    "--generate-registry",
-    "Generate a registry file for the build output",
+    '--generate-registry',
+    'Generate a registry file for the build output'
   )
   .addOption(
-    new Option("--include-stories", "Include stories in the output").implies({
+    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 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}",
+  '**/*.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}",
+  '**/*.stories.{js,jsx,ts,tsx}',
+  '**/__stories__/**/*.{js,jsx,ts,tsx}',
+  '**/__stories__/*.{js,jsx,ts,tsx}',
 ];
 
 /**
@@ -40,67 +42,135 @@ const STORIES_GLOBS = [
  * @param {DigigovCommand} ctx
  */
 async function main(options, ctx) {
-  const project = resolveProject();
-
-  await ctx.exec("rimraf", [project.distDir]);
-
-  /**
-   * 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);
-  }
+  /** @type {string[]} */
+  let filesToDelete = [];
+  let isCleaningUp = false;
+  let signalHandlersRegistered = false;
 
-  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.");
-
-  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,
+  const cleanup = async () => {
+    if (isCleaningUp) return;
+    isCleaningUp = true;
+
+    if (options.generateRegistry && filesToDelete.length > 0) {
+      logger.debug('Deleting temporary registry files...');
+      try {
+        await ctx.exec('rimraf', filesToDelete, {}, true);
+      } catch (error) {
+        logger.error('Error during cleanup:', error);
+      }
+    }
+
+    // Remove signal handlers after cleanup
+    if (signalHandlersRegistered) {
+      process.off('SIGINT', handleSignal);
+      process.off('SIGTERM', handleSignal);
+    }
+  };
+
+  /** @param {string} signal */
+  const handleSignal = async (signal) => {
+    logger.log(`\nReceived ${signal}, cleaning up...`);
+    await cleanup();
+    process.exit(signal === 'SIGINT' ? 130 : 143);
+  };
+
+  // Register signal handlers
+  process.on('SIGINT', handleSignal);
+  process.on('SIGTERM', handleSignal);
+  signalHandlersRegistered = true;
+
+  try {
+    const project = resolveProject();
+
+    await ctx.exec('rimraf', [project.distDir]);
+
+    /**
+     * 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');
+    }
+
+    if (options.generateRegistry) {
+      logger.debug('Generating registry files...');
+
+      const initialFiles = await glob(path.join(project.root, SRC_GLOB), {
+        ignore: [...TEST_GLOBS, ...STORIES_GLOBS],
+      });
+
+      const filesToIncludeInRegistry = initialFiles.filter(
+        (file) => !(file.includes('native') || file.endsWith('.d.ts'))
+      );
+      let storiesFiles = null;
+      if (options.includeStories) {
+        logger.debug('Including stories in the registry...');
+
+        storiesFiles = await glob(
+          STORIES_GLOBS.map((glob) =>
+            path.join(project.root, project.src, glob)
+          ),
+          {
+            ignore: ['**/*.native.*, **/*.d.ts'],
+          }
+        );
+      }
+
+      filesToDelete = await Promise.all([
+        storiesFiles
+          ? generateRegistry(project, storiesFiles, 'stories-registry.ts')
+          : null,
+        generateRegistry(project, filesToIncludeInRegistry, 'registry.ts'),
+        generateLazyRegistry(project, filesToIncludeInRegistry, 'lazy.ts'),
+      ]).then((paths) => paths.filter((p) => p !== null));
+
+      logger.log('Generated registry files');
+    }
+
+    const IGNORE_BLOBS = [...TEST_GLOBS, ...STORIES_GLOBS].map(
+      (path) => `!${project.root}/${path}`
     );
-    await buildFormat({
-      files: registryFilePaths,
-      tsconfig: tsconfig,
-      format: "cjs",
-      outdir: project.distDir + "/cjs",
+
+    logger.debug('Building...');
+    await build({
+      source: {
+        tsconfigPath: tsconfig,
+        entry: {
+          index: [`${project.root}/${SRC_GLOB}`, ...IGNORE_BLOBS],
+        },
+      },
+      output: {
+        distPath: {
+          root: project.distDir,
+        },
+      },
+      lib: [
+        {
+          redirect: {
+            dts: {
+              extension: true,
+            },
+          },
+          bundle: false,
+          dts: {
+            bundle: false,
+            autoExtension: true,
+          },
+          format: 'esm',
+          plugins: [
+            transformImportsPlugin(project, ['@uides/react-qr-reader']),
+          ],
+        },
+      ],
     });
-    logger.log("Generated registry files");
-  }
+    logger.debug('Building done.');
 
-  logger.debug("Copying files to build directory...");
-  copyFiles();
-  logger.debug("Files copied.");
+    logger.debug('Copying files to build directory...');
+    copyFiles();
+    logger.debug('Files copied.');
+  } finally {
+    await cleanup();
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digigov/cli-build",
-  "version": "2.0.0-07ee8440",
+  "version": "2.0.0-0b806366",
   "description": "Build plugin for Digigov CLI",
   "main": "./index.js",
   "type": "module",
@@ -8,43 +8,28 @@
   "license": "BSD-2-Clause",
   "private": false,
   "dependencies": {
-    "@babel/cli": "7.12.1",
-    "@babel/compat-data": "7.12.5",
-    "@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",
-    "@babel/plugin-transform-object-assign": "7.12.1",
-    "@babel/plugin-transform-runtime": "7.12.1",
-    "@babel/preset-env": "7.12.13",
-    "@babel/preset-react": "7.12.13",
-    "@babel/preset-typescript": "7.12.1",
-    "babel-plugin-inline-import-data-uri": "1.0.1",
-    "babel-plugin-module-resolver": "4.0.0",
-    "babel-plugin-optimize-clsx": "1.1.1",
-    "babel-plugin-react-remove-properties": "0.3.0",
-    "babel-plugin-transform-dev-warning": "0.1.1",
-    "babel-plugin-transform-react-constant-elements": "6.23.0",
-    "babel-plugin-transform-react-remove-prop-types": "0.4.24",
     "fs-extra": "11.2.0",
     "globby": "11.0.0",
-    "babel-plugin-istanbul": "7.0.0",
     "publint": "0.1.8",
     "rimraf": "3.0.2",
-    "esbuild": "0.23.0",
     "commander": "12.1.0",
-    "ts-morph": "25.0.0"
+    "ts-morph": "25.0.0",
+    "@rslib/core": "0.15.1"
   },
   "devDependencies": {
+    "@digigov/cli": "2.0.0-0b806366",
+    "@digigov/cli-lint": "2.0.0-0b806366",
     "publint": "0.1.8",
     "vitest": "2.1.3",
-    "@digigov/cli-test": "2.0.0-07ee8440",
+    "@digigov/cli-test": "2.0.0-0b806366",
     "@types/fs-extra": "11.0.4",
-    "@types/node": "18.19.0",
-    "typescript": "5.6.2"
+    "@types/node": "20.17.24",
+    "typescript": "5.6.2",
+    "eslint": "9.16.0",
+    "prettier": "3.4.2"
   },
   "peerDependencies": {
-    "@digigov/cli": "2.0.0-07ee8440",
+    "@digigov/cli": "2.0.0-0b806366",
     "next": "13.1.1"
   },
   "peerDependenciesMeta": {
@@ -53,6 +38,8 @@
     }
   },
   "scripts": {
-    "publint": "publint"
+    "publint": "publint",
+    "lint": "digigov lint",
+    "typecheck": "tsc"
   }
 }

package/transform-imports-plugin.js

@@ -0,0 +1,263 @@
+import { logger } from '@digigov/cli/lib';
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * @param {Record<string, any>} project
+ * @param {string[]} [pathsToIgnore=[]]
+ * @returns {import('@rslib/core').rsbuild.RsbuildPlugin}
+ */
+export default function transformImportsPlugin(project, pathsToIgnore = []) {
+  const projectName = project['name'];
+  const projectRoot = project['root'];
+  const workspace = project['workspace'];
+
+  if (Object.keys(workspace).length === 0) {
+    throw new Error(
+      `transform-imports-plugin can only be used in workspace projects. ${projectName} is not a workspace project.`
+    );
+  }
+
+  const projectScopes =
+    workspace.config.projects.map((p) => p.packageName) ?? [];
+
+  if (projectScopes.length === 0) {
+    logger.warn(
+      `No project scopes found for ${projectName}. Plugin may not transform any imports.`
+    );
+  }
+
+  const importRegex =
+    /(?:^|[^'"\\])(?:from|import)\s*\(\s*['"]([^'"]+)['"]\s*\)|(?:from|import)\s+['"]([^'"]+)['"]/gm;
+
+  const packageJsonCache = new Map();
+  const fileExistsCache = new Map();
+  const resolvedImportsCache = new Map();
+
+  /**
+   * Check if a package uses exports field
+   * @param {string} packageName
+   * @returns {boolean}
+   */
+  function hasExportsField(packageName) {
+    if (packageJsonCache.has(packageName)) {
+      return packageJsonCache.get(packageName);
+    }
+
+    try {
+      const pkgJsonPath = path.join(
+        projectRoot,
+        'node_modules',
+        packageName,
+        'package.json'
+      );
+
+      if (fs.existsSync(pkgJsonPath)) {
+        const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+        const hasExports = !!pkgJson.exports;
+        packageJsonCache.set(packageName, hasExports);
+        return hasExports;
+      }
+    } catch (error) {
+      logger.warn(`Failed to read package.json for ${packageName}:`, error);
+    }
+
+    packageJsonCache.set(packageName, false);
+    return false;
+  }
+
+  /**
+   * Check if a file exists with any of the given suffixes (with caching)
+   * @param {string} basePath
+   * @param {string[]} suffixes
+   * @returns {string | null} The matching suffix or null
+   */
+  function findFileWithSuffix(basePath, suffixes) {
+    const cacheKey = `${basePath}:${suffixes.join(',')}`;
+
+    if (fileExistsCache.has(cacheKey)) {
+      return fileExistsCache.get(cacheKey);
+    }
+
+    for (const suffix of suffixes) {
+      const fullPath = basePath + suffix;
+      if (fs.existsSync(fullPath)) {
+        fileExistsCache.set(cacheKey, suffix);
+        return suffix;
+      }
+    }
+
+    fileExistsCache.set(cacheKey, null);
+    return null;
+  }
+
+  /**
+   * Extract the package name from an import path
+   * @param {string} importPath
+   * @returns {string} The package name
+   */
+  function getPackageName(importPath) {
+    if (importPath.startsWith('@')) {
+      const parts = importPath.split('/');
+      return parts.slice(0, 2).join('/');
+    }
+    // @ts-expect-error - assured string
+    return importPath.split('/')[0];
+  }
+
+  /**
+   * Check if a package is internal based on project scopes
+   * @param {string} packageName
+   * @returns {boolean}
+   */
+  function isInternalPackage(packageName) {
+    return projectScopes.some((scope) => packageName.startsWith(scope));
+  }
+
+  /**
+   * Determine if an import should be skipped
+   * @param {string} importPath
+   * @returns {boolean}
+   */
+  function shouldSkipImport(importPath) {
+    return (
+      !importPath ||
+      importPath.includes(projectName) ||
+      pathsToIgnore.some((ignorePath) => importPath.startsWith(ignorePath)) ||
+      importPath.endsWith('.js') ||
+      importPath.endsWith('.mjs') ||
+      importPath.endsWith('.cjs') ||
+      importPath.startsWith('.') ||
+      importPath.startsWith('/') ||
+      importPath.startsWith('node:') ||
+      !importPath.includes('/')
+    );
+  }
+
+  /**
+   * Transform an internal package import
+   * @param {string} importPath
+   * @returns {string | null}
+   */
+  function transformInternalPackageImport(importPath) {
+    const parts = importPath.split('/');
+    const dependencyName = parts[1];
+
+    if (!dependencyName) return null;
+
+    // Replace the dependency name to point to /src
+    const srcPath = [...parts];
+    srcPath[1] = `${dependencyName}/src`;
+    const srcImportPath = srcPath.join('/');
+
+    const resolvedBase = path.join(projectRoot, 'node_modules', srcImportPath);
+
+    // Check for direct file match
+    const directMatch = findFileWithSuffix(resolvedBase, [
+      '.js',
+      '.jsx',
+      '.ts',
+      '.tsx',
+    ]);
+    if (directMatch) {
+      return importPath + '.js';
+    }
+
+    // Check for index file
+    const indexMatch = findFileWithSuffix(resolvedBase, [
+      '/index.js',
+      '/index.jsx',
+      '/index.ts',
+      '/index.tsx',
+    ]);
+    if (indexMatch) {
+      return importPath + '/index.js';
+    }
+
+    return null;
+  }
+
+  /**
+   * Transform a third-party package import
+   * @param {string} importPath
+   * @returns {string | null}
+   */
+  function transformThirdPartyImport(importPath) {
+    const resolvedBase = path.join(projectRoot, 'node_modules', importPath);
+
+    // Check for direct .js file
+    if (findFileWithSuffix(resolvedBase, ['.js'])) {
+      return importPath + '.js';
+    }
+
+    // Check for index.js
+    if (findFileWithSuffix(resolvedBase, ['/index.js'])) {
+      return importPath + '/index.js';
+    }
+
+    return null;
+  }
+
+  return {
+    name: 'transform-imports-plugin',
+    setup(api) {
+      api.transform(
+        { test: /\.[jt]sx?$/, order: 'post' },
+        ({ code, resourcePath }) => {
+          const transformedCode = code.replace(
+            importRegex,
+            (fullMatch, dynamicImport, staticImport) => {
+              const importPath = dynamicImport || staticImport;
+
+              // Early return for skippable imports
+              if (shouldSkipImport(importPath)) {
+                return fullMatch;
+              }
+
+              // Check cache first
+              if (resolvedImportsCache.has(importPath)) {
+                const cached = resolvedImportsCache.get(importPath);
+                return cached
+                  ? fullMatch.replace(importPath, cached)
+                  : fullMatch;
+              }
+
+              const packageName = getPackageName(importPath);
+
+              // Skip third-party packages with exports field
+              if (
+                !isInternalPackage(packageName) &&
+                hasExportsField(packageName)
+              ) {
+                logger.debug(`Skipping ${importPath} - uses exports field`);
+                resolvedImportsCache.set(importPath, null);
+                return fullMatch;
+              }
+
+              // Transform based on package type
+              let newImportPath = null;
+              if (isInternalPackage(packageName)) {
+                newImportPath = transformInternalPackageImport(importPath);
+              } else {
+                newImportPath = transformThirdPartyImport(importPath);
+              }
+
+              // Cache the result
+              resolvedImportsCache.set(importPath, newImportPath);
+
+              if (newImportPath) {
+                logger.debug(`Transformed import in ${resourcePath}`);
+                logger.debug(`   ${importPath} => ${newImportPath}\n`);
+                return fullMatch.replace(importPath, newImportPath);
+              }
+
+              return fullMatch;
+            }
+          );
+
+          return { code: transformedCode };
+        }
+      );
+    },
+  };
+}

package/tsconfig.base.json

@@ -1,62 +1,24 @@
 {
-  "extends": "./tsconfig.common.json",
   "compilerOptions": {
-    "baseUrl": "../../libs/",
-    "paths": {
-      "@digigov/ui/*": ["./ui/src/*"],
-      "@digigov/ui/": ["./ui/src"],
-      "@digigov/ui": ["./ui/src"],
-      "@digigov/ui-dilosi-integration/*": ["./ui-dilosi-integration/src/*"],
-      "@digigov/ui-dilosi-integration/": ["./ui-dilosi-integration/src"],
-      "@digigov/ui-dilosi-integration": ["./ui-dilosi-integration/src"],
-      "@digigov/auth/*": ["./auth/src/*"],
-      "@digigov/auth/": ["./auth/src"],
-      "@digigov/auth": ["./auth/src"],
-      "@digigov/text-search/*": ["./text-search/src/*"],
-      "@digigov/text-search/": ["./text-search/src"],
-      "@digigov/text-search": ["./text-search/src"],
-      "@digigov/form/*": ["./form/src/*"],
-      "@digigov/form/": ["./form/src"],
-      "@digigov/form": ["./form/src"],
-      "@digigov/form-dilosi-integration/*": ["./form-dilosi-integration/src/*"],
-      "@digigov/form-dilosi-integration/": ["./form-dilosi-integration/src"],
-      "@digigov/form-dilosi-integration": ["./form-dilosi-integration/src"],
-      "@digigov/nextjs/*": ["./nextjs/src/*"],
-      "@digigov/nextjs/": ["./nextjs/src"],
-      "@digigov/nextjs": ["./nextjs/src"],
-      "@digigov/react-core/*": ["../libs-ui/react-core/src/*"],
-      "@digigov/react-core/": ["../libs-ui/react-core/src"],
-      "@digigov/react-core": ["../libs-ui/react-core/src"],
-      "@digigov/react-icons/*": ["../libs-ui/react-icons/src/*"],
-      "@digigov/react-icons/": ["../libs-ui/react-icons/src"],
-      "@digigov/react-icons": ["../libs-ui/react-icons/src"],
-      "@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/*"],
-      "@uides/stepwise/*": ["./stepwise/src/*"],
-      "@uides/stepwise/": ["./stepwise/src"],
-      "@uides/stepwise": ["./stepwise/src"]
-    }
-  },
-  "include": [
-    "../../libs/auth/src/**/*.tsx",
-    "../../libs/auth/src/*.tsx",
-    "../../libs/text-search/src/**/*.tsx",
-    "../../libs/text-search/src/*.tsx",
-    "../../libs/text-search/src/**/*.ts",
-    "../../libs/text-search/src/*.ts",
-    "../../libs/form/src/**/*.(tsx|ts)",
-    "../../libs/form/src/*.(tsx|ts)",
-    "../../libs/form-dilosi-integration/src/**/*.(tsx|ts)",
-    "../../libs/form-dilosi-integration/src/*.(tsx|ts)",
-    "../../libs/ui-dilosi-integration/src/**/*.(tsx|ts)",
-    "../../libs/ui-dilosi-integration/src/*.(tsx|ts)",
-    "../../libs/ui/src/**/*.(tsx|ts)",
-    "../../libs/ui/src/*.(tsx|ts)",
-    "../../libs/auth/src/**/*.tsx",
-    "../../libs/auth/src/*.tsx",
-    "../../libs/nextjs/**/*.tsx",
-    "../../libs/nextjs/*.tsx"
-  ]
+    "module": "ESNext",
+    "target": "es5",
+    "lib": ["es6", "dom", "es2019"],
+    "sourceMap": true,
+    "allowJs": true,
+    "jsx": "react",
+    "declaration": true,
+    "moduleResolution": "bundler",
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noImplicitAny": false,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "allowSyntheticDefaultImports": true,
+    "skipDefaultLibCheck": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  }
 }