@idealyst/tooling 1.2.25 → 1.2.27

package/dist/vite-plugin.cjs

@@ -0,0 +1,802 @@
+"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/vite-plugin.ts
+var vite_plugin_exports = {};
+__export(vite_plugin_exports, {
+  generateComponentRegistry: () => generateComponentRegistry,
+  idealystDocsPlugin: () => idealystDocsPlugin
+});
+module.exports = __toCommonJS(vite_plugin_exports);
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// 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);
+}
+
+// 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
+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 isComponentFile = options.componentPaths.some((p) => file.includes(path3.resolve(p))) && (file.endsWith(".ts") || file.endsWith(".tsx"));
+      const isThemeFile = file.includes(path3.resolve(options.themePath));
+      if (isComponentFile || 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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateComponentRegistry,
+  idealystDocsPlugin
+});
+//# sourceMappingURL=vite-plugin.cjs.map