@idealyst/tooling 1.2.25 → 1.2.27

package/dist/index.cjs

@@ -0,0 +1,2146 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  HTML_ELEMENT_NAMES: () => HTML_ELEMENT_NAMES,
+  HTML_INTRINSIC_ELEMENTS: () => HTML_INTRINSIC_ELEMENTS,
+  REACT_DOM_PRIMITIVES: () => REACT_DOM_PRIMITIVES,
+  REACT_DOM_PRIMITIVE_NAMES: () => REACT_DOM_PRIMITIVE_NAMES,
+  REACT_DOM_RULE_SET: () => REACT_DOM_RULE_SET,
+  REACT_DOM_SOURCES: () => REACT_DOM_SOURCES,
+  REACT_NATIVE_PRIMITIVES: () => REACT_NATIVE_PRIMITIVES,
+  REACT_NATIVE_PRIMITIVE_NAMES: () => REACT_NATIVE_PRIMITIVE_NAMES,
+  REACT_NATIVE_RULE_SET: () => REACT_NATIVE_RULE_SET,
+  REACT_NATIVE_SOURCES: () => REACT_NATIVE_SOURCES,
+  analyzeComponents: () => analyzeComponents,
+  analyzeFiles: () => analyzeFiles,
+  analyzePlatformImports: () => analyzePlatformImports,
+  analyzeTheme: () => analyzeTheme,
+  classifyFile: () => classifyFile,
+  componentNames: () => componentNames,
+  componentRegistry: () => componentRegistry,
+  filterPlatformImports: () => filterPlatformImports,
+  formatLintIssue: () => formatLintIssue,
+  formatLintResults: () => formatLintResults,
+  formatViolation: () => formatViolation,
+  formatViolations: () => formatViolations,
+  generateComponentRegistry: () => generateComponentRegistry,
+  getBaseName: () => getBaseName,
+  getComponentsByCategory: () => getComponentsByCategory,
+  getExpectedPlatform: () => getExpectedPlatform,
+  getPlatformForSource: () => getPlatformForSource,
+  getPropConfig: () => getPropConfig,
+  getReactDomPrimitive: () => getReactDomPrimitive,
+  getReactNativePrimitive: () => getReactNativePrimitive,
+  getUniqueSources: () => getUniqueSources,
+  groupImportsBySource: () => groupImportsBySource,
+  idealystDocsPlugin: () => idealystDocsPlugin,
+  isComponentFile: () => isComponentFile,
+  isHtmlElement: () => isHtmlElement,
+  isPlatformSpecificFile: () => isPlatformSpecificFile,
+  isReactDomPrimitive: () => isReactDomPrimitive,
+  isReactNativePrimitive: () => isReactNativePrimitive,
+  isSharedFile: () => isSharedFile,
+  lintComponent: () => lintComponent,
+  lintComponents: () => lintComponents,
+  loadThemeKeys: () => loadThemeKeys,
+  parseImports: () => parseImports,
+  resetThemeCache: () => resetThemeCache,
+  summarizeLintResults: () => summarizeLintResults,
+  summarizeResults: () => summarizeResults
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/analyzer/component-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
+var ts = __toESM(require("typescript"), 1);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+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"],
+      // Typography sizes for Text component's $typography iterator
+      typography: ["h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "caption"]
+    },
+    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,
+    typography: themeValues.typography
+  };
+  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";
+}
+
+// src/vite-plugin.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+function idealystDocsPlugin(options) {
+  let registry = null;
+  const { debug = false, output, outputPath } = options;
+  const log = (...args) => {
+    if (debug) console.log("[idealyst-docs]", ...args);
+  };
+  function generateRegistry() {
+    log("Generating component registry...");
+    log("Component paths:", options.componentPaths);
+    log("Theme path:", options.themePath);
+    try {
+      registry = analyzeComponents(options);
+      log(`Generated registry with ${Object.keys(registry).length} components`);
+      if (debug) {
+        log("Components found:", Object.keys(registry));
+      }
+      if (output === "file" && outputPath) {
+        const outputDir = path3.dirname(outputPath);
+        if (!fs3.existsSync(outputDir)) {
+          fs3.mkdirSync(outputDir, { recursive: true });
+        }
+        fs3.writeFileSync(
+          outputPath,
+          `// Auto-generated by @idealyst/tooling - DO NOT EDIT
+export const componentRegistry = ${JSON.stringify(registry, null, 2)} as const;
+`
+        );
+        log(`Wrote registry to ${outputPath}`);
+      }
+      return registry;
+    } catch (error) {
+      console.error("[idealyst-docs] Error generating registry:", error);
+      return {};
+    }
+  }
+  return {
+    name: "idealyst-docs",
+    // Transform @idealyst/tooling to inject the actual registry
+    transform(code, id) {
+      const isToolingIndex = id.includes("@idealyst/tooling") && id.endsWith("index.ts");
+      const isToolingSrc = id.includes("/packages/tooling/src/index.ts");
+      if (isToolingIndex || isToolingSrc) {
+        console.log(`[idealyst-docs] Transforming tooling index: ${id}`);
+        if (!registry) {
+          registry = generateRegistry();
+        }
+        let transformed = code;
+        transformed = transformed.replace(
+          /export const componentRegistry\s*=\s*\{\s*\};?/,
+          `export const componentRegistry = ${JSON.stringify(registry, null, 2)};`
+        );
+        log(`Code transformed: ${code !== transformed}`);
+        transformed = transformed.replace(
+          /export const componentNames\s*=\s*\[\s*\];?/,
+          `export const componentNames = ${JSON.stringify(Object.keys(registry))};`
+        );
+        transformed = transformed.replace(
+          /export function getComponentsByCategory\(category\)\s*\{[\s\S]*?^\}/m,
+          `export function getComponentsByCategory(category) {
+  return Object.entries(componentRegistry)
+    .filter(([_, def]) => def.category === category)
+    .map(([name]) => name);
+}`
+        );
+        transformed = transformed.replace(
+          /export function getPropConfig\(componentName\)\s*\{[\s\S]*?^\}/m,
+          `export function getPropConfig(componentName) {
+  const def = componentRegistry[componentName];
+  if (!def) return {};
+  return Object.entries(def.props).reduce((acc, [key, prop]) => {
+    if (prop.values && prop.values.length > 0) {
+      acc[key] = { type: 'select', options: prop.values, default: prop.default };
+    } else if (prop.type === 'boolean') {
+      acc[key] = { type: 'boolean', default: prop.default ?? false };
+    } else if (prop.type === 'string') {
+      acc[key] = { type: 'text', default: prop.default ?? '' };
+    } else if (prop.type === 'number') {
+      acc[key] = { type: 'number', default: prop.default ?? 0 };
+    }
+    return acc;
+  }, {});
+}`
+        );
+        return {
+          code: transformed,
+          map: null
+        };
+      }
+      return null;
+    },
+    // Regenerate on component file changes
+    handleHotUpdate({ file, server }) {
+      const isComponentFile2 = options.componentPaths.some((p) => file.includes(path3.resolve(p))) && (file.endsWith(".ts") || file.endsWith(".tsx"));
+      const isThemeFile = file.includes(path3.resolve(options.themePath));
+      if (isComponentFile2 || isThemeFile) {
+        log(`File changed: ${file}, regenerating registry...`);
+        registry = null;
+        const toolingMods = Array.from(server.moduleGraph.idToModuleMap.values()).filter((m) => m.id && (m.id.includes("@idealyst/tooling") || m.id.includes("/packages/tooling/src/index")));
+        toolingMods.forEach((m) => server.moduleGraph.invalidateModule(m));
+        if (toolingMods.length > 0) {
+          return toolingMods;
+        }
+      }
+    },
+    // Generate on build
+    buildStart() {
+      registry = generateRegistry();
+    }
+  };
+}
+function generateComponentRegistry(options) {
+  return analyzeComponents(options);
+}
+
+// src/utils/fileClassifier.ts
+var path4 = __toESM(require("path"), 1);
+var EXTENSION_PATTERNS = [
+  // Platform-specific component files
+  { pattern: /\.web\.(tsx|jsx)$/, type: "web" },
+  { pattern: /\.native\.(tsx|jsx)$/, type: "native" },
+  { pattern: /\.ios\.(tsx|jsx)$/, type: "native" },
+  { pattern: /\.android\.(tsx|jsx)$/, type: "native" },
+  // Style files (can be .ts or .tsx)
+  { pattern: /\.styles?\.(tsx?|jsx?)$/, type: "styles" },
+  // Type definition files
+  { pattern: /\.types?\.(ts|tsx)$/, type: "types" },
+  { pattern: /types\.(ts|tsx)$/, type: "types" },
+  { pattern: /\.d\.ts$/, type: "types" },
+  // Shared component files (generic .tsx/.jsx without platform suffix)
+  { pattern: /\.(tsx|jsx)$/, type: "shared" }
+];
+var EXCLUDED_PATTERNS = [
+  /\.test\.(tsx?|jsx?)$/,
+  /\.spec\.(tsx?|jsx?)$/,
+  /\.stories\.(tsx?|jsx?)$/,
+  /\.config\.(ts|js)$/,
+  /index\.(ts|tsx|js|jsx)$/
+];
+function classifyFile(filePath) {
+  const fileName = path4.basename(filePath);
+  for (const pattern of EXCLUDED_PATTERNS) {
+    if (pattern.test(fileName)) {
+      return "other";
+    }
+  }
+  for (const { pattern, type } of EXTENSION_PATTERNS) {
+    if (pattern.test(fileName)) {
+      return type;
+    }
+  }
+  return "other";
+}
+function isComponentFile(filePath) {
+  const fileType = classifyFile(filePath);
+  return fileType === "shared" || fileType === "web" || fileType === "native";
+}
+function isSharedFile(filePath) {
+  return classifyFile(filePath) === "shared";
+}
+function isPlatformSpecificFile(filePath) {
+  const fileType = classifyFile(filePath);
+  return fileType === "web" || fileType === "native";
+}
+function getExpectedPlatform(filePath) {
+  const fileType = classifyFile(filePath);
+  if (fileType === "web") return "web";
+  if (fileType === "native") return "native";
+  return null;
+}
+function getBaseName(filePath) {
+  const fileName = path4.basename(filePath);
+  return fileName.replace(/\.(web|native|ios|android)\.(tsx|jsx|ts|js)$/, "").replace(/\.styles?\.(tsx|jsx|ts|js)$/, "").replace(/\.types?\.(tsx|ts)$/, "").replace(/\.(tsx|jsx|ts|js)$/, "");
+}
+
+// src/utils/importParser.ts
+var ts3 = __toESM(require("typescript"), 1);
+
+// src/rules/reactNativePrimitives.ts
+var REACT_NATIVE_SOURCES = [
+  "react-native",
+  "react-native-web",
+  "react-native-gesture-handler",
+  "react-native-reanimated",
+  "react-native-safe-area-context",
+  "react-native-screens",
+  "react-native-svg",
+  "@react-native-vector-icons/material-design-icons",
+  "@react-native-vector-icons/common",
+  "@react-native-community/async-storage",
+  "@react-native-picker/picker",
+  "expo",
+  "expo-constants",
+  "expo-linking",
+  "expo-status-bar"
+];
+var CORE_PRIMITIVES = [
+  {
+    name: "View",
+    source: "react-native",
+    platform: "react-native",
+    description: "Basic container component"
+  },
+  {
+    name: "Text",
+    source: "react-native",
+    platform: "react-native",
+    description: "Text display component"
+  },
+  {
+    name: "Image",
+    source: "react-native",
+    platform: "react-native",
+    description: "Image display component"
+  },
+  {
+    name: "ImageBackground",
+    source: "react-native",
+    platform: "react-native",
+    description: "Background image container"
+  },
+  {
+    name: "ScrollView",
+    source: "react-native",
+    platform: "react-native",
+    description: "Scrollable container"
+  },
+  {
+    name: "FlatList",
+    source: "react-native",
+    platform: "react-native",
+    description: "Performant list component"
+  },
+  {
+    name: "SectionList",
+    source: "react-native",
+    platform: "react-native",
+    description: "Sectioned list component"
+  },
+  {
+    name: "VirtualizedList",
+    source: "react-native",
+    platform: "react-native",
+    description: "Base virtualized list"
+  }
+];
+var INTERACTIVE_PRIMITIVES = [
+  {
+    name: "TouchableOpacity",
+    source: "react-native",
+    platform: "react-native",
+    description: "Touch with opacity feedback"
+  },
+  {
+    name: "TouchableHighlight",
+    source: "react-native",
+    platform: "react-native",
+    description: "Touch with highlight feedback"
+  },
+  {
+    name: "TouchableWithoutFeedback",
+    source: "react-native",
+    platform: "react-native",
+    description: "Touch without visual feedback"
+  },
+  {
+    name: "TouchableNativeFeedback",
+    source: "react-native",
+    platform: "react-native",
+    description: "Android ripple feedback"
+  },
+  {
+    name: "Pressable",
+    source: "react-native",
+    platform: "react-native",
+    description: "Modern press handler component"
+  },
+  {
+    name: "Button",
+    source: "react-native",
+    platform: "react-native",
+    description: "Basic button component"
+  }
+];
+var INPUT_PRIMITIVES = [
+  {
+    name: "TextInput",
+    source: "react-native",
+    platform: "react-native",
+    description: "Text input field"
+  },
+  {
+    name: "Switch",
+    source: "react-native",
+    platform: "react-native",
+    description: "Toggle switch component"
+  },
+  {
+    name: "Slider",
+    source: "react-native",
+    platform: "react-native",
+    description: "Slider input (deprecated)"
+  }
+];
+var MODAL_PRIMITIVES = [
+  {
+    name: "Modal",
+    source: "react-native",
+    platform: "react-native",
+    description: "Modal overlay component"
+  },
+  {
+    name: "Alert",
+    source: "react-native",
+    platform: "react-native",
+    description: "Native alert dialog"
+  },
+  {
+    name: "ActionSheetIOS",
+    source: "react-native",
+    platform: "react-native",
+    description: "iOS action sheet"
+  },
+  {
+    name: "StatusBar",
+    source: "react-native",
+    platform: "react-native",
+    description: "Status bar controller"
+  }
+];
+var ANIMATION_PRIMITIVES = [
+  {
+    name: "Animated",
+    source: "react-native",
+    platform: "react-native",
+    description: "Animation library namespace"
+  },
+  {
+    name: "Easing",
+    source: "react-native",
+    platform: "react-native",
+    description: "Easing functions"
+  },
+  {
+    name: "LayoutAnimation",
+    source: "react-native",
+    platform: "react-native",
+    description: "Layout animation controller"
+  }
+];
+var PLATFORM_PRIMITIVES = [
+  {
+    name: "Platform",
+    source: "react-native",
+    platform: "react-native",
+    description: "Platform detection utility"
+  },
+  {
+    name: "Dimensions",
+    source: "react-native",
+    platform: "react-native",
+    description: "Screen dimensions utility"
+  },
+  {
+    name: "PixelRatio",
+    source: "react-native",
+    platform: "react-native",
+    description: "Pixel ratio utility"
+  },
+  {
+    name: "Appearance",
+    source: "react-native",
+    platform: "react-native",
+    description: "Color scheme detection"
+  },
+  {
+    name: "useColorScheme",
+    source: "react-native",
+    platform: "react-native",
+    description: "Color scheme hook"
+  },
+  {
+    name: "useWindowDimensions",
+    source: "react-native",
+    platform: "react-native",
+    description: "Window dimensions hook"
+  }
+];
+var EVENT_PRIMITIVES = [
+  {
+    name: "BackHandler",
+    source: "react-native",
+    platform: "react-native",
+    description: "Android back button handler"
+  },
+  {
+    name: "Keyboard",
+    source: "react-native",
+    platform: "react-native",
+    description: "Keyboard event handler"
+  },
+  {
+    name: "PanResponder",
+    source: "react-native",
+    platform: "react-native",
+    description: "Gesture responder system"
+  },
+  {
+    name: "Linking",
+    source: "react-native",
+    platform: "react-native",
+    description: "Deep linking utility"
+  },
+  {
+    name: "AppState",
+    source: "react-native",
+    platform: "react-native",
+    description: "App lifecycle state"
+  }
+];
+var SAFETY_PRIMITIVES = [
+  {
+    name: "SafeAreaView",
+    source: "react-native",
+    platform: "react-native",
+    description: "Safe area inset container"
+  },
+  {
+    name: "KeyboardAvoidingView",
+    source: "react-native",
+    platform: "react-native",
+    description: "Keyboard avoidance container"
+  }
+];
+var ACCESSIBILITY_PRIMITIVES = [
+  {
+    name: "AccessibilityInfo",
+    source: "react-native",
+    platform: "react-native",
+    description: "Accessibility information API"
+  }
+];
+var STYLE_PRIMITIVES = [
+  {
+    name: "StyleSheet",
+    source: "react-native",
+    platform: "react-native",
+    description: "Style sheet creator"
+  }
+];
+var REACT_NATIVE_PRIMITIVES = [
+  ...CORE_PRIMITIVES,
+  ...INTERACTIVE_PRIMITIVES,
+  ...INPUT_PRIMITIVES,
+  ...MODAL_PRIMITIVES,
+  ...ANIMATION_PRIMITIVES,
+  ...PLATFORM_PRIMITIVES,
+  ...EVENT_PRIMITIVES,
+  ...SAFETY_PRIMITIVES,
+  ...ACCESSIBILITY_PRIMITIVES,
+  ...STYLE_PRIMITIVES
+];
+var REACT_NATIVE_PRIMITIVE_NAMES = new Set(
+  REACT_NATIVE_PRIMITIVES.map((p) => p.name)
+);
+var REACT_NATIVE_RULE_SET = {
+  platform: "react-native",
+  primitives: REACT_NATIVE_PRIMITIVES,
+  sources: [...REACT_NATIVE_SOURCES]
+};
+function isReactNativePrimitive(name) {
+  return REACT_NATIVE_PRIMITIVE_NAMES.has(name);
+}
+function getReactNativePrimitive(name) {
+  return REACT_NATIVE_PRIMITIVES.find((p) => p.name === name);
+}
+
+// src/rules/reactDomPrimitives.ts
+var REACT_DOM_SOURCES = [
+  "react-dom",
+  "react-dom/client",
+  "react-dom/server"
+];
+var DOM_API_PRIMITIVES = [
+  {
+    name: "createPortal",
+    source: "react-dom",
+    platform: "react-dom",
+    description: "Render children into a different DOM node"
+  },
+  {
+    name: "flushSync",
+    source: "react-dom",
+    platform: "react-dom",
+    description: "Force synchronous DOM updates"
+  },
+  {
+    name: "createRoot",
+    source: "react-dom/client",
+    platform: "react-dom",
+    description: "Create a React root for rendering"
+  },
+  {
+    name: "hydrateRoot",
+    source: "react-dom/client",
+    platform: "react-dom",
+    description: "Hydrate server-rendered content"
+  },
+  {
+    name: "render",
+    source: "react-dom",
+    platform: "react-dom",
+    description: "Legacy render function (deprecated)"
+  },
+  {
+    name: "hydrate",
+    source: "react-dom",
+    platform: "react-dom",
+    description: "Legacy hydrate function (deprecated)"
+  },
+  {
+    name: "unmountComponentAtNode",
+    source: "react-dom",
+    platform: "react-dom",
+    description: "Legacy unmount function (deprecated)"
+  },
+  {
+    name: "findDOMNode",
+    source: "react-dom",
+    platform: "react-dom",
+    description: "Find DOM node (deprecated)"
+  }
+];
+var HTML_INTRINSIC_ELEMENTS = [
+  // Document structure
+  "html",
+  "head",
+  "body",
+  "main",
+  "header",
+  "footer",
+  "nav",
+  "aside",
+  "article",
+  "section",
+  // Content sectioning
+  "div",
+  "span",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  // Text content
+  "a",
+  "strong",
+  "em",
+  "code",
+  "pre",
+  "blockquote",
+  "br",
+  "hr",
+  // Lists
+  "ul",
+  "ol",
+  "li",
+  "dl",
+  "dt",
+  "dd",
+  // Tables
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  // Forms
+  "form",
+  "input",
+  "textarea",
+  "select",
+  "option",
+  "optgroup",
+  "button",
+  "label",
+  "fieldset",
+  "legend",
+  "datalist",
+  "output",
+  "progress",
+  "meter",
+  // Media
+  "img",
+  "video",
+  "audio",
+  "source",
+  "track",
+  "picture",
+  "figure",
+  "figcaption",
+  "canvas",
+  "svg",
+  "iframe",
+  "embed",
+  "object",
+  // Interactive
+  "details",
+  "summary",
+  "dialog",
+  "menu",
+  // Scripting
+  "script",
+  "noscript",
+  "template",
+  "slot"
+];
+var REACT_DOM_PRIMITIVES = [...DOM_API_PRIMITIVES];
+var REACT_DOM_PRIMITIVE_NAMES = new Set(
+  REACT_DOM_PRIMITIVES.map((p) => p.name)
+);
+var HTML_ELEMENT_NAMES = new Set(HTML_INTRINSIC_ELEMENTS);
+var REACT_DOM_RULE_SET = {
+  platform: "react-dom",
+  primitives: REACT_DOM_PRIMITIVES,
+  sources: [...REACT_DOM_SOURCES]
+};
+function isReactDomPrimitive(name) {
+  return REACT_DOM_PRIMITIVE_NAMES.has(name);
+}
+function isHtmlElement(name) {
+  return HTML_ELEMENT_NAMES.has(name);
+}
+function getReactDomPrimitive(name) {
+  return REACT_DOM_PRIMITIVES.find((p) => p.name === name);
+}
+
+// src/utils/importParser.ts
+function getPlatformForSource(source, options) {
+  const nativeSources = /* @__PURE__ */ new Set([
+    ...REACT_NATIVE_SOURCES,
+    ...options?.additionalNativeSources ?? []
+  ]);
+  const domSources = /* @__PURE__ */ new Set([
+    ...REACT_DOM_SOURCES,
+    ...options?.additionalDomSources ?? []
+  ]);
+  if (nativeSources.has(source)) return "react-native";
+  if (domSources.has(source)) return "react-dom";
+  if (source.startsWith("react-native")) return "react-native";
+  if (source.startsWith("react-dom")) return "react-dom";
+  return "neutral";
+}
+function parseImports(sourceCode, filePath = "unknown.tsx", options) {
+  const imports = [];
+  const sourceFile = ts3.createSourceFile(
+    filePath,
+    sourceCode,
+    ts3.ScriptTarget.Latest,
+    true,
+    filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
+  );
+  const visit = (node) => {
+    if (ts3.isImportDeclaration(node)) {
+      const importInfo = parseImportDeclaration(node, sourceFile, options);
+      imports.push(...importInfo);
+    }
+    if (ts3.isCallExpression(node) && ts3.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1 && ts3.isStringLiteral(node.arguments[0])) {
+      const source = node.arguments[0].text;
+      const { line, character } = sourceFile.getLineAndCharacterOfPosition(
+        node.getStart()
+      );
+      imports.push({
+        name: "require",
+        source,
+        platform: getPlatformForSource(source, options),
+        line: line + 1,
+        column: character + 1,
+        isDefault: false,
+        isNamespace: true,
+        isTypeOnly: false
+      });
+    }
+    ts3.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return imports;
+}
+function parseImportDeclaration(node, sourceFile, options) {
+  const imports = [];
+  if (!ts3.isStringLiteral(node.moduleSpecifier)) {
+    return imports;
+  }
+  const source = node.moduleSpecifier.text;
+  const platform = getPlatformForSource(source, options);
+  const isTypeOnly = node.importClause?.isTypeOnly ?? false;
+  const importClause = node.importClause;
+  if (!importClause) {
+    return imports;
+  }
+  if (importClause.name) {
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(
+      importClause.name.getStart()
+    );
+    imports.push({
+      name: importClause.name.text,
+      source,
+      platform,
+      line: line + 1,
+      column: character + 1,
+      isDefault: true,
+      isNamespace: false,
+      isTypeOnly
+    });
+  }
+  const namedBindings = importClause.namedBindings;
+  if (namedBindings) {
+    if (ts3.isNamespaceImport(namedBindings)) {
+      const { line, character } = sourceFile.getLineAndCharacterOfPosition(
+        namedBindings.name.getStart()
+      );
+      imports.push({
+        name: namedBindings.name.text,
+        source,
+        platform,
+        line: line + 1,
+        column: character + 1,
+        isDefault: false,
+        isNamespace: true,
+        isTypeOnly
+      });
+    } else if (ts3.isNamedImports(namedBindings)) {
+      for (const element of namedBindings.elements) {
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(
+          element.name.getStart()
+        );
+        const importedName = element.propertyName?.text ?? element.name.text;
+        const localName = element.name.text;
+        imports.push({
+          name: localName,
+          originalName: element.propertyName ? importedName : void 0,
+          source,
+          platform,
+          line: line + 1,
+          column: character + 1,
+          isDefault: false,
+          isNamespace: false,
+          isTypeOnly: isTypeOnly || element.isTypeOnly
+        });
+      }
+    }
+  }
+  return imports;
+}
+function filterPlatformImports(imports, platform) {
+  return imports.filter((imp) => {
+    if (imp.platform === "neutral") return false;
+    if (platform && imp.platform !== platform) return false;
+    return true;
+  });
+}
+function getUniqueSources(imports) {
+  return [...new Set(imports.map((imp) => imp.source))];
+}
+function groupImportsBySource(imports) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    const existing = grouped.get(imp.source) ?? [];
+    existing.push(imp);
+    grouped.set(imp.source, existing);
+  }
+  return grouped;
+}
+
+// src/analyzers/platformImports.ts
+var DEFAULT_OPTIONS = {
+  severity: "error",
+  additionalNativePrimitives: [],
+  additionalDomPrimitives: [],
+  ignoredPrimitives: [],
+  ignoredPatterns: [],
+  additionalNativeSources: [],
+  additionalDomSources: []
+};
+function matchesIgnoredPattern(filePath, patterns) {
+  if (patterns.length === 0) return false;
+  for (const pattern of patterns) {
+    const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(regexPattern);
+    if (regex.test(filePath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createViolation(type, primitive, source, filePath, line, column, severity) {
+  const messages = {
+    "native-in-shared": `React Native primitive '${primitive}' from '${source}' should not be used in shared files. Use a .native.tsx file instead.`,
+    "dom-in-shared": `React DOM primitive '${primitive}' from '${source}' should not be used in shared files. Use a .web.tsx file instead.`,
+    "native-in-web": `React Native primitive '${primitive}' from '${source}' should not be used in web-specific files.`,
+    "dom-in-native": `React DOM primitive '${primitive}' from '${source}' should not be used in native-specific files.`
+  };
+  return {
+    type,
+    primitive,
+    source,
+    filePath,
+    line,
+    column,
+    message: messages[type],
+    severity
+  };
+}
+function isNativePrimitive(importInfo, additionalPrimitives) {
+  const name = importInfo.originalName ?? importInfo.name;
+  if (isReactNativePrimitive(name)) return true;
+  if (additionalPrimitives.includes(name)) return true;
+  const nativeSources = /* @__PURE__ */ new Set([...REACT_NATIVE_SOURCES]);
+  if (nativeSources.has(importInfo.source)) {
+    if (/^[A-Z]/.test(name)) return true;
+  }
+  return false;
+}
+function isDomPrimitive(importInfo, additionalPrimitives) {
+  const name = importInfo.originalName ?? importInfo.name;
+  if (isReactDomPrimitive(name)) return true;
+  if (additionalPrimitives.includes(name)) return true;
+  return false;
+}
+function analyzePlatformImports(filePath, sourceCode, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const fileType = classifyFile(filePath);
+  const violations = [];
+  if (matchesIgnoredPattern(filePath, opts.ignoredPatterns)) {
+    return {
+      filePath,
+      fileType,
+      violations: [],
+      imports: [],
+      passed: true
+    };
+  }
+  if (fileType === "other" || fileType === "styles" || fileType === "types") {
+    return {
+      filePath,
+      fileType,
+      violations: [],
+      imports: [],
+      passed: true
+    };
+  }
+  const imports = parseImports(sourceCode, filePath, {
+    additionalNativeSources: opts.additionalNativeSources,
+    additionalDomSources: opts.additionalDomSources
+  });
+  const ignoredPrimitives = new Set(opts.ignoredPrimitives);
+  for (const imp of imports) {
+    if (imp.isTypeOnly) continue;
+    const primitiveName = imp.originalName ?? imp.name;
+    if (ignoredPrimitives.has(primitiveName)) continue;
+    switch (fileType) {
+      case "shared":
+        if (isNativePrimitive(imp, opts.additionalNativePrimitives)) {
+          violations.push(
+            createViolation(
+              "native-in-shared",
+              primitiveName,
+              imp.source,
+              filePath,
+              imp.line,
+              imp.column,
+              opts.severity
+            )
+          );
+        }
+        if (isDomPrimitive(imp, opts.additionalDomPrimitives)) {
+          violations.push(
+            createViolation(
+              "dom-in-shared",
+              primitiveName,
+              imp.source,
+              filePath,
+              imp.line,
+              imp.column,
+              opts.severity
+            )
+          );
+        }
+        break;
+      case "web":
+        if (isNativePrimitive(imp, opts.additionalNativePrimitives)) {
+          violations.push(
+            createViolation(
+              "native-in-web",
+              primitiveName,
+              imp.source,
+              filePath,
+              imp.line,
+              imp.column,
+              opts.severity
+            )
+          );
+        }
+        break;
+      case "native":
+        if (isDomPrimitive(imp, opts.additionalDomPrimitives)) {
+          violations.push(
+            createViolation(
+              "dom-in-native",
+              primitiveName,
+              imp.source,
+              filePath,
+              imp.line,
+              imp.column,
+              opts.severity
+            )
+          );
+        }
+        break;
+    }
+  }
+  return {
+    filePath,
+    fileType,
+    violations,
+    imports,
+    passed: violations.length === 0
+  };
+}
+function analyzeFiles(files, options) {
+  return files.map(
+    (file) => analyzePlatformImports(file.path, file.content, options)
+  );
+}
+function summarizeResults(results) {
+  const violationsByType = {
+    "native-in-shared": 0,
+    "dom-in-shared": 0,
+    "native-in-web": 0,
+    "dom-in-native": 0
+  };
+  const violationsBySeverity = {
+    error: 0,
+    warning: 0,
+    info: 0
+  };
+  let totalViolations = 0;
+  for (const result of results) {
+    for (const violation of result.violations) {
+      totalViolations++;
+      violationsByType[violation.type]++;
+      violationsBySeverity[violation.severity]++;
+    }
+  }
+  return {
+    totalFiles: results.length,
+    passedFiles: results.filter((r) => r.passed).length,
+    failedFiles: results.filter((r) => !r.passed).length,
+    totalViolations,
+    violationsByType,
+    violationsBySeverity
+  };
+}
+function formatViolation(violation) {
+  const severityPrefix = violation.severity === "error" ? "ERROR" : violation.severity === "warning" ? "WARN" : "INFO";
+  return `${severityPrefix}: ${violation.filePath}:${violation.line}:${violation.column} - ${violation.message}`;
+}
+function formatViolations(results) {
+  const lines = [];
+  for (const result of results) {
+    for (const violation of result.violations) {
+      lines.push(formatViolation(violation));
+    }
+  }
+  return lines;
+}
+
+// src/analyzers/componentLinter.ts
+var CSS_COLOR_NAMES = /* @__PURE__ */ new Set([
+  "aliceblue",
+  "antiquewhite",
+  "aqua",
+  "aquamarine",
+  "azure",
+  "beige",
+  "bisque",
+  "black",
+  "blanchedalmond",
+  "blue",
+  "blueviolet",
+  "brown",
+  "burlywood",
+  "cadetblue",
+  "chartreuse",
+  "chocolate",
+  "coral",
+  "cornflowerblue",
+  "cornsilk",
+  "crimson",
+  "cyan",
+  "darkblue",
+  "darkcyan",
+  "darkgoldenrod",
+  "darkgray",
+  "darkgreen",
+  "darkgrey",
+  "darkkhaki",
+  "darkmagenta",
+  "darkolivegreen",
+  "darkorange",
+  "darkorchid",
+  "darkred",
+  "darksalmon",
+  "darkseagreen",
+  "darkslateblue",
+  "darkslategray",
+  "darkslategrey",
+  "darkturquoise",
+  "darkviolet",
+  "deeppink",
+  "deepskyblue",
+  "dimgray",
+  "dimgrey",
+  "dodgerblue",
+  "firebrick",
+  "floralwhite",
+  "forestgreen",
+  "fuchsia",
+  "gainsboro",
+  "ghostwhite",
+  "gold",
+  "goldenrod",
+  "gray",
+  "green",
+  "greenyellow",
+  "grey",
+  "honeydew",
+  "hotpink",
+  "indianred",
+  "indigo",
+  "ivory",
+  "khaki",
+  "lavender",
+  "lavenderblush",
+  "lawngreen",
+  "lemonchiffon",
+  "lightblue",
+  "lightcoral",
+  "lightcyan",
+  "lightgoldenrodyellow",
+  "lightgray",
+  "lightgreen",
+  "lightgrey",
+  "lightpink",
+  "lightsalmon",
+  "lightseagreen",
+  "lightskyblue",
+  "lightslategray",
+  "lightslategrey",
+  "lightsteelblue",
+  "lightyellow",
+  "lime",
+  "limegreen",
+  "linen",
+  "magenta",
+  "maroon",
+  "mediumaquamarine",
+  "mediumblue",
+  "mediumorchid",
+  "mediumpurple",
+  "mediumseagreen",
+  "mediumslateblue",
+  "mediumspringgreen",
+  "mediumturquoise",
+  "mediumvioletred",
+  "midnightblue",
+  "mintcream",
+  "mistyrose",
+  "moccasin",
+  "navajowhite",
+  "navy",
+  "oldlace",
+  "olive",
+  "olivedrab",
+  "orange",
+  "orangered",
+  "orchid",
+  "palegoldenrod",
+  "palegreen",
+  "paleturquoise",
+  "palevioletred",
+  "papayawhip",
+  "peachpuff",
+  "peru",
+  "pink",
+  "plum",
+  "powderblue",
+  "purple",
+  "rebeccapurple",
+  "red",
+  "rosybrown",
+  "royalblue",
+  "saddlebrown",
+  "salmon",
+  "sandybrown",
+  "seagreen",
+  "seashell",
+  "sienna",
+  "silver",
+  "skyblue",
+  "slateblue",
+  "slategray",
+  "slategrey",
+  "snow",
+  "springgreen",
+  "steelblue",
+  "tan",
+  "teal",
+  "thistle",
+  "tomato",
+  "turquoise",
+  "violet",
+  "wheat",
+  "white",
+  "whitesmoke",
+  "yellow",
+  "yellowgreen"
+]);
+var DEFAULT_ALLOWED_COLORS = /* @__PURE__ */ new Set([
+  "transparent",
+  "inherit",
+  "currentColor",
+  "currentcolor"
+]);
+var COLOR_PROPERTIES = [
+  "color",
+  "backgroundColor",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor",
+  "shadowColor",
+  "textDecorationColor",
+  "tintColor",
+  "overlayColor"
+];
+function isHardcodedColor(value, allowedColors) {
+  const trimmed = value.trim().toLowerCase();
+  if (allowedColors.has(trimmed)) {
+    return false;
+  }
+  if (/^#[0-9a-f]{3,8}$/i.test(trimmed)) {
+    return true;
+  }
+  if (/^rgba?\s*\(/.test(trimmed)) {
+    return true;
+  }
+  if (/^hsla?\s*\(/.test(trimmed)) {
+    return true;
+  }
+  if (CSS_COLOR_NAMES.has(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function getRuleSeverity(rule, defaultSeverity) {
+  if (rule === false) return null;
+  if (rule === true || rule === void 0) return defaultSeverity;
+  return rule;
+}
+function getLineColumn(source, index) {
+  const lines = source.substring(0, index).split("\n");
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1
+  };
+}
+function lintComponent(filePath, sourceCode, options = {}) {
+  const issues = [];
+  const rules = options.rules || {};
+  const allowedColors = /* @__PURE__ */ new Set([
+    ...DEFAULT_ALLOWED_COLORS,
+    ...(options.allowedColors || []).map((c) => c.toLowerCase())
+  ]);
+  const hardcodedColorSeverity = getRuleSeverity(rules.hardcodedColors, "warning");
+  if (hardcodedColorSeverity) {
+    for (const prop of COLOR_PROPERTIES) {
+      const propRegex = new RegExp(`${prop}\\s*:\\s*['"]([^'"]+)['"]`, "g");
+      let match;
+      while ((match = propRegex.exec(sourceCode)) !== null) {
+        const colorValue = match[1];
+        if (isHardcodedColor(colorValue, allowedColors)) {
+          const { line, column } = getLineColumn(sourceCode, match.index);
+          issues.push({
+            type: "hardcoded-color",
+            severity: hardcodedColorSeverity,
+            line,
+            column,
+            code: match[0],
+            message: `Hardcoded color '${colorValue}' in ${prop}. Use theme colors instead.`,
+            suggestion: `Use theme.colors.*, theme.intents[intent].*, or pass color via props`
+          });
+        }
+      }
+    }
+    const templateColorRegex = /(?:color|backgroundColor)\s*:\s*`[^`]*#[0-9a-fA-F]{3,8}[^`]*`/g;
+    let templateMatch;
+    while ((templateMatch = templateColorRegex.exec(sourceCode)) !== null) {
+      const { line, column } = getLineColumn(sourceCode, templateMatch.index);
+      issues.push({
+        type: "hardcoded-color",
+        severity: hardcodedColorSeverity,
+        line,
+        column,
+        code: templateMatch[0],
+        message: `Hardcoded hex color in template literal. Use theme colors instead.`,
+        suggestion: `Use theme.colors.* or theme.intents[intent].*`
+      });
+    }
+  }
+  const directPlatformSeverity = getRuleSeverity(rules.directPlatformImports, "warning");
+  if (directPlatformSeverity) {
+    const isSharedFile2 = !filePath.includes(".web.") && !filePath.includes(".native.");
+    if (isSharedFile2) {
+      const rnImportRegex = /import\s+.*\s+from\s+['"]react-native['"]/g;
+      let match;
+      while ((match = rnImportRegex.exec(sourceCode)) !== null) {
+        const { line, column } = getLineColumn(sourceCode, match.index);
+        issues.push({
+          type: "direct-platform-import",
+          severity: directPlatformSeverity,
+          line,
+          column,
+          code: match[0],
+          message: `Direct import from 'react-native' in shared file. Use @idealyst/components instead.`,
+          suggestion: `Import View, Text, etc. from '@idealyst/components'`
+        });
+      }
+    }
+  }
+  const counts = {
+    error: issues.filter((i) => i.severity === "error").length,
+    warning: issues.filter((i) => i.severity === "warning").length,
+    info: issues.filter((i) => i.severity === "info").length
+  };
+  return {
+    filePath,
+    issues,
+    passed: counts.error === 0,
+    counts
+  };
+}
+function lintComponents(files, options = {}) {
+  return files.map((file) => lintComponent(file.path, file.content, options));
+}
+function formatLintIssue(issue, filePath) {
+  const severityPrefix = issue.severity === "error" ? "ERROR" : issue.severity === "warning" ? "WARN" : "INFO";
+  let output = `${severityPrefix}: ${filePath}:${issue.line}:${issue.column} - ${issue.message}`;
+  if (issue.suggestion) {
+    output += `
+  Suggestion: ${issue.suggestion}`;
+  }
+  return output;
+}
+function formatLintResults(results) {
+  const lines = [];
+  for (const result of results) {
+    for (const issue of result.issues) {
+      lines.push(formatLintIssue(issue, result.filePath));
+    }
+  }
+  return lines;
+}
+function summarizeLintResults(results) {
+  const issuesByType = {
+    "hardcoded-color": 0,
+    "direct-platform-import": 0
+  };
+  const issuesBySeverity = {
+    error: 0,
+    warning: 0,
+    info: 0
+  };
+  let totalIssues = 0;
+  for (const result of results) {
+    for (const issue of result.issues) {
+      totalIssues++;
+      issuesByType[issue.type]++;
+      issuesBySeverity[issue.severity]++;
+    }
+  }
+  return {
+    totalFiles: results.length,
+    passedFiles: results.filter((r) => r.passed).length,
+    failedFiles: results.filter((r) => !r.passed).length,
+    totalIssues,
+    issuesByType,
+    issuesBySeverity
+  };
+}
+
+// src/index.ts
+var componentRegistry = {};
+var componentNames = [];
+function getComponentsByCategory(category) {
+  return Object.entries(componentRegistry).filter(([_, def]) => def.category === category).map(([name]) => name);
+}
+function getPropConfig(componentName) {
+  const def = componentRegistry[componentName];
+  if (!def) return {};
+  return Object.entries(def.props).reduce((acc, [key, prop]) => {
+    if (prop.values && prop.values.length > 0) {
+      acc[key] = { type: "select", options: prop.values, default: prop.default };
+    } else if (prop.type === "boolean") {
+      acc[key] = { type: "boolean", default: prop.default ?? false };
+    } else if (prop.type === "string") {
+      acc[key] = { type: "text", default: prop.default ?? "" };
+    } else if (prop.type === "number") {
+      acc[key] = { type: "number", default: prop.default ?? 0 };
+    }
+    return acc;
+  }, {});
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTML_ELEMENT_NAMES,
+  HTML_INTRINSIC_ELEMENTS,
+  REACT_DOM_PRIMITIVES,
+  REACT_DOM_PRIMITIVE_NAMES,
+  REACT_DOM_RULE_SET,
+  REACT_DOM_SOURCES,
+  REACT_NATIVE_PRIMITIVES,
+  REACT_NATIVE_PRIMITIVE_NAMES,
+  REACT_NATIVE_RULE_SET,
+  REACT_NATIVE_SOURCES,
+  analyzeComponents,
+  analyzeFiles,
+  analyzePlatformImports,
+  analyzeTheme,
+  classifyFile,
+  componentNames,
+  componentRegistry,
+  filterPlatformImports,
+  formatLintIssue,
+  formatLintResults,
+  formatViolation,
+  formatViolations,
+  generateComponentRegistry,
+  getBaseName,
+  getComponentsByCategory,
+  getExpectedPlatform,
+  getPlatformForSource,
+  getPropConfig,
+  getReactDomPrimitive,
+  getReactNativePrimitive,
+  getUniqueSources,
+  groupImportsBySource,
+  idealystDocsPlugin,
+  isComponentFile,
+  isHtmlElement,
+  isPlatformSpecificFile,
+  isReactDomPrimitive,
+  isReactNativePrimitive,
+  isSharedFile,
+  lintComponent,
+  lintComponents,
+  loadThemeKeys,
+  parseImports,
+  resetThemeCache,
+  summarizeLintResults,
+  summarizeResults
+});
+//# sourceMappingURL=index.cjs.map