gladvn 0.2.14

package/scripts/audit-showcase.ts

@@ -0,0 +1,262 @@
+import {
+  Project,
+  SyntaxKind,
+  JsxOpeningElement,
+  JsxSelfClosingElement,
+} from "ts-morph";
+import * as fs from "fs";
+import * as path from "path";
+
+const project = new Project({
+  tsConfigFilePath: "tsconfig.json",
+});
+
+const uiSourceFiles = project.getSourceFiles("src/components/micro/*.tsx");
+const monolithicSourceFiles = project.getSourceFiles(
+  "src/components/monolithic/*.tsx",
+);
+const showcaseSourceFiles = project.getSourceFiles("src/dev/showcase/*.tsx");
+
+type ComponentCoverage = {
+  name: string;
+  uiFile: string;
+  exportedComponents: string[];
+  variants: Record<string, string[]>;
+  showcaseFile: string | null;
+  missingComponents: string[];
+  missingVariants: Record<string, string[]>;
+};
+
+const results: ComponentCoverage[] = [];
+
+for (const uiFile of uiSourceFiles) {
+  const baseName = uiFile.getBaseNameWithoutExtension();
+  const showcaseFile = showcaseSourceFiles.find(
+    (f) => f.getBaseNameWithoutExtension() === baseName,
+  );
+
+  // Find all exported components (Capitalized names)
+  const exportedComponents: string[] = [];
+
+  // Named exports
+  for (const [name, declarations] of uiFile.getExportedDeclarations()) {
+    if (
+      /^[A-Z]/.test(name) &&
+      !name.includes("Context") &&
+      !name.includes("Provider") &&
+      !name.includes("Overlay") &&
+      !name.includes("Portal")
+    ) {
+      const decl = declarations[0];
+      if (
+        decl &&
+        decl.getKind() !== SyntaxKind.TypeAliasDeclaration &&
+        decl.getKind() !== SyntaxKind.InterfaceDeclaration
+      ) {
+        exportedComponents.push(name);
+      }
+    }
+  }
+
+  // Find variants from CVA
+  const variants: Record<string, string[]> = {};
+  const cvaCalls = uiFile
+    .getDescendantsOfKind(SyntaxKind.CallExpression)
+    .filter((c) => c.getExpression().getText() === "cva");
+
+  for (const cvaCall of cvaCalls) {
+    const args = cvaCall.getArguments();
+    if (args.length >= 2) {
+      const configObj = args[1].asKind(SyntaxKind.ObjectLiteralExpression);
+      if (configObj) {
+        const variantsProp = configObj.getProperty("variants");
+        if (
+          variantsProp &&
+          variantsProp.getKind() === SyntaxKind.PropertyAssignment
+        ) {
+          const variantsObj = variantsProp.getInitializerIfKind(
+            SyntaxKind.ObjectLiteralExpression,
+          );
+          if (variantsObj) {
+            for (const variantProp of variantsObj.getProperties()) {
+              if (variantProp.getKind() === SyntaxKind.PropertyAssignment) {
+                const variantName = variantProp.getName();
+                const variantValuesObj = variantProp.getInitializerIfKind(
+                  SyntaxKind.ObjectLiteralExpression,
+                );
+                if (variantValuesObj) {
+                  variants[variantName] = variantValuesObj
+                    .getProperties()
+                    .map((p) => p.getName().replace(/['"]/g, ""));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Also check monolithic wrapper for extra variants/components if it exists
+  const monolithicFile = monolithicSourceFiles.find(
+    (f) => f.getBaseNameWithoutExtension() === baseName,
+  );
+  if (monolithicFile) {
+    for (const [
+      name,
+      declarations,
+    ] of monolithicFile.getExportedDeclarations()) {
+      if (
+        /^[A-Z]/.test(name) &&
+        !name.includes("Context") &&
+        !name.includes("Provider") &&
+        !exportedComponents.includes(name)
+      ) {
+        const decl = declarations[0];
+        if (
+          decl &&
+          decl.getKind() !== SyntaxKind.TypeAliasDeclaration &&
+          decl.getKind() !== SyntaxKind.InterfaceDeclaration
+        ) {
+          exportedComponents.push(name);
+        }
+      }
+    }
+  }
+
+  const missingComponents: string[] = [];
+  const missingVariants: Record<string, string[]> = {};
+
+  if (showcaseFile) {
+    const jsxElements = [
+      ...showcaseFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+      ...showcaseFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+    ];
+
+    const usedTags = new Set(
+      jsxElements.map((el) => el.getTagNameNode().getText()),
+    );
+
+    // Check components
+    for (const comp of exportedComponents) {
+      if (!usedTags.has(comp)) {
+        const isNamespacedUsed = Array.from(usedTags).some(
+          (tag) => tag.includes(`.${comp}`) || tag.endsWith(comp),
+        );
+        if (!isNamespacedUsed) {
+          missingComponents.push(comp);
+        }
+      }
+    }
+
+    // Check variants
+    const usedAttributes: Record<string, Set<string>> = {};
+    for (const el of jsxElements) {
+      for (const attr of el.getAttributes()) {
+        if (attr.getKind() === SyntaxKind.JsxAttribute) {
+          const name = attr.getNameNode().getText();
+          const init = attr.getInitializer();
+          let value = "";
+          if (init) {
+            if (init.getKind() === SyntaxKind.StringLiteral) {
+              value = init.getText().replace(/['"]/g, "");
+            } else if (init.getKind() === SyntaxKind.JsxExpression) {
+              value = init.getExpression()?.getText() || "";
+            }
+          } else {
+            value = "true";
+          }
+          if (!usedAttributes[name]) usedAttributes[name] = new Set();
+          usedAttributes[name].add(value);
+        }
+      }
+    }
+
+    for (const [vName, vValues] of Object.entries(variants)) {
+      missingVariants[vName] = [];
+      const usedVals = usedAttributes[vName] || new Set();
+      const usedValsStr = Array.from(usedVals).join(" ");
+
+      for (const val of vValues) {
+        if (val === "default") continue;
+        if (
+          !usedValsStr.includes(val) &&
+          !usedValsStr.includes(`"${val}"`) &&
+          !usedValsStr.includes(`'${val}'`)
+        ) {
+          if (vName === "size" && usedValsStr.includes("globalSize")) {
+            continue;
+          }
+          missingVariants[vName].push(val);
+        }
+      }
+      if (missingVariants[vName].length === 0) {
+        delete missingVariants[vName];
+      }
+    }
+  }
+
+  if (exportedComponents.length > 0 || Object.keys(variants).length > 0) {
+    results.push({
+      name: baseName,
+      uiFile: uiFile.getFilePath(),
+      exportedComponents,
+      variants,
+      showcaseFile: showcaseFile?.getFilePath() || null,
+      missingComponents,
+      missingVariants,
+    });
+  }
+}
+
+let md = `# Báo Cáo Mức Độ Phủ Sóng Của Showcase (AST Auditing)
+*Tạo lúc: ${new Date().toLocaleString()}*
+
+Mục tiêu: Đảm bảo toàn bộ Component, Sub-component, Variant, Color, Size được export từ \`src/components/micro/*\` đều có ít nhất một ví dụ trong \`src/dev/showcase/*\`.
+
+`;
+
+let perfectCount = 0;
+let missingShowcaseCount = 0;
+
+for (const res of results) {
+  if (!res.showcaseFile) {
+    missingShowcaseCount++;
+    md += `## ❌ ${res.name} (Thiếu hoàn toàn Showcase)\n`;
+    continue;
+  }
+
+  const hasMissingComps = res.missingComponents.length > 0;
+  const hasMissingVars = Object.keys(res.missingVariants).length > 0;
+
+  if (!hasMissingComps && !hasMissingVars) {
+    perfectCount++;
+    continue;
+  }
+
+  md += `## ⚠️ ${res.name}\n`;
+  if (hasMissingComps) {
+    md += `- **Thiếu Sub-components:** ${res.missingComponents.map((c) => "`" + c + "`").join(", ")}\n`;
+  }
+  if (hasMissingVars) {
+    md += `- **Thiếu Variants:**\n`;
+    for (const [vName, vVals] of Object.entries(res.missingVariants)) {
+      md += `  - \`${vName}\`: ${vVals.map((v) => "`" + v + "`").join(", ")}\n`;
+    }
+  }
+  md += "\n";
+}
+
+md += `## Tóm Tắt\n`;
+md += `- Tổng số Components: ${results.length}\n`;
+md += `- Hoàn hảo (100% Coverage): ${perfectCount}\n`;
+md += `- Thiếu Showcase File: ${missingShowcaseCount}\n`;
+md += `- Cần bổ sung ví dụ: ${results.length - perfectCount - missingShowcaseCount}\n`;
+
+fs.writeFileSync(
+  "/Users/y/.gemini/antigravity-ide/brain/b74152fa-bc73-4d65-9843-c65a49e0b5c5/showcase_coverage_report.md",
+  md,
+);
+console.log(
+  "Report generated at /Users/y/.gemini/antigravity-ide/brain/b74152fa-bc73-4d65-9843-c65a49e0b5c5/showcase_coverage_report.md",
+);

package/scripts/audit-showcases.ts

@@ -0,0 +1,83 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const uiDir = path.join(__dirname, "../src/components/micro");
+const showcaseDir = path.join(__dirname, "../src/dev/showcase");
+
+const uiFiles = fs
+  .readdirSync(uiDir)
+  .filter((f) => f.endsWith(".tsx") && !f.includes("index.tsx"));
+
+const issues: Record<string, string[]> = {};
+
+for (const file of uiFiles) {
+  const componentName = file.replace(".tsx", "");
+  const showcaseFile = path.join(showcaseDir, file);
+  const uiContent = fs.readFileSync(path.join(uiDir, file), "utf-8");
+
+  if (!fs.existsSync(showcaseFile)) continue;
+  const showcaseContent = fs.readFileSync(showcaseFile, "utf-8");
+
+  issues[componentName] = [];
+
+  // 1. Check exports vs imports
+  const exportMatches = uiContent.match(/export \{([^}]+)\}/);
+  if (exportMatches) {
+    const exports = exportMatches[1]
+      .split(",")
+      .map((e) => e.trim())
+      .filter((e) => e);
+    for (const exp of exports) {
+      const actualExport = exp.includes(" as ")
+        ? exp.split(" as ")[1].trim()
+        : exp;
+      if (
+        actualExport &&
+        !showcaseContent.includes(actualExport) &&
+        actualExport !== "type"
+      ) {
+        issues[componentName].push(`Missing subcomponent: ${actualExport}`);
+      }
+    }
+  }
+
+  // 2. Check globalSize
+  if (uiContent.includes("size: {") || uiContent.includes('size = "')) {
+    if (!showcaseContent.includes("globalSize")) {
+      issues[componentName].push("Missing globalSize toggle");
+    }
+  }
+
+  // 3. Check variants
+  if (uiContent.includes("variant: {")) {
+    const variantMatch = uiContent.match(/variant:\s*\{([^}]+)\}/);
+    if (variantMatch) {
+      const variants = variantMatch[1]
+        .split("\n")
+        .map((l) => l.trim().split(":")[0].replace(/['"]/g, ""))
+        .filter((v) => v && !v.includes("//") && v !== "default");
+      for (const v of variants) {
+        if (
+          !showcaseContent.includes(`variant="${v}"`) &&
+          !showcaseContent.includes(`variant='${v}'`)
+        ) {
+          issues[componentName].push(`Missing variant demo: ${v}`);
+        }
+      }
+    }
+  }
+}
+
+let hasIssues = false;
+for (const [comp, compIssues] of Object.entries(issues)) {
+  if (compIssues.length > 0) {
+    hasIssues = true;
+    console.log(`\n❌ ${comp}.tsx:`);
+    compIssues.forEach((i) => console.log(`  - ${i}`));
+  }
+}
+if (!hasIssues) console.log("All showcases fully cover their components!");

package/scripts/clean-imports.ts

@@ -0,0 +1,21 @@
+import { Project } from "ts-morph";
+
+const project = new Project({
+  tsConfigFilePath: "/Users/y/Desktop/github/gladcn/tsconfig.json",
+});
+
+const sourceFiles = project.getSourceFiles(
+  "/Users/y/Desktop/github/gladcn/src/dev/showcase/**/*.tsx",
+);
+console.log(`Found ${sourceFiles.length} showcase files to process.`);
+
+for (const sourceFile of sourceFiles) {
+  // Use fixUnusedIdentifiers to let TS compiler fix unused imports
+  const text = sourceFile.getFullText();
+  // We can just use the organize imports feature
+  sourceFile.organizeImports();
+  sourceFile.fixUnusedIdentifiers();
+}
+
+project.saveSync();
+console.log("Cleanup complete!");

package/scripts/count_missing.ts

@@ -0,0 +1,24 @@
+import { Project, SyntaxKind } from "ts-morph";
+
+const project = new Project({
+  tsConfigFilePath: "tsconfig.json",
+});
+
+const sourceFiles = project.getSourceFiles("src/dev/showcase/**/*.tsx");
+let missing = 0;
+let total = 0;
+
+for (const sourceFile of sourceFiles) {
+  const exampleSections = sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement)
+    .filter(element => element.getOpeningElement().getTagNameNode().getText() === "ExampleSection");
+    
+  for (const section of exampleSections) {
+    total++;
+    const hasCodeString = section.getOpeningElement().getAttributes().some(attr => {
+      return attr.getKind() === SyntaxKind.JsxAttribute && 
+             attr.asKind(SyntaxKind.JsxAttribute)?.getNameNode().getText() === "codeString";
+    });
+    if (!hasCodeString) missing++;
+  }
+}
+console.log(`Total ExampleSections: ${total}, Missing codeString: ${missing}`);

package/scripts/find-css-vars.ts

@@ -0,0 +1,62 @@
+import * as fs from "fs";
+import * as path from "path";
+
+const SRC_DIR = path.join(process.cwd(), "src/components");
+
+function walkDir(dir: string, callback: (filePath: string) => void) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      walkDir(fullPath, callback);
+    } else if (fullPath.endsWith(".tsx") || fullPath.endsWith(".ts")) {
+      callback(fullPath);
+    }
+  }
+}
+
+const defRegex = /\[--([a-zA-Z0-9_-]+):([^\]]+)\]/g;
+const usageRegex =
+  /(w|h|size|rounded|p|m|gap|space-[xy]|top|bottom|left|right)-\(--([a-zA-Z0-9_-]+)\)/g;
+const genericUsageRegex = /var\(--([a-zA-Z0-9_-]+)\)/g;
+
+const results: Record<string, { defs: Set<string>; usages: Set<string> }> = {};
+
+walkDir(SRC_DIR, (filePath) => {
+  const content = fs.readFileSync(filePath, "utf-8");
+  let match;
+
+  const relPath = path.relative(process.cwd(), filePath);
+
+  while ((match = defRegex.exec(content)) !== null) {
+    if (!results[relPath])
+      results[relPath] = { defs: new Set(), usages: new Set() };
+    results[relPath].defs.add(`--${match[1]}: ${match[2]}`);
+  }
+
+  while ((match = usageRegex.exec(content)) !== null) {
+    if (!results[relPath])
+      results[relPath] = { defs: new Set(), usages: new Set() };
+    results[relPath].usages.add(`${match[1]}-(--${match[2]})`);
+  }
+
+  while ((match = genericUsageRegex.exec(content)) !== null) {
+    // Avoid double counting if it's already caught by defRegex
+    if (!results[relPath])
+      results[relPath] = { defs: new Set(), usages: new Set() };
+    results[relPath].usages.add(`var(--${match[1]})`);
+  }
+});
+
+for (const [file, data] of Object.entries(results)) {
+  if (data.defs.size === 0 && data.usages.size === 0) continue;
+  console.log(`\nFile: ${file}`);
+  if (data.defs.size > 0) {
+    console.log(`  Definitions:`);
+    for (const def of data.defs) console.log(`    - ${def}`);
+  }
+  if (data.usages.size > 0) {
+    console.log(`  Usages:`);
+    for (const usage of data.usages) console.log(`    - ${usage}`);
+  }
+}

package/scripts/fix-portals.ts

@@ -0,0 +1,90 @@
+import { Project, SyntaxKind, JsxElement } from "ts-morph";
+
+const project = new Project({ tsConfigFilePath: "./tsconfig.json" });
+const sourceFiles = [
+  ...project.addSourceFilesAtPaths("src/dev/showcase/**/*.tsx"),
+  ...project.addSourceFilesAtPaths("src/components/macro/**/*.tsx")
+];
+
+const map: Record<string, string> = {
+  "DropdownMenuContent": "DropdownMenuPortal",
+  "SelectContent": "SelectPortal",
+  "PopoverContent": "PopoverPortal",
+  "HoverCardContent": "HoverCardPortal",
+  "TooltipContent": "TooltipPortal",
+  "DialogContent": "DialogPortal",
+  "AlertDialogContent": "AlertDialogPortal",
+  "ContextMenuContent": "ContextMenuPortal",
+  "MenubarContent": "MenubarPortal",
+  "ComboboxContent": "ComboboxPortal"
+};
+
+for (const sf of sourceFiles) {
+  let changed = false;
+
+  // We loop until no more elements need wrapping to avoid AST node invalidation errors
+  let needsMoreWork = true;
+  while (needsMoreWork) {
+    needsMoreWork = false;
+    const elements = sf.getDescendantsOfKind(SyntaxKind.JsxElement);
+    
+    for (const element of elements) {
+      // Check if it's already been deleted/replaced
+      if (element.wasForgotten()) continue;
+      
+      const openingEl = element.getOpeningElement();
+      const tagName = openingEl.getTagNameNode().getText();
+      
+      if (map[tagName]) {
+        const portalName = map[tagName];
+        const parent = element.getParent();
+        
+        let needsWrap = true;
+        if (parent && parent.getKind() === SyntaxKind.JsxElement) {
+          const parentOpening = (parent as JsxElement).getOpeningElement().getTagNameNode().getText();
+          if (parentOpening === portalName || parentOpening === "ThemeWrapper") {
+            needsWrap = false;
+          }
+        }
+        
+        if (needsWrap) {
+          element.replaceWithText(`<${portalName}>\n${element.getText()}\n</${portalName}>`);
+          changed = true;
+          needsMoreWork = true;
+          break; // Break the for loop and restart traversal on fresh AST
+        }
+      }
+    }
+  }
+
+  // Ensure imports are correct
+  if (changed) {
+    const importDecls = sf.getImportDeclarations();
+    // Gather all tags we need imports for in this file
+    const tagsInFile = new Set<string>();
+    sf.getDescendantsOfKind(SyntaxKind.JsxOpeningElement).forEach(el => {
+      const name = el.getTagNameNode().getText();
+      if (Object.values(map).includes(name)) tagsInFile.add(name);
+    });
+
+    for (const portalName of tagsInFile) {
+      // Find the import declaration for this micro component
+      const primitiveName = portalName.replace('Portal', '').toLowerCase()
+        .replace('dropdownmenu', 'dropdown-menu')
+        .replace('alertdialog', 'alert-dialog')
+        .replace('hovercard', 'hover-card')
+        .replace('contextmenu', 'context-menu');
+      
+      const matchingImport = importDecls.find(imp => imp.getModuleSpecifierValue().includes(`components/micro/${primitiveName}`));
+      if (matchingImport) {
+        const namedImports = matchingImport.getNamedImports();
+        if (!namedImports.some(n => n.getName() === portalName)) {
+          matchingImport.addNamedImport(portalName);
+        }
+      }
+    }
+
+    sf.saveSync();
+    console.log("Fixed missing portals in", sf.getBaseName());
+  }
+}

package/scripts/full-audit.ts

@@ -0,0 +1,89 @@
+import * as fs from "fs";
+import * as path from "path";
+
+const SRC_DIR = path.join(process.cwd(), "src/components");
+
+function walkDir(dir: string, callback: (filePath: string) => void) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      walkDir(fullPath, callback);
+    } else if (fullPath.endsWith(".tsx") || fullPath.endsWith(".ts")) {
+      callback(fullPath);
+    }
+  }
+}
+
+const results: Record<string, string[]> = {};
+
+function addIssue(file: string, issue: string) {
+  const relPath = path.relative(process.cwd(), file);
+  if (!results[relPath]) results[relPath] = [];
+  results[relPath].push(issue);
+}
+
+walkDir(SRC_DIR, (filePath) => {
+  const content = fs.readFileSync(filePath, "utf-8");
+
+  // 1. Magic CSS Violations
+  if (/\[&_[a-zA-Z0-9]+\]/.test(content)) {
+    addIssue(
+      filePath,
+      "Magic CSS: Uses raw HTML tag descendant selectors (e.g. [&_div]) instead of data-slots.",
+    );
+  }
+  if (/has-\[/.test(content)) {
+    addIssue(
+      filePath,
+      "Magic CSS: Uses :has() combinator which may be fragile for encapsulation.",
+    );
+  }
+  if (/\*:/g.test(content)) {
+    addIssue(
+      filePath,
+      "Magic CSS: Uses universal selector (*:) which breaks encapsulation.",
+    );
+  }
+
+  // 2. React Antipatterns
+  if (
+    /\.map\([^,]+,\s*(?:index|i)\s*\)\s*=>\s*[\s\S]*?key=\{?(?:index|i)\}?/m.test(
+      content,
+    )
+  ) {
+    addIssue(filePath, "React: Uses array index as key in map().");
+  }
+
+  // 3. String manipulation Edge Cases
+  if (/\.substring\(/.test(content) || /\.charAt\(/.test(content)) {
+    addIssue(
+      filePath,
+      "Edge Case: Uses charAt or substring which breaks on Emojis/Surrogate pairs.",
+    );
+  }
+
+  // 4. Props / Architecture
+  if (filePath.includes("micro") && content.includes("useState(")) {
+    addIssue(
+      filePath,
+      "Architecture: Micro component contains local state (useState). Micro components should generally be stateless wrappers.",
+    );
+  }
+
+  if (
+    filePath.includes("macro") &&
+    content.includes("forwardRef") &&
+    !content.includes("asChild") &&
+    !content.includes("render=")
+  ) {
+    // Just a heuristic, not always a bug.
+  }
+});
+
+for (const [file, issues] of Object.entries(results)) {
+  console.log(`\nFile: ${file}`);
+  for (const issue of issues) {
+    console.log(`  - ${issue}`);
+  }
+}

package/scripts/merge-components.cjs

@@ -0,0 +1,65 @@
+const fs = require("fs");
+const path = require("path");
+
+const dataTsPath = path.resolve(__dirname, "../src/dev/data.ts");
+let content = fs.readFileSync(dataTsPath, "utf8");
+
+// Match MICRO_COMPONENTS array
+const microMatch = content.match(
+  /export const MICRO_COMPONENTS = (\[[\s\S]*?\]);/,
+);
+// Match MACRO_COMPONENTS array
+const macroMatch = content.match(
+  /export const MACRO_COMPONENTS = (\[[\s\S]*?\]);/,
+);
+
+if (!microMatch || !macroMatch) {
+  console.error("Could not find arrays");
+  process.exit(1);
+}
+
+// Safely evaluate arrays (since they only contain static objects)
+const micro = eval(microMatch[1]);
+const macro = eval(macroMatch[1]);
+
+const componentMap = new Map();
+
+micro.forEach((c) => {
+  componentMap.set(c.id, {
+    id: c.id,
+    label: c.label,
+    hasMicro: true,
+    hasMacro: false,
+  });
+});
+
+macro.forEach((c) => {
+  const baseId = c.id.replace("macro-", "");
+  if (componentMap.has(baseId)) {
+    componentMap.get(baseId).hasMacro = true;
+  } else {
+    componentMap.set(baseId, {
+      id: baseId,
+      label: c.label,
+      hasMicro: false,
+      hasMacro: true,
+    });
+  }
+});
+
+const merged = Array.from(componentMap.values()).sort((a, b) =>
+  a.label.localeCompare(b.label),
+);
+
+let output = "export const COMPONENTS = [\n";
+merged.forEach((c) => {
+  output += `  { id: "${c.id}", label: "${c.label}", hasMicro: ${c.hasMicro}, hasMacro: ${c.hasMacro} },\n`;
+});
+output += "];\n";
+
+// Replace in content
+content = content.replace(microMatch[0], output);
+content = content.replace(macroMatch[0], ""); // Remove MACRO_COMPONENTS
+
+fs.writeFileSync(dataTsPath, content);
+console.log("Merged data.ts successfully.");