@idealyst/tooling 1.2.30 → 1.2.32

package/dist/analyzer/index.cjs

@@ -32,37 +32,57 @@ var analyzer_exports = {};
 __export(analyzer_exports, {
   analyzeComponents: () => analyzeComponents,
   analyzeTheme: () => analyzeTheme,
+  analyzeThemeSource: () => analyzeThemeSource,
   loadThemeKeys: () => loadThemeKeys,
-  resetThemeCache: () => resetThemeCache
+  resetThemeCache: () => resetThemeCache,
+  toBabelThemeKeys: () => toBabelThemeKeys
 });
 module.exports = __toCommonJS(analyzer_exports);
 
 // src/analyzer/component-analyzer.ts
+var ts3 = __toESM(require("typescript"), 1);
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// src/analyzer/theme-analyzer.ts
 var ts2 = __toESM(require("typescript"), 1);
 var fs2 = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
 
-// src/analyzer/theme-analyzer.ts
+// src/analyzer/theme-source-analyzer.ts
 var ts = __toESM(require("typescript"), 1);
 var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
-function analyzeTheme(themePath, verbose = false) {
+function analyzeThemeSource(themePath, options = {}) {
   const resolvedPath = path.resolve(themePath);
+  const verbose = options.verbose ?? false;
+  const aliases = options.aliases ?? {};
+  const log = (...args) => {
+    if (verbose) console.log("[theme-source-analyzer]", ...args);
+  };
   if (!fs.existsSync(resolvedPath)) {
     throw new Error(`Theme file not found: ${resolvedPath}`);
   }
-  const log = (...args) => {
-    if (verbose) console.log("[theme-analyzer]", ...args);
-  };
   log("Analyzing theme file:", resolvedPath);
-  const program = ts.createProgram([resolvedPath], {
+  const configPath = ts.findConfigFile(path.dirname(resolvedPath), ts.sys.fileExists, "tsconfig.json");
+  let compilerOptions = {
     target: ts.ScriptTarget.ES2020,
     module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Node10,
     strict: true,
     esModuleInterop: true,
     skipLibCheck: true,
-    allowSyntheticDefaultImports: true
-  });
+    allowSyntheticDefaultImports: true,
+    resolveJsonModule: true
+  };
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (!configFile.error) {
+      const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+      compilerOptions = { ...compilerOptions, ...parsed.options };
+    }
+  }
+  const program = ts.createProgram([resolvedPath], compilerOptions);
   const sourceFile = program.getSourceFile(resolvedPath);
   if (!sourceFile) {
     throw new Error(`Failed to parse theme file: ${resolvedPath}`);
@@ -70,7 +90,9 @@ function analyzeTheme(themePath, verbose = false) {
   const ctx = {
     program,
     typeChecker: program.getTypeChecker(),
-    verbose
+    verbose,
+    aliases,
+    analyzedFiles: /* @__PURE__ */ new Set([resolvedPath])
   };
   const values = {
     intents: [],
@@ -93,13 +115,377 @@ function analyzeTheme(themePath, verbose = false) {
           const localName = element.name.text;
           const importedName = element.propertyName?.text ?? localName;
           imports.set(localName, { source, imported: importedName });
+          log(`  Import: ${localName} from '${source}'`);
         }
       }
     }
   });
+  function resolveImportPath(source, fromFile) {
+    for (const [aliasPrefix, aliasPath] of Object.entries(ctx.aliases)) {
+      if (source === aliasPrefix || source.startsWith(aliasPrefix + "/")) {
+        const remainder = source.slice(aliasPrefix.length);
+        let resolved = aliasPath + remainder;
+        if (!path.isAbsolute(resolved)) {
+          resolved = path.resolve(path.dirname(fromFile), resolved);
+        }
+        return resolved;
+      }
+    }
+    if (source.startsWith(".")) {
+      return path.resolve(path.dirname(fromFile), source);
+    }
+    try {
+      return require.resolve(source, { paths: [path.dirname(fromFile)] });
+    } catch {
+      return null;
+    }
+  }
+  function findThemeFile(basePath, preferDark) {
+    const themeFileName = preferDark ? "darkTheme" : "lightTheme";
+    const candidates = [
+      basePath,
+      `${basePath}.ts`,
+      `${basePath}.tsx`,
+      path.join(basePath, "src", `${themeFileName}.ts`),
+      path.join(basePath, `${themeFileName}.ts`),
+      path.join(basePath, "src", "index.ts"),
+      path.join(basePath, "index.ts")
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  function analyzeBaseTheme2(varName) {
+    const importInfo = imports.get(varName);
+    if (!importInfo) {
+      log(`Could not find import for base theme: ${varName}`);
+      return;
+    }
+    log(`Analyzing base theme '${varName}' from '${importInfo.source}'`);
+    const resolvedBase = resolveImportPath(importInfo.source, resolvedPath);
+    if (!resolvedBase) {
+      log(`Could not resolve import path: ${importInfo.source}`);
+      return;
+    }
+    const preferDark = varName.toLowerCase().includes("dark");
+    const themeFile = findThemeFile(resolvedBase, preferDark);
+    if (!themeFile) {
+      log(`Could not find theme file for: ${resolvedBase}`);
+      return;
+    }
+    if (ctx.analyzedFiles.has(themeFile)) {
+      log(`Already analyzed: ${themeFile}`);
+      return;
+    }
+    ctx.analyzedFiles.add(themeFile);
+    log(`Recursively analyzing: ${themeFile}`);
+    const baseValues = analyzeThemeSource(themeFile, { verbose, aliases });
+    mergeThemeValues(values, baseValues, false);
+  }
+  function traceBuilderCalls(node, calls = []) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+        const fnName = node.expression.text;
+        if (fnName === "fromTheme" && node.arguments.length > 0) {
+          const arg = node.arguments[0];
+          if (ts.isIdentifier(arg)) {
+            return { calls, baseThemeVar: arg.text };
+          }
+        }
+      }
+      return { calls, baseThemeVar: null };
+    }
+    const methodName = node.expression.name.text;
+    calls.unshift({ method: methodName, args: node.arguments });
+    const obj = node.expression.expression;
+    if (ts.isCallExpression(obj)) {
+      return traceBuilderCalls(obj, calls);
+    }
+    return { calls, baseThemeVar: null };
+  }
+  function getStringValue2(node) {
+    if (!node) return null;
+    if (ts.isStringLiteral(node)) return node.text;
+    if (ts.isIdentifier(node)) return node.text;
+    if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+    return null;
+  }
+  function getObjectKeys2(node) {
+    return node.properties.filter((prop) => ts.isPropertyAssignment(prop)).map((prop) => {
+      if (ts.isIdentifier(prop.name)) return prop.name.text;
+      if (ts.isStringLiteral(prop.name)) return prop.name.text;
+      return null;
+    }).filter((k) => k !== null);
+  }
+  function processCalls(calls) {
+    log(`Processing ${calls.length} builder method calls`);
+    for (const { method, args } of calls) {
+      switch (method) {
+        case "addIntent": {
+          const name = getStringValue2(args[0]);
+          if (name && !values.intents.includes(name)) {
+            values.intents.push(name);
+            log(`  Found intent: ${name}`);
+          }
+          break;
+        }
+        case "addRadius": {
+          const name = getStringValue2(args[0]);
+          if (name && !values.radii.includes(name)) {
+            values.radii.push(name);
+            log(`  Found radius: ${name}`);
+          }
+          break;
+        }
+        case "addShadow": {
+          const name = getStringValue2(args[0]);
+          if (name && !values.shadows.includes(name)) {
+            values.shadows.push(name);
+            log(`  Found shadow: ${name}`);
+          }
+          break;
+        }
+        case "addBreakpoint": {
+          const name = getStringValue2(args[0]);
+          if (name && !values.breakpoints.includes(name)) {
+            values.breakpoints.push(name);
+            log(`  Found breakpoint: ${name}`);
+          }
+          break;
+        }
+        case "setBreakpoints": {
+          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            const keys = getObjectKeys2(args[0]);
+            for (const key of keys) {
+              if (!values.breakpoints.includes(key)) {
+                values.breakpoints.push(key);
+              }
+            }
+            log(`  Found breakpoints: ${values.breakpoints.join(", ")}`);
+          }
+          break;
+        }
+        case "setSizes": {
+          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            for (const prop of args[0].properties) {
+              if (ts.isPropertyAssignment(prop)) {
+                let componentName = null;
+                if (ts.isIdentifier(prop.name)) {
+                  componentName = prop.name.text;
+                } else if (ts.isStringLiteral(prop.name)) {
+                  componentName = prop.name.text;
+                }
+                if (componentName && ts.isObjectLiteralExpression(prop.initializer)) {
+                  const sizeKeys = getObjectKeys2(prop.initializer);
+                  values.sizes[componentName] = sizeKeys;
+                  log(`  Found sizes for ${componentName}: ${sizeKeys.join(", ")}`);
+                  if (componentName === "typography") {
+                    for (const key of sizeKeys) {
+                      if (!values.typography.includes(key)) {
+                        values.typography.push(key);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          } else if (args[0] && ts.isPropertyAccessExpression(args[0])) {
+            const propAccess = args[0];
+            if (ts.isIdentifier(propAccess.expression) && propAccess.name.text === "sizes") {
+              const themeVarName = propAccess.expression.text;
+              log(`  Found sizes reference: ${themeVarName}.sizes`);
+              const importInfo = imports.get(themeVarName);
+              if (importInfo) {
+                log(`  Resolving sizes from imported theme: ${importInfo.source}`);
+                const resolvedBase = resolveImportPath(importInfo.source, resolvedPath);
+                if (resolvedBase) {
+                  const preferDark = themeVarName.toLowerCase().includes("dark");
+                  const themeFile = findThemeFile(resolvedBase, preferDark);
+                  if (themeFile && !ctx.analyzedFiles.has(themeFile)) {
+                    ctx.analyzedFiles.add(themeFile);
+                    const baseValues = analyzeThemeSource(themeFile, { verbose, aliases });
+                    for (const [comp, sizes] of Object.entries(baseValues.sizes)) {
+                      if (!values.sizes[comp]) {
+                        values.sizes[comp] = sizes;
+                        log(`  Inherited sizes for ${comp}: ${sizes.join(", ")}`);
+                      }
+                    }
+                    for (const typo of baseValues.typography) {
+                      if (!values.typography.includes(typo)) {
+                        values.typography.push(typo);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          break;
+        }
+        case "setColors": {
+          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            for (const prop of args[0].properties) {
+              if (ts.isPropertyAssignment(prop)) {
+                let colorType = null;
+                if (ts.isIdentifier(prop.name)) {
+                  colorType = prop.name.text;
+                } else if (ts.isStringLiteral(prop.name)) {
+                  colorType = prop.name.text;
+                }
+                if (colorType && ts.isObjectLiteralExpression(prop.initializer)) {
+                  const colorKeys = getObjectKeys2(prop.initializer);
+                  switch (colorType) {
+                    case "surface":
+                      values.surfaceColors = colorKeys;
+                      log(`  Found surface colors: ${colorKeys.join(", ")}`);
+                      break;
+                    case "text":
+                      values.textColors = colorKeys;
+                      log(`  Found text colors: ${colorKeys.join(", ")}`);
+                      break;
+                    case "border":
+                      values.borderColors = colorKeys;
+                      log(`  Found border colors: ${colorKeys.join(", ")}`);
+                      break;
+                  }
+                }
+              }
+            }
+          }
+          break;
+        }
+        case "build":
+          break;
+        default:
+          log(`  Skipping unknown method: ${method}`);
+      }
+    }
+  }
   function processBuilderChain(node) {
     if (!ts.isCallExpression(node)) return;
-    if (ts.isPropertyAccessExpression(node.expression)) {
+    if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "build") {
+      log("Found .build() call, tracing chain...");
+      const { calls, baseThemeVar } = traceBuilderCalls(node);
+      if (baseThemeVar) {
+        log(`Found fromTheme(${baseThemeVar})`);
+        analyzeBaseTheme2(baseThemeVar);
+      }
+      processCalls(calls);
+      return;
+    }
+    ts.forEachChild(node, processBuilderChain);
+  }
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer) {
+          processBuilderChain(decl.initializer);
+        }
+      }
+    }
+    if (ts.isExportAssignment(node)) {
+      processBuilderChain(node.expression);
+    }
+  });
+  log("Analysis complete:");
+  log(`  Intents: ${values.intents.join(", ")}`);
+  log(`  Radii: ${values.radii.join(", ")}`);
+  log(`  Shadows: ${values.shadows.join(", ")}`);
+  log(`  Breakpoints: ${values.breakpoints.join(", ")}`);
+  log(`  Typography: ${values.typography.join(", ")}`);
+  log(`  Size components: ${Object.keys(values.sizes).join(", ")}`);
+  return values;
+}
+function mergeThemeValues(target, source, sourceOverrides) {
+  const mergeArrays = (targetArr, sourceArr) => {
+    for (const item of sourceArr) {
+      if (!targetArr.includes(item)) {
+        targetArr.push(item);
+      }
+    }
+  };
+  mergeArrays(target.intents, source.intents);
+  mergeArrays(target.radii, source.radii);
+  mergeArrays(target.shadows, source.shadows);
+  mergeArrays(target.breakpoints, source.breakpoints);
+  mergeArrays(target.typography, source.typography);
+  mergeArrays(target.surfaceColors, source.surfaceColors);
+  mergeArrays(target.textColors, source.textColors);
+  mergeArrays(target.borderColors, source.borderColors);
+  for (const [component, sizes] of Object.entries(source.sizes)) {
+    if (sourceOverrides || !target.sizes[component]) {
+      target.sizes[component] = sizes;
+    }
+  }
+}
+function toBabelThemeKeys(values) {
+  return {
+    intents: values.intents,
+    sizes: values.sizes,
+    radii: values.radii,
+    shadows: values.shadows,
+    typography: values.typography
+  };
+}
+
+// src/analyzer/theme-analyzer.ts
+function analyzeTheme(themePath, verbose = false) {
+  const resolvedPath = path2.resolve(themePath);
+  if (!fs2.existsSync(resolvedPath)) {
+    throw new Error(`Theme file not found: ${resolvedPath}`);
+  }
+  const log = (...args) => {
+    if (verbose) console.log("[theme-analyzer]", ...args);
+  };
+  log("Analyzing theme file:", resolvedPath);
+  const program = ts2.createProgram([resolvedPath], {
+    target: ts2.ScriptTarget.ES2020,
+    module: ts2.ModuleKind.ESNext,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    allowSyntheticDefaultImports: true
+  });
+  const sourceFile = program.getSourceFile(resolvedPath);
+  if (!sourceFile) {
+    throw new Error(`Failed to parse theme file: ${resolvedPath}`);
+  }
+  const ctx = {
+    program,
+    typeChecker: program.getTypeChecker(),
+    verbose
+  };
+  const values = {
+    intents: [],
+    sizes: {},
+    radii: [],
+    shadows: [],
+    breakpoints: [],
+    typography: [],
+    surfaceColors: [],
+    textColors: [],
+    borderColors: []
+  };
+  const imports = /* @__PURE__ */ new Map();
+  ts2.forEachChild(sourceFile, (node) => {
+    if (ts2.isImportDeclaration(node)) {
+      const source = node.moduleSpecifier.text;
+      const clause = node.importClause;
+      if (clause?.namedBindings && ts2.isNamedImports(clause.namedBindings)) {
+        for (const element of clause.namedBindings.elements) {
+          const localName = element.name.text;
+          const importedName = element.propertyName?.text ?? localName;
+          imports.set(localName, { source, imported: importedName });
+        }
+      }
+    }
+  });
+  function processBuilderChain(node) {
+    if (!ts2.isCallExpression(node)) return;
+    if (ts2.isPropertyAccessExpression(node.expression)) {
       const methodName = node.expression.name.text;
       if (methodName === "build") {
         const calls = traceBuilderCalls(node);
@@ -107,15 +493,15 @@ function analyzeTheme(themePath, verbose = false) {
         return;
       }
     }
-    ts.forEachChild(node, processBuilderChain);
+    ts2.forEachChild(node, processBuilderChain);
   }
   function traceBuilderCalls(node, calls = []) {
-    if (!ts.isPropertyAccessExpression(node.expression)) {
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+    if (!ts2.isPropertyAccessExpression(node.expression)) {
+      if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression)) {
         const fnName = node.expression.text;
         if (fnName === "fromTheme" && node.arguments.length > 0) {
           const arg = node.arguments[0];
-          if (ts.isIdentifier(arg)) {
+          if (ts2.isIdentifier(arg)) {
             analyzeBaseTheme(arg.text, imports, values, ctx);
           }
         }
@@ -125,7 +511,7 @@ function analyzeTheme(themePath, verbose = false) {
     const methodName = node.expression.name.text;
     calls.unshift({ method: methodName, args: node.arguments });
     const obj = node.expression.expression;
-    if (ts.isCallExpression(obj)) {
+    if (ts2.isCallExpression(obj)) {
       return traceBuilderCalls(obj, calls);
     }
     return calls;
@@ -159,11 +545,11 @@ function analyzeTheme(themePath, verbose = false) {
           break;
         }
         case "setSizes": {
-          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+          if (args[0] && ts2.isObjectLiteralExpression(args[0])) {
             for (const prop of args[0].properties) {
-              if (ts.isPropertyAssignment(prop)) {
+              if (ts2.isPropertyAssignment(prop)) {
                 const componentName = getPropertyName(prop.name);
-                if (componentName && ts.isObjectLiteralExpression(prop.initializer)) {
+                if (componentName && ts2.isObjectLiteralExpression(prop.initializer)) {
                   values.sizes[componentName] = getObjectKeys(prop.initializer);
                   log("  Found sizes for", componentName + ":", values.sizes[componentName]);
                 }
@@ -173,18 +559,18 @@ function analyzeTheme(themePath, verbose = false) {
           break;
         }
         case "setBreakpoints": {
-          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+          if (args[0] && ts2.isObjectLiteralExpression(args[0])) {
             values.breakpoints = getObjectKeys(args[0]);
             log("  Found breakpoints:", values.breakpoints);
           }
           break;
         }
         case "setColors": {
-          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+          if (args[0] && ts2.isObjectLiteralExpression(args[0])) {
             for (const prop of args[0].properties) {
-              if (ts.isPropertyAssignment(prop)) {
+              if (ts2.isPropertyAssignment(prop)) {
                 const colorType = getPropertyName(prop.name);
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
+                if (ts2.isObjectLiteralExpression(prop.initializer)) {
                   const keys = getObjectKeys(prop.initializer);
                   switch (colorType) {
                     case "surface":
@@ -213,15 +599,15 @@ function analyzeTheme(themePath, verbose = false) {
       }
     }
   }
-  ts.forEachChild(sourceFile, (node) => {
-    if (ts.isVariableStatement(node)) {
+  ts2.forEachChild(sourceFile, (node) => {
+    if (ts2.isVariableStatement(node)) {
       for (const decl of node.declarationList.declarations) {
         if (decl.initializer) {
           processBuilderChain(decl.initializer);
         }
       }
     }
-    if (ts.isExportAssignment(node)) {
+    if (ts2.isExportAssignment(node)) {
       processBuilderChain(node.expression);
     }
   });
@@ -242,9 +628,30 @@ function analyzeBaseTheme(varName, imports, values, ctx) {
   }
   log("Base theme", varName, "imported from", importInfo.source);
   if (importInfo.source === "@idealyst/theme" || importInfo.source.includes("@idealyst/theme")) {
-    const defaultValues = getDefaultThemeValues();
-    mergeThemeValues(values, defaultValues);
+    const aliasPath = packageAliases["@idealyst/theme"];
+    if (aliasPath) {
+      const themeFileName = varName.toLowerCase().includes("dark") ? "darkTheme.ts" : "lightTheme.ts";
+      const themePath = path2.join(aliasPath, "src", themeFileName);
+      if (fs2.existsSync(themePath)) {
+        log(`Analyzing @idealyst/theme from source: ${themePath}`);
+        try {
+          const sourceValues = analyzeThemeSource(themePath, {
+            verbose: ctx.verbose,
+            aliases: packageAliases
+          });
+          mergeThemeValues2(values, sourceValues);
+          log("Successfully extracted values from source");
+          return;
+        } catch (err) {
+          log("Failed to analyze source, falling back to defaults:", err.message);
+        }
+      } else {
+        log(`Theme file not found at alias path: ${themePath}`);
+      }
+    }
     log("Using default @idealyst/theme values");
+    const defaultValues = getDefaultThemeValues();
+    mergeThemeValues2(values, defaultValues);
     return;
   }
   log("Skipping base theme analysis for:", importInfo.source);
@@ -254,6 +661,7 @@ function getDefaultThemeValues() {
     intents: ["primary", "success", "danger", "warning", "neutral", "info"],
     sizes: {
       button: ["xs", "sm", "md", "lg", "xl"],
+      iconButton: ["xs", "sm", "md", "lg", "xl"],
       chip: ["xs", "sm", "md", "lg", "xl"],
       badge: ["xs", "sm", "md", "lg", "xl"],
       icon: ["xs", "sm", "md", "lg", "xl"],
@@ -267,6 +675,7 @@ function getDefaultThemeValues() {
       progress: ["xs", "sm", "md", "lg", "xl"],
       accordion: ["xs", "sm", "md", "lg", "xl"],
       activityIndicator: ["xs", "sm", "md", "lg", "xl"],
+      alert: ["xs", "sm", "md", "lg", "xl"],
       breadcrumb: ["xs", "sm", "md", "lg", "xl"],
       list: ["xs", "sm", "md", "lg", "xl"],
       menu: ["xs", "sm", "md", "lg", "xl"],
@@ -287,7 +696,7 @@ function getDefaultThemeValues() {
     borderColors: ["primary", "secondary", "tertiary", "disabled"]
   };
 }
-function mergeThemeValues(target, source) {
+function mergeThemeValues2(target, source) {
   target.intents.push(...source.intents.filter((k) => !target.intents.includes(k)));
   target.radii.push(...source.radii.filter((k) => !target.radii.includes(k)));
   target.shadows.push(...source.shadows.filter((k) => !target.shadows.includes(k)));
@@ -304,32 +713,58 @@ function mergeThemeValues(target, source) {
 }
 function getStringValue(node) {
   if (!node) return null;
-  if (ts.isStringLiteral(node)) return node.text;
-  if (ts.isIdentifier(node)) return node.text;
+  if (ts2.isStringLiteral(node)) return node.text;
+  if (ts2.isIdentifier(node)) return node.text;
   return null;
 }
 function getPropertyName(node) {
-  if (ts.isIdentifier(node)) return node.text;
-  if (ts.isStringLiteral(node)) return node.text;
+  if (ts2.isIdentifier(node)) return node.text;
+  if (ts2.isStringLiteral(node)) return node.text;
   return null;
 }
 function getObjectKeys(node) {
-  return node.properties.filter(ts.isPropertyAssignment).map((prop) => getPropertyName(prop.name)).filter((k) => k !== null);
+  return node.properties.filter(ts2.isPropertyAssignment).map((prop) => getPropertyName(prop.name)).filter((k) => k !== null);
 }
 var themeKeysCache = null;
 var themeLoadAttempted = false;
+var packageAliases = {};
+function resolveWithAliases(source, fromDir) {
+  for (const [aliasPrefix, aliasPath] of Object.entries(packageAliases)) {
+    if (source === aliasPrefix || source.startsWith(aliasPrefix + "/")) {
+      const remainder = source.slice(aliasPrefix.length);
+      let resolved = aliasPath + remainder;
+      if (!path2.isAbsolute(resolved)) {
+        resolved = path2.resolve(fromDir, resolved);
+      }
+      return resolved;
+    }
+  }
+  return null;
+}
 function loadThemeKeys(opts, rootDir, _babelTypes, verboseMode = false) {
   if (themeLoadAttempted && themeKeysCache) {
     return themeKeysCache;
   }
   themeLoadAttempted = true;
+  if (opts.aliases && typeof opts.aliases === "object") {
+    packageAliases = opts.aliases;
+    if (verboseMode) {
+      console.log("[idealyst-plugin] Configured aliases:", packageAliases);
+    }
+  }
   const themePath = opts.themePath;
   if (!themePath) {
     throw new Error(
       '[idealyst-plugin] themePath is required!\nAdd it to your babel config:\n  ["@idealyst/theme/plugin", { themePath: "./src/theme/styles.ts" }]'
     );
   }
-  const resolvedPath = themePath.startsWith(".") ? path.resolve(rootDir, themePath) : themePath;
+  let resolvedPath;
+  const aliasResolved = resolveWithAliases(themePath, rootDir);
+  if (aliasResolved && fs2.existsSync(aliasResolved)) {
+    resolvedPath = aliasResolved;
+  } else {
+    resolvedPath = themePath.startsWith(".") ? path2.resolve(rootDir, themePath) : themePath;
+  }
   if (verboseMode) {
     console.log("[idealyst-plugin] Analyzing theme file via @idealyst/tooling:", resolvedPath);
   }
@@ -364,14 +799,14 @@ function analyzeComponents(options) {
   const registry = {};
   const themeValues = analyzeTheme(themePath, false);
   for (const componentPath of componentPaths) {
-    const resolvedPath = path2.resolve(componentPath);
-    if (!fs2.existsSync(resolvedPath)) {
+    const resolvedPath = path3.resolve(componentPath);
+    if (!fs3.existsSync(resolvedPath)) {
       console.warn(`[component-analyzer] Path not found: ${resolvedPath}`);
       continue;
     }
     const componentDirs = findComponentDirs(resolvedPath);
     for (const dir of componentDirs) {
-      const componentName = path2.basename(dir);
+      const componentName = path3.basename(dir);
       if (include && !include.includes(componentName)) continue;
       if (exclude && exclude.includes(componentName)) continue;
       if (!includeInternal && componentName.startsWith("_")) continue;
@@ -385,12 +820,12 @@ function analyzeComponents(options) {
 }
 function findComponentDirs(basePath) {
   const dirs = [];
-  const entries = fs2.readdirSync(basePath, { withFileTypes: true });
+  const entries = fs3.readdirSync(basePath, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dirPath = path2.join(basePath, entry.name);
-    const hasIndex = fs2.existsSync(path2.join(dirPath, "index.ts"));
-    const hasTypes = fs2.existsSync(path2.join(dirPath, "types.ts"));
+    const dirPath = path3.join(basePath, entry.name);
+    const hasIndex = fs3.existsSync(path3.join(dirPath, "index.ts"));
+    const hasTypes = fs3.existsSync(path3.join(dirPath, "types.ts"));
     if (hasIndex || hasTypes) {
       dirs.push(dirPath);
     }
@@ -398,14 +833,14 @@ function findComponentDirs(basePath) {
   return dirs;
 }
 function analyzeComponentDir(dir, componentName, themeValues) {
-  const tsFiles = fs2.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx")).map((f) => path2.join(dir, f));
+  const tsFiles = fs3.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx")).map((f) => path3.join(dir, f));
   if (tsFiles.length === 0) {
     return null;
   }
-  const program = ts2.createProgram(tsFiles, {
-    target: ts2.ScriptTarget.ES2020,
-    module: ts2.ModuleKind.ESNext,
-    jsx: ts2.JsxEmit.React,
+  const program = ts3.createProgram(tsFiles, {
+    target: ts3.ScriptTarget.ES2020,
+    module: ts3.ModuleKind.ESNext,
+    jsx: ts3.JsxEmit.React,
     strict: true,
     esModuleInterop: true,
     skipLibCheck: true
@@ -418,12 +853,12 @@ function analyzeComponentDir(dir, componentName, themeValues) {
   for (const filePath of tsFiles) {
     const sourceFile = program.getSourceFile(filePath);
     if (!sourceFile) continue;
-    ts2.forEachChild(sourceFile, (node) => {
-      if (ts2.isInterfaceDeclaration(node) && node.name.text === propsInterfaceName) {
+    ts3.forEachChild(sourceFile, (node) => {
+      if (ts3.isInterfaceDeclaration(node) && node.name.text === propsInterfaceName) {
         propsInterface = node;
         interfaceDescription = getJSDocDescription(node);
       }
-      if (ts2.isTypeAliasDeclaration(node) && node.name.text === propsInterfaceName) {
+      if (ts3.isTypeAliasDeclaration(node) && node.name.text === propsInterfaceName) {
         propsInterface = node;
         interfaceDescription = getJSDocDescription(node);
       }
@@ -435,8 +870,8 @@ function analyzeComponentDir(dir, componentName, themeValues) {
       for (const filePath of tsFiles) {
         const sourceFile = program.getSourceFile(filePath);
         if (!sourceFile) continue;
-        ts2.forEachChild(sourceFile, (node) => {
-          if ((ts2.isInterfaceDeclaration(node) || ts2.isTypeAliasDeclaration(node)) && node.name.text === altName) {
+        ts3.forEachChild(sourceFile, (node) => {
+          if ((ts3.isInterfaceDeclaration(node) || ts3.isTypeAliasDeclaration(node)) && node.name.text === altName) {
             propsInterface = node;
             interfaceDescription = getJSDocDescription(node);
           }
@@ -468,32 +903,32 @@ function analyzeComponentDir(dir, componentName, themeValues) {
     description,
     props,
     category,
-    filePath: path2.relative(process.cwd(), dir),
+    filePath: path3.relative(process.cwd(), dir),
     sampleProps
   };
 }
 function extractSampleProps(dir) {
-  const docsPath = path2.join(dir, "docs.ts");
-  if (!fs2.existsSync(docsPath)) {
+  const docsPath = path3.join(dir, "docs.ts");
+  if (!fs3.existsSync(docsPath)) {
     return void 0;
   }
   try {
-    const content = fs2.readFileSync(docsPath, "utf-8");
-    const sourceFile = ts2.createSourceFile(
+    const content = fs3.readFileSync(docsPath, "utf-8");
+    const sourceFile = ts3.createSourceFile(
       "docs.ts",
       content,
-      ts2.ScriptTarget.ES2020,
+      ts3.ScriptTarget.ES2020,
       true,
-      ts2.ScriptKind.TS
+      ts3.ScriptKind.TS
     );
     let samplePropsNode = null;
-    ts2.forEachChild(sourceFile, (node) => {
-      if (ts2.isVariableStatement(node)) {
-        const isExported = node.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+    ts3.forEachChild(sourceFile, (node) => {
+      if (ts3.isVariableStatement(node)) {
+        const isExported = node.modifiers?.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword);
         if (isExported) {
           for (const decl of node.declarationList.declarations) {
-            if (ts2.isIdentifier(decl.name) && decl.name.text === "sampleProps" && decl.initializer) {
-              if (ts2.isObjectLiteralExpression(decl.initializer)) {
+            if (ts3.isIdentifier(decl.name) && decl.name.text === "sampleProps" && decl.initializer) {
+              if (ts3.isObjectLiteralExpression(decl.initializer)) {
                 samplePropsNode = decl.initializer;
               }
             }
@@ -507,13 +942,13 @@ function extractSampleProps(dir) {
     const result = {};
     const propsNode = samplePropsNode;
     for (const prop of propsNode.properties) {
-      if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
+      if (ts3.isPropertyAssignment(prop) && ts3.isIdentifier(prop.name)) {
         const propName = prop.name.text;
-        if (propName === "props" && ts2.isObjectLiteralExpression(prop.initializer)) {
+        if (propName === "props" && ts3.isObjectLiteralExpression(prop.initializer)) {
           result.props = extractObjectLiteral(prop.initializer, content);
         } else if (propName === "children") {
           result.children = prop.initializer.getText(sourceFile);
-        } else if (propName === "state" && ts2.isObjectLiteralExpression(prop.initializer)) {
+        } else if (propName === "state" && ts3.isObjectLiteralExpression(prop.initializer)) {
           result.state = extractObjectLiteral(prop.initializer, content);
         }
       }
@@ -527,20 +962,20 @@ function extractSampleProps(dir) {
 function extractObjectLiteral(node, sourceContent) {
   const result = {};
   for (const prop of node.properties) {
-    if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
+    if (ts3.isPropertyAssignment(prop) && ts3.isIdentifier(prop.name)) {
       const key = prop.name.text;
       const init = prop.initializer;
-      if (ts2.isStringLiteral(init)) {
+      if (ts3.isStringLiteral(init)) {
         result[key] = init.text;
-      } else if (ts2.isNumericLiteral(init)) {
+      } else if (ts3.isNumericLiteral(init)) {
         result[key] = Number(init.text);
-      } else if (init.kind === ts2.SyntaxKind.TrueKeyword) {
+      } else if (init.kind === ts3.SyntaxKind.TrueKeyword) {
         result[key] = true;
-      } else if (init.kind === ts2.SyntaxKind.FalseKeyword) {
+      } else if (init.kind === ts3.SyntaxKind.FalseKeyword) {
         result[key] = false;
-      } else if (ts2.isArrayLiteralExpression(init)) {
+      } else if (ts3.isArrayLiteralExpression(init)) {
         result[key] = extractArrayLiteral(init, sourceContent);
-      } else if (ts2.isObjectLiteralExpression(init)) {
+      } else if (ts3.isObjectLiteralExpression(init)) {
         result[key] = extractObjectLiteral(init, sourceContent);
       } else {
         result[key] = init.getText();
@@ -552,17 +987,17 @@ function extractObjectLiteral(node, sourceContent) {
 function extractArrayLiteral(node, sourceContent) {
   const result = [];
   for (const element of node.elements) {
-    if (ts2.isStringLiteral(element)) {
+    if (ts3.isStringLiteral(element)) {
       result.push(element.text);
-    } else if (ts2.isNumericLiteral(element)) {
+    } else if (ts3.isNumericLiteral(element)) {
       result.push(Number(element.text));
-    } else if (element.kind === ts2.SyntaxKind.TrueKeyword) {
+    } else if (element.kind === ts3.SyntaxKind.TrueKeyword) {
       result.push(true);
-    } else if (element.kind === ts2.SyntaxKind.FalseKeyword) {
+    } else if (element.kind === ts3.SyntaxKind.FalseKeyword) {
       result.push(false);
-    } else if (ts2.isObjectLiteralExpression(element)) {
+    } else if (ts3.isObjectLiteralExpression(element)) {
       result.push(extractObjectLiteral(element, sourceContent));
-    } else if (ts2.isArrayLiteralExpression(element)) {
+    } else if (ts3.isArrayLiteralExpression(element)) {
       result.push(extractArrayLiteral(element, sourceContent));
     } else {
       result.push(element.getText());
@@ -577,8 +1012,8 @@ function analyzeProperty(symbol, typeChecker, themeValues) {
   const declaration = declarations[0];
   const type = typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
   const typeString = typeChecker.typeToString(type);
-  const description = ts2.displayPartsToString(symbol.getDocumentationComment(typeChecker)) || void 0;
-  const required = !(symbol.flags & ts2.SymbolFlags.Optional);
+  const description = ts3.displayPartsToString(symbol.getDocumentationComment(typeChecker)) || void 0;
+  const required = !(symbol.flags & ts3.SymbolFlags.Optional);
   const values = extractPropValues(type, typeString, typeChecker, themeValues);
   const defaultValue = extractDefaultValue(symbol);
   return {
@@ -619,7 +1054,7 @@ function extractDefaultValue(symbol) {
   const tags = symbol.getJsDocTags();
   for (const tag of tags) {
     if (tag.name === "default" && tag.text) {
-      const value = ts2.displayPartsToString(tag.text);
+      const value = ts3.displayPartsToString(tag.text);
       try {
         return JSON.parse(value);
       } catch {
@@ -724,7 +1159,9 @@ function inferCategory(componentName) {
 0 && (module.exports = {
   analyzeComponents,
   analyzeTheme,
+  analyzeThemeSource,
   loadThemeKeys,
-  resetThemeCache
+  resetThemeCache,
+  toBabelThemeKeys
 });
 //# sourceMappingURL=index.cjs.map