@digigov/cli-build 2.0.0-13876dba → 2.0.0-16fbe090

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
+  }
 }

package/tsconfig.json

@@ -1,12 +1,8 @@
 {
   "extends": "@digigov/cli/tsconfig.cli",
   "compilerOptions": {
-    "types": [
-      "vitest/globals"
-    ]
+    "types": ["vitest/globals"]
   },
-  "include": [
-    "./*.js",
-    "__tests__"
-  ]
+  "include": ["./*.js", "__tests__"],
+  "exclude": ["eslint.config.js", ".prettierrc.cjs"]
 }

package/babel.common.cjs

@@ -1,119 +0,0 @@
-// Mostly shared from
-// https://github.com/mui-org/material-ui/blob/master/babel.config.js
-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(true) : {};
-
-  const BABEL_ENV = process.env.BABEL_ENV || "esm";
-  const BABEL_PUBLISH = process.env.BABEL_PUBLISH || false;
-  const NODE_ENV = process.env.NODE_ENV;
-  const IS_COMMONJS = BABEL_ENV === "cjs" || NODE_ENV === "test";
-
-  const PRESETS = [
-    [
-      require.resolve("@babel/preset-env"),
-      {
-        modules: IS_COMMONJS ? "commonjs" : false,
-      },
-    ],
-    require.resolve("@babel/preset-react"),
-  ];
-
-  if (project.isTs) {
-    PRESETS.push(require.resolve("@babel/preset-typescript"));
-  }
-
-  const PLUGINS_COMMON = [
-    require.resolve("babel-plugin-optimize-clsx"),
-    [
-      require.resolve("@babel/plugin-proposal-class-properties"),
-      { loose: true },
-    ],
-    [
-      require.resolve("@babel/plugin-proposal-object-rest-spread"),
-      { loose: true },
-    ],
-    // any package needs to declare 7.4.4 as a runtime dependency. default is ^7.0.0
-    [require.resolve("@babel/plugin-transform-runtime"), { version: "^7.4.4" }],
-    // for IE 11 support
-    require.resolve("@babel/plugin-transform-object-assign"),
-    require.resolve("babel-plugin-transform-react-constant-elements"),
-  ];
-
-  const PLUGINS_PUBLISH = [
-    require.resolve("babel-plugin-transform-dev-warning"),
-    [
-      require.resolve("babel-plugin-react-remove-properties"),
-      { properties: ["data-testid"] },
-    ],
-    [
-      require.resolve("babel-plugin-transform-react-remove-prop-types"),
-      {
-        mode: "unsafe-wrap",
-      },
-    ],
-  ];
-
-  const PLUGINS = PLUGINS_COMMON;
-
-  // Apps images are handled using `next-images` plugin. For libraries there is no
-  // explicit way to provide assets to the App using the library. While not
-  // considered a very good practice, one way to provide images via libraries is
-  // to embed the image data into the library code.
-  if (project.isLib || project.isApp) {
-    PLUGINS.push(require.resolve("babel-plugin-inline-import-data-uri"));
-  }
-
-  if (BABEL_PUBLISH) {
-    PLUGINS.push(...PLUGINS_PUBLISH);
-  }
-
-  if (!opts.docs) {
-    let resolverAlias = {};
-    if (NODE_ENV === "test") resolverAlias = aliases;
-    if (BABEL_ENV === "cjs") {
-      resolverAlias = Object.keys(aliases).reduce((acc, key) => {
-        if (key !== project.name) {
-          acc[`^${key}/(.+)`] = `${key}/cjs/\\1`;
-        }
-        return acc;
-      }, {});
-    }
-
-    const RESOLVER = [
-      require.resolve("babel-plugin-module-resolver"),
-      {
-        alias: resolverAlias,
-        extensions: [".js", ".jsx", ".ts", ".tsx", ".json"],
-        loglevel: "silent",
-      },
-    ];
-    PLUGINS.push(RESOLVER);
-  }
-
-  if (project.isApp) {
-    PRESETS.push(require.resolve("next/babel"));
-  }
-
-  const CONFIG = {
-    presets: PRESETS,
-    plugins: PLUGINS,
-    ignore: [/@babel[\\|/]runtime/],
-    env: {
-      coverage: {
-        plugins: [require.resolve("babel-plugin-istanbul")],
-      },
-      test: {
-        sourceMaps: "both",
-        plugins: [],
-      },
-    },
-  };
-  return CONFIG;
-}
-module.exports = {
-  makeBabelConfig,
-  config: makeBabelConfig(),
-};

package/babel.config.cjs

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

package/build.js

@@ -1,93 +0,0 @@
-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
- * @param {boolean | undefined} [options.noLogs] - Whether to log debug information
- */
-export function buildFormat({
-  files: entryPoints,
-  tsconfig,
-  format,
-  outdir,
-  noLogs,
-}) {
-  assert(format === "esm" || format === "cjs", "Invalid format");
-
-  if (!noLogs)
-    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/tsconfig.common.json

@@ -1,27 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "ESNext",
-    "target": "es5",
-    "lib": [
-      "es6",
-      "dom",
-      "es2019"
-    ],
-    "sourceMap": true,
-    "allowJs": true,
-    "jsx": "react",
-    "declaration": true,
-    "moduleResolution": "node",
-    "forceConsistentCasingInFileNames": true,
-    "noImplicitReturns": true,
-    "noImplicitThis": true,
-    "noImplicitAny": false,
-    "strictNullChecks": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "allowSyntheticDefaultImports": true,
-    "skipDefaultLibCheck": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true
-  }
-}