@idealyst/tooling 1.2.23 → 1.2.25

package/dist/analyzer/index.js

@@ -0,0 +1,687 @@
+// src/analyzer/component-analyzer.ts
+import * as ts2 from "typescript";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/analyzer/theme-analyzer.ts
+import * as ts from "typescript";
+import * as fs from "fs";
+import * as path from "path";
+function analyzeTheme(themePath, verbose = false) {
+  const resolvedPath = path.resolve(themePath);
+  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], {
+    target: ts.ScriptTarget.ES2020,
+    module: ts.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();
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isImportDeclaration(node)) {
+      const source = node.moduleSpecifier.text;
+      const clause = node.importClause;
+      if (clause?.namedBindings && ts.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 (!ts.isCallExpression(node)) return;
+    if (ts.isPropertyAccessExpression(node.expression)) {
+      const methodName = node.expression.name.text;
+      if (methodName === "build") {
+        const calls = traceBuilderCalls(node);
+        processCalls(calls);
+        return;
+      }
+    }
+    ts.forEachChild(node, processBuilderChain);
+  }
+  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)) {
+            analyzeBaseTheme(arg.text, imports, values, ctx);
+          }
+        }
+      }
+      return calls;
+    }
+    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;
+  }
+  function processCalls(calls) {
+    log("Processing", calls.length, "builder method calls");
+    for (const { method, args } of calls) {
+      switch (method) {
+        case "addIntent": {
+          const name = getStringValue(args[0]);
+          if (name && !values.intents.includes(name)) {
+            values.intents.push(name);
+            log("  Found intent:", name);
+          }
+          break;
+        }
+        case "addRadius": {
+          const name = getStringValue(args[0]);
+          if (name && !values.radii.includes(name)) {
+            values.radii.push(name);
+            log("  Found radius:", name);
+          }
+          break;
+        }
+        case "addShadow": {
+          const name = getStringValue(args[0]);
+          if (name && !values.shadows.includes(name)) {
+            values.shadows.push(name);
+            log("  Found shadow:", name);
+          }
+          break;
+        }
+        case "setSizes": {
+          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            for (const prop of args[0].properties) {
+              if (ts.isPropertyAssignment(prop)) {
+                const componentName = getPropertyName(prop.name);
+                if (componentName && ts.isObjectLiteralExpression(prop.initializer)) {
+                  values.sizes[componentName] = getObjectKeys(prop.initializer);
+                  log("  Found sizes for", componentName + ":", values.sizes[componentName]);
+                }
+              }
+            }
+          }
+          break;
+        }
+        case "setBreakpoints": {
+          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            values.breakpoints = getObjectKeys(args[0]);
+            log("  Found breakpoints:", values.breakpoints);
+          }
+          break;
+        }
+        case "setColors": {
+          if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            for (const prop of args[0].properties) {
+              if (ts.isPropertyAssignment(prop)) {
+                const colorType = getPropertyName(prop.name);
+                if (ts.isObjectLiteralExpression(prop.initializer)) {
+                  const keys = getObjectKeys(prop.initializer);
+                  switch (colorType) {
+                    case "surface":
+                      values.surfaceColors = keys;
+                      log("  Found surface colors:", keys);
+                      break;
+                    case "text":
+                      values.textColors = keys;
+                      log("  Found text colors:", keys);
+                      break;
+                    case "border":
+                      values.borderColors = keys;
+                      log("  Found border colors:", keys);
+                      break;
+                  }
+                }
+              }
+            }
+          }
+          break;
+        }
+        case "build":
+          break;
+        default:
+          log("  Skipping unknown method:", method);
+      }
+    }
+  }
+  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);
+    }
+  });
+  if (values.sizes["typography"]) {
+    values.typography = values.sizes["typography"];
+  }
+  log("Extracted theme values:", values);
+  return values;
+}
+function analyzeBaseTheme(varName, imports, values, ctx) {
+  const log = (...args) => {
+    if (ctx.verbose) console.log("[theme-analyzer]", ...args);
+  };
+  const importInfo = imports.get(varName);
+  if (!importInfo) {
+    log("Could not find import for base theme:", varName);
+    return;
+  }
+  log("Base theme", varName, "imported from", importInfo.source);
+  if (importInfo.source === "@idealyst/theme" || importInfo.source.includes("@idealyst/theme")) {
+    const defaultValues = getDefaultThemeValues();
+    mergeThemeValues(values, defaultValues);
+    log("Using default @idealyst/theme values");
+    return;
+  }
+  log("Skipping base theme analysis for:", importInfo.source);
+}
+function getDefaultThemeValues() {
+  return {
+    intents: ["primary", "success", "error", "warning", "neutral", "info"],
+    sizes: {
+      button: ["xs", "sm", "md", "lg", "xl"],
+      chip: ["xs", "sm", "md", "lg", "xl"],
+      badge: ["xs", "sm", "md", "lg", "xl"],
+      icon: ["xs", "sm", "md", "lg", "xl"],
+      input: ["xs", "sm", "md", "lg", "xl"],
+      radioButton: ["xs", "sm", "md", "lg", "xl"],
+      select: ["xs", "sm", "md", "lg", "xl"],
+      slider: ["xs", "sm", "md", "lg", "xl"],
+      switch: ["xs", "sm", "md", "lg", "xl"],
+      textarea: ["xs", "sm", "md", "lg", "xl"],
+      avatar: ["xs", "sm", "md", "lg", "xl"],
+      progress: ["xs", "sm", "md", "lg", "xl"],
+      accordion: ["xs", "sm", "md", "lg", "xl"],
+      activityIndicator: ["xs", "sm", "md", "lg", "xl"],
+      breadcrumb: ["xs", "sm", "md", "lg", "xl"],
+      list: ["xs", "sm", "md", "lg", "xl"],
+      menu: ["xs", "sm", "md", "lg", "xl"],
+      text: ["xs", "sm", "md", "lg", "xl"],
+      tabBar: ["xs", "sm", "md", "lg", "xl"],
+      table: ["xs", "sm", "md", "lg", "xl"],
+      tooltip: ["xs", "sm", "md", "lg", "xl"],
+      view: ["xs", "sm", "md", "lg", "xl"]
+    },
+    radii: ["none", "xs", "sm", "md", "lg", "xl"],
+    shadows: ["none", "sm", "md", "lg", "xl"],
+    breakpoints: ["xs", "sm", "md", "lg", "xl"],
+    typography: ["h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "caption"],
+    surfaceColors: ["screen", "primary", "secondary", "tertiary", "inverse", "inverse-secondary", "inverse-tertiary"],
+    textColors: ["primary", "secondary", "tertiary", "inverse", "inverse-secondary", "inverse-tertiary"],
+    borderColors: ["primary", "secondary", "tertiary", "disabled"]
+  };
+}
+function mergeThemeValues(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)));
+  target.breakpoints.push(...source.breakpoints.filter((k) => !target.breakpoints.includes(k)));
+  target.typography.push(...source.typography.filter((k) => !target.typography.includes(k)));
+  target.surfaceColors.push(...source.surfaceColors.filter((k) => !target.surfaceColors.includes(k)));
+  target.textColors.push(...source.textColors.filter((k) => !target.textColors.includes(k)));
+  target.borderColors.push(...source.borderColors.filter((k) => !target.borderColors.includes(k)));
+  for (const [comp, sizes] of Object.entries(source.sizes)) {
+    if (!target.sizes[comp]) {
+      target.sizes[comp] = sizes;
+    }
+  }
+}
+function getStringValue(node) {
+  if (!node) return null;
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isIdentifier(node)) return node.text;
+  return null;
+}
+function getPropertyName(node) {
+  if (ts.isIdentifier(node)) return node.text;
+  if (ts.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);
+}
+var themeKeysCache = null;
+var themeLoadAttempted = false;
+function loadThemeKeys(opts, rootDir, _babelTypes, verboseMode = false) {
+  if (themeLoadAttempted && themeKeysCache) {
+    return themeKeysCache;
+  }
+  themeLoadAttempted = true;
+  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;
+  if (verboseMode) {
+    console.log("[idealyst-plugin] Analyzing theme file via @idealyst/tooling:", resolvedPath);
+  }
+  const themeValues = analyzeTheme(resolvedPath, verboseMode);
+  themeKeysCache = {
+    intents: themeValues.intents,
+    sizes: themeValues.sizes,
+    radii: themeValues.radii,
+    shadows: themeValues.shadows
+  };
+  if (verboseMode) {
+    console.log("[idealyst-plugin] Extracted theme keys:");
+    console.log("  intents:", themeKeysCache.intents);
+    console.log("  radii:", themeKeysCache.radii);
+    console.log("  shadows:", themeKeysCache.shadows);
+    console.log("  sizes:");
+    for (const [component, sizes] of Object.entries(themeKeysCache.sizes)) {
+      console.log(`    ${component}:`, sizes);
+    }
+  }
+  return themeKeysCache;
+}
+function resetThemeCache() {
+  themeKeysCache = null;
+  themeLoadAttempted = false;
+}
+
+// src/analyzer/component-analyzer.ts
+function analyzeComponents(options) {
+  const { componentPaths, themePath, include, exclude, includeInternal = false } = options;
+  const registry = {};
+  const themeValues = analyzeTheme(themePath, false);
+  for (const componentPath of componentPaths) {
+    const resolvedPath = path2.resolve(componentPath);
+    if (!fs2.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);
+      if (include && !include.includes(componentName)) continue;
+      if (exclude && exclude.includes(componentName)) continue;
+      if (!includeInternal && componentName.startsWith("_")) continue;
+      const definition = analyzeComponentDir(dir, componentName, themeValues);
+      if (definition) {
+        registry[componentName] = definition;
+      }
+    }
+  }
+  return registry;
+}
+function findComponentDirs(basePath) {
+  const dirs = [];
+  const entries = fs2.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"));
+    if (hasIndex || hasTypes) {
+      dirs.push(dirPath);
+    }
+  }
+  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));
+  if (tsFiles.length === 0) {
+    return null;
+  }
+  const program = ts2.createProgram(tsFiles, {
+    target: ts2.ScriptTarget.ES2020,
+    module: ts2.ModuleKind.ESNext,
+    jsx: ts2.JsxEmit.React,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true
+  });
+  const typeChecker = program.getTypeChecker();
+  const propsInterfaceName = `${componentName}Props`;
+  const altNames = [`${componentName}ComponentProps`, "Props"];
+  let propsInterface = null;
+  let interfaceDescription;
+  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) {
+        propsInterface = node;
+        interfaceDescription = getJSDocDescription(node);
+      }
+      if (ts2.isTypeAliasDeclaration(node) && node.name.text === propsInterfaceName) {
+        propsInterface = node;
+        interfaceDescription = getJSDocDescription(node);
+      }
+    });
+    if (propsInterface) break;
+  }
+  if (!propsInterface) {
+    for (const altName of altNames) {
+      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) {
+            propsInterface = node;
+            interfaceDescription = getJSDocDescription(node);
+          }
+        });
+        if (propsInterface) break;
+      }
+      if (propsInterface) break;
+    }
+  }
+  if (!propsInterface) {
+    return null;
+  }
+  const props = {};
+  if (propsInterface) {
+    const type = typeChecker.getTypeAtLocation(propsInterface);
+    const properties = type.getProperties();
+    for (const prop of properties) {
+      const propDef = analyzeProperty(prop, typeChecker, themeValues);
+      if (propDef && !isInternalProp(propDef.name)) {
+        props[propDef.name] = propDef;
+      }
+    }
+  }
+  const description = interfaceDescription;
+  const category = inferCategory(componentName);
+  const sampleProps = extractSampleProps(dir);
+  return {
+    name: componentName,
+    description,
+    props,
+    category,
+    filePath: path2.relative(process.cwd(), dir),
+    sampleProps
+  };
+}
+function extractSampleProps(dir) {
+  const docsPath = path2.join(dir, "docs.ts");
+  if (!fs2.existsSync(docsPath)) {
+    return void 0;
+  }
+  try {
+    const content = fs2.readFileSync(docsPath, "utf-8");
+    const sourceFile = ts2.createSourceFile(
+      "docs.ts",
+      content,
+      ts2.ScriptTarget.ES2020,
+      true,
+      ts2.ScriptKind.TS
+    );
+    let samplePropsNode = null;
+    ts2.forEachChild(sourceFile, (node) => {
+      if (ts2.isVariableStatement(node)) {
+        const isExported = node.modifiers?.some((m) => m.kind === ts2.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)) {
+                samplePropsNode = decl.initializer;
+              }
+            }
+          }
+        }
+      }
+    });
+    if (!samplePropsNode) {
+      return void 0;
+    }
+    const result = {};
+    const propsNode = samplePropsNode;
+    for (const prop of propsNode.properties) {
+      if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
+        const propName = prop.name.text;
+        if (propName === "props" && ts2.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)) {
+          result.state = extractObjectLiteral(prop.initializer, content);
+        }
+      }
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  } catch (e) {
+    console.warn(`[component-analyzer] Error reading docs.ts in ${dir}:`, e);
+    return void 0;
+  }
+}
+function extractObjectLiteral(node, sourceContent) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
+      const key = prop.name.text;
+      const init = prop.initializer;
+      if (ts2.isStringLiteral(init)) {
+        result[key] = init.text;
+      } else if (ts2.isNumericLiteral(init)) {
+        result[key] = Number(init.text);
+      } else if (init.kind === ts2.SyntaxKind.TrueKeyword) {
+        result[key] = true;
+      } else if (init.kind === ts2.SyntaxKind.FalseKeyword) {
+        result[key] = false;
+      } else if (ts2.isArrayLiteralExpression(init)) {
+        result[key] = extractArrayLiteral(init, sourceContent);
+      } else if (ts2.isObjectLiteralExpression(init)) {
+        result[key] = extractObjectLiteral(init, sourceContent);
+      } else {
+        result[key] = init.getText();
+      }
+    }
+  }
+  return result;
+}
+function extractArrayLiteral(node, sourceContent) {
+  const result = [];
+  for (const element of node.elements) {
+    if (ts2.isStringLiteral(element)) {
+      result.push(element.text);
+    } else if (ts2.isNumericLiteral(element)) {
+      result.push(Number(element.text));
+    } else if (element.kind === ts2.SyntaxKind.TrueKeyword) {
+      result.push(true);
+    } else if (element.kind === ts2.SyntaxKind.FalseKeyword) {
+      result.push(false);
+    } else if (ts2.isObjectLiteralExpression(element)) {
+      result.push(extractObjectLiteral(element, sourceContent));
+    } else if (ts2.isArrayLiteralExpression(element)) {
+      result.push(extractArrayLiteral(element, sourceContent));
+    } else {
+      result.push(element.getText());
+    }
+  }
+  return result;
+}
+function analyzeProperty(symbol, typeChecker, themeValues) {
+  const name = symbol.getName();
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return null;
+  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 values = extractPropValues(type, typeString, typeChecker, themeValues);
+  const defaultValue = extractDefaultValue(symbol);
+  return {
+    name,
+    type: simplifyTypeName(typeString),
+    values: values.length > 0 ? values : void 0,
+    default: defaultValue,
+    description,
+    required
+  };
+}
+function extractPropValues(type, typeString, _typeChecker, themeValues) {
+  if (typeString === "Intent" || typeString.includes("Intent")) {
+    return themeValues.intents;
+  }
+  if (typeString === "Size" || typeString.includes("Size")) {
+    return ["xs", "sm", "md", "lg", "xl"];
+  }
+  if (type.isUnion()) {
+    const values = [];
+    for (const unionType of type.types) {
+      if (unionType.isStringLiteral()) {
+        values.push(unionType.value);
+      } else if (unionType.intrinsicName === "true") {
+        values.push("true");
+      } else if (unionType.intrinsicName === "false") {
+        values.push("false");
+      }
+    }
+    if (values.length > 0) return values;
+  }
+  if (typeString === "boolean") {
+    return ["true", "false"];
+  }
+  return [];
+}
+function extractDefaultValue(symbol) {
+  const tags = symbol.getJsDocTags();
+  for (const tag of tags) {
+    if (tag.name === "default" && tag.text) {
+      const value = ts2.displayPartsToString(tag.text);
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+function getJSDocDescription(node) {
+  const jsDocs = node.jsDoc;
+  if (!jsDocs || jsDocs.length === 0) return void 0;
+  const firstDoc = jsDocs[0];
+  if (firstDoc.comment) {
+    if (typeof firstDoc.comment === "string") {
+      return firstDoc.comment;
+    }
+    return firstDoc.comment.map((c) => c.text || "").join("");
+  }
+  return void 0;
+}
+function simplifyTypeName(typeString) {
+  typeString = typeString.replace(/import\([^)]+\)\./g, "");
+  if (typeString.includes("ReactNode")) return "ReactNode";
+  if (typeString.includes("StyleProp")) return "Style";
+  return typeString;
+}
+function isInternalProp(name) {
+  const internalProps = [
+    "ref",
+    "key",
+    "children",
+    "style",
+    "testID",
+    "nativeID",
+    "accessible",
+    "accessibilityActions",
+    "accessibilityComponentType",
+    "accessibilityElementsHidden",
+    "accessibilityHint",
+    "accessibilityIgnoresInvertColors",
+    "accessibilityLabel",
+    "accessibilityLabelledBy",
+    "accessibilityLanguage",
+    "accessibilityLiveRegion",
+    "accessibilityRole",
+    "accessibilityState",
+    "accessibilityTraits",
+    "accessibilityValue",
+    "accessibilityViewIsModal",
+    "collapsable",
+    "focusable",
+    "hasTVPreferredFocus",
+    "hitSlop",
+    "importantForAccessibility",
+    "needsOffscreenAlphaCompositing",
+    "onAccessibilityAction",
+    "onAccessibilityEscape",
+    "onAccessibilityTap",
+    "onLayout",
+    "onMagicTap",
+    "onMoveShouldSetResponder",
+    "onMoveShouldSetResponderCapture",
+    "onResponderEnd",
+    "onResponderGrant",
+    "onResponderMove",
+    "onResponderReject",
+    "onResponderRelease",
+    "onResponderStart",
+    "onResponderTerminate",
+    "onResponderTerminationRequest",
+    "onStartShouldSetResponder",
+    "onStartShouldSetResponderCapture",
+    "pointerEvents",
+    "removeClippedSubviews",
+    "renderToHardwareTextureAndroid",
+    "shouldRasterizeIOS",
+    "tvParallaxMagnification",
+    "tvParallaxProperties",
+    "tvParallaxShiftDistanceX",
+    "tvParallaxShiftDistanceY",
+    "tvParallaxTiltAngle"
+  ];
+  return internalProps.includes(name) || name.startsWith("accessibility");
+}
+function inferCategory(componentName) {
+  const formComponents = ["Button", "Input", "Checkbox", "Select", "Switch", "RadioButton", "Slider", "TextArea"];
+  const displayComponents = ["Text", "Card", "Badge", "Chip", "Avatar", "Icon", "Skeleton", "Alert", "Tooltip"];
+  const layoutComponents = ["View", "Screen", "Divider"];
+  const navigationComponents = ["TabBar", "Breadcrumb", "Menu", "List", "Link"];
+  const overlayComponents = ["Dialog", "Popover", "Modal"];
+  const dataComponents = ["Table", "Progress", "Accordion"];
+  if (formComponents.includes(componentName)) return "form";
+  if (displayComponents.includes(componentName)) return "display";
+  if (layoutComponents.includes(componentName)) return "layout";
+  if (navigationComponents.includes(componentName)) return "navigation";
+  if (overlayComponents.includes(componentName)) return "overlay";
+  if (dataComponents.includes(componentName)) return "data";
+  return "display";
+}
+export {
+  analyzeComponents,
+  analyzeTheme,
+  loadThemeKeys,
+  resetThemeCache
+};
+//# sourceMappingURL=index.js.map