@unisphere/cli 1.58.6 → 1.58.7

package/bundler/package/rollup.js

@@ -7,9 +7,139 @@ const svg = require('@svgr/rollup');
 const fs = require('fs');
 const path = require('path');
 const { getEnvVariables } = require('../../src/lib/utils/unisphere/get-env-variables');
+const os = require('os');
+
+function createTempBuildTsconfig({
+  projectRoot,
+  baseTsconfigPath, // can be absolute OR relative to projectRoot
+  compilerOptions = {},
+}) {
+  if (!projectRoot) {
+    throw new Error('createTempBuildTsconfig: projectRoot is required');
+  }
+  if (!baseTsconfigPath) {
+    throw new Error('createTempBuildTsconfig: baseTsconfigPath is required');
+  }
+
+  const resolvedProjectRoot = path.resolve(projectRoot);
+
+  // ✅ resolve base tsconfig relative to projectRoot (unless already absolute)
+  const resolvedBaseTsconfig = path.isAbsolute(baseTsconfigPath)
+    ? baseTsconfigPath
+    : path.resolve(resolvedProjectRoot, baseTsconfigPath);
+
+  if (!fs.existsSync(resolvedBaseTsconfig)) {
+    throw new Error(
+      `createTempBuildTsconfig: base tsconfig not found at: ${resolvedBaseTsconfig}`
+    );
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'unisphere-tsc-'));
+  const tempTsconfigPath = path.join(tempDir, 'tsconfig.build.json');
+
+  // ✅ important: "extends" can be absolute; TS supports it.
+  const tsconfig = {
+    extends: resolvedBaseTsconfig,
+    compilerOptions: {
+      ...compilerOptions,
+    },
+  };
+
+  console.log(`creating temporary build file in '${tempTsconfigPath}'`)
+  fs.writeFileSync(tempTsconfigPath, JSON.stringify(tsconfig, null, 2), 'utf8');
+
+  // Optional cleanup
+  const cleanup = () => {
+    try {
+      console.log(`removing temporary folder '${tempDir}'`)
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch { }
+  };
+  process.on('exit', cleanup);
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+
+  return tempTsconfigPath;
+}
 
 const { envVariables, isUnisphereEnvironment } = getEnvVariables();
 
+function generateDynamicPaths(projectRoot) {
+  const paths = {};
+
+  try {
+    // Find workspace root by following tsconfig extends chain
+    const { workspaceRoot, baseTsconfigPath } = findWorkspaceRoot(projectRoot);
+    console.log(`[unisphere] Found workspace root: ${workspaceRoot}`);
+    console.log(`[unisphere] Base tsconfig path: ${baseTsconfigPath}`);
+
+    // Read base tsconfig to get original paths
+    if (fs.existsSync(baseTsconfigPath)) {
+      const baseTsconfig = JSON.parse(fs.readFileSync(baseTsconfigPath, 'utf8'));
+      const originalPaths = baseTsconfig.compilerOptions?.paths || {};
+
+      console.log(`[unisphere] Found ${Object.keys(originalPaths).length} original paths in base tsconfig`);
+
+      // Convert each path from .ts to .d.ts in dist folder
+      Object.entries(originalPaths).forEach(([key, pathArray]) => {
+        const convertedPaths = pathArray.map(originalPath => {
+          // Convert index.ts to index.d.ts and prefix with dist
+          return originalPath.replace(/index\.ts$/, 'index.d.ts').replace(/^/, 'dist/');
+        });
+
+        paths[key] = convertedPaths;
+        console.log(`[unisphere] Converted path mapping: ${key} -> ${convertedPaths.join(', ')}`);
+      });
+    }
+  } catch (error) {
+    console.warn(`[unisphere] Failed to generate dynamic paths: ${error.message}`);
+    console.log(`[unisphere] Falling back to basic path generation`);
+  }
+
+  console.log(`[unisphere] Generated ${Object.keys(paths).length} path mappings`);
+  return paths;
+}
+
+function findWorkspaceRoot(projectRoot) {
+  let currentPath = projectRoot;
+  let tsconfigPath = path.join(currentPath, 'tsconfig.json');
+
+  console.log(`[unisphere] Starting search from: ${projectRoot}`);
+
+  while (fs.existsSync(tsconfigPath)) {
+    const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf8'));
+    const extendsPath = tsconfig.extends;
+
+    if (!extendsPath) {
+      // No extends, this might be the base
+      return { workspaceRoot: currentPath, baseTsconfigPath: tsconfigPath };
+    }
+
+    console.log(`[unisphere] Found extends: ${extendsPath} in ${tsconfigPath}`);
+
+    // Resolve the extends path
+    const resolvedExtendsPath = path.resolve(path.dirname(tsconfigPath), extendsPath);
+
+    if (!fs.existsSync(resolvedExtendsPath)) {
+      // Can't follow the chain further
+      return { workspaceRoot: currentPath, baseTsconfigPath: tsconfigPath };
+    }
+
+    // Check if this is tsconfig.base.json (likely the root)
+    if (path.basename(resolvedExtendsPath) === 'tsconfig.base.json') {
+      const workspaceRoot = path.dirname(resolvedExtendsPath);
+      return { workspaceRoot, baseTsconfigPath: resolvedExtendsPath };
+    }
+
+    // Continue following the chain
+    currentPath = path.dirname(resolvedExtendsPath);
+    tsconfigPath = resolvedExtendsPath;
+  }
+
+  // Fallback - couldn't find the chain
+  throw new Error('Could not find workspace root through tsconfig extends chain');
+}
+
 if (!isUnisphereEnvironment) {
   console.warn(
     'WARNING: Building or linting unisphere elements from outside the unisphere cli will not handle runtimes.'
@@ -27,10 +157,8 @@ const withUnisphere = (config) => {
 
   const onwarn = config.onwarn;
 
-  const esmOutput = config.output;
-
-  config.onwarn = function(warning) {
-    if ( warning.code === 'THIS_IS_UNDEFINED' ) { return; }
+  config.onwarn = function (warning) {
+    if (warning.code === 'THIS_IS_UNDEFINED') { return; }
     return onwarn?.(warning)
   }
 
@@ -59,20 +187,21 @@ const withUnisphere = (config) => {
     };
   }
 
-  config.plugins.push(analyze({     summaryOnly: true, // Adjusts the output to show summary information
+  config.plugins.push(analyze({
+    summaryOnly: true, // Adjusts the output to show summary information
     limit: 20 // Limits the output to the top 10 items
-  }),   replace({
-    "process.env['NODE_ENV']": JSON.stringify(`${envVariables.UNISPHERE_ENV}`),  
+  }), replace({
+    "process.env['NODE_ENV']": JSON.stringify(`${envVariables.UNISPHERE_ENV}`),
     preventAssignment: true,
   }),);
   return config;
 };
 
-const withUnisphereInterceptors =  (config) => {
+const withUnisphereInterceptors = (config) => {
   console.log('patching rollup package config');
   config.unisphere = {
     interceptors: {
-      compilerOptions : (options) => {
+      compilerOptions: (options) => {
         return options;
       }
     }
@@ -92,17 +221,25 @@ module.exports = (unisphereConfig) => {
   const outputPath = path.join('..', '..', '..', 'dist', ...sourcePath);
 
 
+  const dynamicPaths = generateDynamicPaths(unisphereConfig.cwd);
+
+  const tsConfig = createTempBuildTsconfig({
+    projectRoot: unisphereConfig.cwd,
+    baseTsconfigPath: 'tsconfig.lib.json',
+    compilerOptions: {
+      paths: dynamicPaths,
+    },
+  });
   return withUnisphere(withNx(
     {
       main: './src/index.ts',
       outputPath,
-      tsConfig: './tsconfig.lib.json',
-      compiler: 'babel',
+      tsConfig: tsConfig,
       external: ['react', 'react-dom', 'react/jsx-runtime'],
       format: ['esm'],
       assets: [{ input: '.', output: '.', glob: 'README.md' }],
     },
-      withUnisphereInterceptors({
+    withUnisphereInterceptors({
       // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
       plugins: [
         svg({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unisphere/cli",
-  "version": "1.58.6",
+  "version": "1.58.7",
   "bin": {
     "unisphere": "./src/cli.js"
   },