@fragments-sdk/cli 0.14.2 → 0.15.0

package/dist/{chunk-55KERLWL.js → chunk-65WSVDV5.js}

@@ -2,7 +2,7 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 import {
   BRAND,
   fragmentsConfigSchema
-} from "./chunk-I34BC3CU.js";
+} from "./chunk-32LIWN2P.js";
 
 // src/core/config.ts
 import { existsSync } from "fs";
@@ -17,7 +17,9 @@ var STORYBOOK_FILTER_DEFAULTS = {
 var DEFAULT_CONFIG = {
   include: [
     `src/**/*${BRAND.fileExtension}`,
-    // *.fragment.tsx files
+    // *.contract.json files (V2 canonical)
+    "src/**/*.fragment.tsx",
+    // Legacy fragment files (still supported)
     "src/**/*.stories.tsx"
     // Storybook stories (auto-converted)
   ],
@@ -80,6 +82,293 @@ ${errors}`);
   }
 }
 
+// src/core/discovery.ts
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { readFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import fg from "fast-glob";
+function toPascalCase(name) {
+  return name.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+async function extractPascalCaseExports(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const exports = /* @__PURE__ */ new Set();
+    const exportFuncRegex = /export\s+function\s+([A-Z][a-zA-Z0-9]*)/g;
+    let match;
+    while ((match = exportFuncRegex.exec(content)) !== null) {
+      exports.add(match[1]);
+    }
+    const exportConstRegex = /export\s+const\s+([A-Z][a-zA-Z0-9]*)/g;
+    while ((match = exportConstRegex.exec(content)) !== null) {
+      exports.add(match[1]);
+    }
+    const exportBlockRegex = /export\s*\{([^}]+)\}/g;
+    while ((match = exportBlockRegex.exec(content)) !== null) {
+      const names = match[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+      for (const name of names) {
+        if (/^[A-Z]/.test(name)) {
+          exports.add(name);
+        }
+      }
+    }
+    return Array.from(exports);
+  } catch {
+    return [];
+  }
+}
+async function discoverBlockFiles(configDir, exclude) {
+  const patterns = [
+    `**/*${BRAND.blockFileExtension}`,
+    `**/*${BRAND.recipeFileExtension}`
+  ];
+  const files = await fg(patterns, {
+    cwd: configDir,
+    ignore: exclude ?? ["**/node_modules/**", "**/dist/**"],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+async function discoverFragmentFiles(config, configDir) {
+  const defaultExcludes = [
+    "**/*.test.stories.*",
+    "**/*.stories.test.*",
+    "**/*.test.story.*",
+    "**/*.story.test.*"
+  ];
+  const patterns = [
+    ...config.include,
+    "**/*.contract.json"
+  ];
+  const files = await fg(patterns, {
+    cwd: configDir,
+    ignore: [...defaultExcludes, ...config.exclude ?? []],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+async function discoverComponentFiles(config, configDir) {
+  if (!config.components || config.components.length === 0) {
+    return [];
+  }
+  const files = await fg(config.components, {
+    cwd: configDir,
+    ignore: [
+      ...config.exclude ?? [],
+      // Exclude fragment files themselves
+      ...config.include,
+      // Exclude test files
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/__tests__/**"
+    ],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+function extractComponentName(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/");
+  const fileName = parts[parts.length - 1];
+  if (fileName === "index.tsx" || fileName === "index.ts") {
+    return parts[parts.length - 2] ?? "Unknown";
+  }
+  return fileName.replace(/\.(tsx?|jsx?)$/, "");
+}
+var DEFAULT_COMPONENT_PATTERNS = [
+  "src/components/**/*.tsx",
+  "src/components/**/index.tsx",
+  "components/**/*.tsx",
+  "lib/components/**/*.tsx",
+  "packages/*/src/components/**/*.tsx"
+];
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*.stories.*",
+  "**/*.story.*",
+  "**/__tests__/**",
+  "**/__mocks__/**",
+  "**/node_modules/**",
+  "**/dist/**"
+];
+async function discoverComponentsFromSource(configDir, patterns, exclude) {
+  const searchPatterns = patterns && patterns.length > 0 ? patterns : DEFAULT_COMPONENT_PATTERNS;
+  const excludePatterns = [
+    ...DEFAULT_EXCLUDE_PATTERNS,
+    ...exclude ?? []
+  ];
+  const files = await fg(searchPatterns, {
+    cwd: configDir,
+    ignore: excludePatterns,
+    absolute: false
+  });
+  const pascalCaseFiles = [];
+  const lowercaseFiles = [];
+  for (const file of files) {
+    const name = extractComponentName(file);
+    if (/^[A-Z]/.test(name)) {
+      pascalCaseFiles.push(file);
+    } else if (/^[a-z]/.test(name)) {
+      lowercaseFiles.push(file);
+    }
+  }
+  const storyPatterns = [
+    "**/*.stories.tsx",
+    "**/*.stories.ts",
+    "**/*.story.tsx",
+    "**/*.story.ts"
+  ];
+  const storyFiles = await fg(storyPatterns, {
+    cwd: configDir,
+    ignore: ["**/node_modules/**", "**/dist/**"],
+    absolute: false
+  });
+  const storyMap = /* @__PURE__ */ new Map();
+  for (const storyFile of storyFiles) {
+    const name = extractComponentName(storyFile.replace(/\.stories?\.(tsx?|jsx?)$/, ".tsx"));
+    storyMap.set(name, storyFile);
+  }
+  const components = [];
+  for (const file of pascalCaseFiles) {
+    const name = extractComponentName(file);
+    const absolutePath = resolve2(configDir, file);
+    const storyFile = storyMap.get(name);
+    components.push({
+      name,
+      sourcePath: absolutePath,
+      relativePath: file,
+      storyPath: storyFile ? resolve2(configDir, storyFile) : void 0
+    });
+  }
+  for (const file of lowercaseFiles) {
+    const absolutePath = resolve2(configDir, file);
+    const fileName = extractComponentName(file);
+    const pascalName = toPascalCase(fileName);
+    const exports = await extractPascalCaseExports(absolutePath);
+    const primaryExport = exports.find((e) => e === pascalName) || exports[0];
+    if (primaryExport) {
+      const storyFile = storyMap.get(primaryExport) || storyMap.get(fileName);
+      components.push({
+        name: primaryExport,
+        sourcePath: absolutePath,
+        relativePath: file,
+        storyPath: storyFile ? resolve2(configDir, storyFile) : void 0
+      });
+    }
+  }
+  components.sort((a, b) => a.name.localeCompare(b.name));
+  return components;
+}
+async function discoverComponentsFromBarrel(barrelPath, configDir) {
+  const absoluteBarrelPath = resolve2(configDir, barrelPath);
+  if (!existsSync2(absoluteBarrelPath)) {
+    return [];
+  }
+  const content = await readFile(absoluteBarrelPath, "utf-8");
+  const components = [];
+  const exportRegex = /export\s+(?:\*|{([^}]+)})\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = exportRegex.exec(content)) !== null) {
+    const exportedNames = match[1];
+    const importPath = match[2];
+    const barrelDir = dirname2(absoluteBarrelPath);
+    let resolvedPath = resolve2(barrelDir, importPath);
+    if (!resolvedPath.endsWith(".tsx") && !resolvedPath.endsWith(".ts")) {
+      if (existsSync2(`${resolvedPath}.tsx`)) {
+        resolvedPath = `${resolvedPath}.tsx`;
+      } else if (existsSync2(`${resolvedPath}.ts`)) {
+        resolvedPath = `${resolvedPath}.ts`;
+      } else if (existsSync2(`${resolvedPath}/index.tsx`)) {
+        resolvedPath = `${resolvedPath}/index.tsx`;
+      } else if (existsSync2(`${resolvedPath}/index.ts`)) {
+        resolvedPath = `${resolvedPath}/index.ts`;
+      }
+    }
+    if (!existsSync2(resolvedPath)) {
+      continue;
+    }
+    if (exportedNames) {
+      const names = exportedNames.split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+      for (const name of names) {
+        if (/^[A-Z]/.test(name)) {
+          const relativePath = resolvedPath.replace(configDir + "/", "");
+          components.push({
+            name,
+            sourcePath: resolvedPath,
+            relativePath
+          });
+        }
+      }
+    } else {
+      const name = extractComponentName(importPath);
+      if (/^[A-Z]/.test(name)) {
+        const relativePath = resolvedPath.replace(configDir + "/", "");
+        components.push({
+          name,
+          sourcePath: resolvedPath,
+          relativePath
+        });
+      }
+    }
+  }
+  return components;
+}
+var DEFAULT_TOKEN_PATTERNS = [
+  "src/**/tokens/**/_variables.scss",
+  "src/**/tokens/**/variables.scss",
+  "src/**/styles/**/variables.scss",
+  "src/**/styles/**/tokens.scss",
+  "src/**/styles/**/variables.css",
+  "src/**/theme/**/_variables.scss",
+  "src/**/theme/**/tokens.css",
+  // DTCG token files
+  "**/*.tokens.json",
+  "**/*.tokens"
+];
+async function discoverTokenFiles(configDir, patterns, exclude) {
+  const searchPatterns = patterns && patterns.length > 0 ? patterns : DEFAULT_TOKEN_PATTERNS;
+  const files = await fg(searchPatterns, {
+    cwd: configDir,
+    ignore: exclude ?? ["**/node_modules/**", "**/dist/**"],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+async function discoverAllComponents(configDir, options = {}) {
+  const componentsMap = /* @__PURE__ */ new Map();
+  const sourceComponents = await discoverComponentsFromSource(
+    configDir,
+    options.patterns,
+    options.exclude
+  );
+  for (const comp of sourceComponents) {
+    componentsMap.set(comp.name, comp);
+  }
+  if (options.barrelFiles && options.barrelFiles.length > 0) {
+    for (const barrelFile of options.barrelFiles) {
+      const barrelComponents = await discoverComponentsFromBarrel(barrelFile, configDir);
+      for (const comp of barrelComponents) {
+        if (!componentsMap.has(comp.name)) {
+          componentsMap.set(comp.name, comp);
+        }
+      }
+    }
+  }
+  return Array.from(componentsMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+
 // src/core/generators/typescript-extractor.ts
 import ts from "typescript";
 import { readFileSync } from "fs";
@@ -338,8 +627,8 @@ function getJSDocDefault(node) {
 
 // src/core/generators/registry.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { relative, dirname as dirname2, basename, join } from "path";
-import fg from "fast-glob";
+import { relative, dirname as dirname3, basename as basename2, join } from "path";
+import fg2 from "fast-glob";
 async function generateRegistry(options) {
   const {
     projectRoot,
@@ -357,18 +646,18 @@ async function generateRegistry(options) {
   } = registryOptions;
   const errors = [];
   const warnings = [];
-  const storyFiles = await fg(storyPatterns, {
+  const storyFiles = await fg2(storyPatterns, {
     cwd: projectRoot,
     ignore: ["**/node_modules/**"],
     absolute: true
   });
   const storyMap = /* @__PURE__ */ new Map();
   for (const storyPath of storyFiles) {
-    const storyDir = dirname2(storyPath);
-    const storyBase = basename(storyPath).replace(/\.stories\.(tsx?|jsx?)$/, "");
+    const storyDir = dirname3(storyPath);
+    const storyBase = basename2(storyPath).replace(/\.stories\.(tsx?|jsx?)$/, "");
     storyMap.set(`${storyDir}/${storyBase}`, storyPath);
   }
-  const componentFiles = await fg(componentPatterns, {
+  const componentFiles = await fg2(componentPatterns, {
     cwd: projectRoot,
     ignore: [
       "**/node_modules/**",
@@ -384,13 +673,13 @@ async function generateRegistry(options) {
     BRAND.componentsDir,
     `*${BRAND.fileExtension}`
   );
-  const fragmentFiles = await fg(fragmentPattern, {
+  const fragmentFiles = await fg2(fragmentPattern, {
     cwd: projectRoot,
     absolute: true
   });
   const fragmentMap = /* @__PURE__ */ new Map();
   for (const fragmentPath of fragmentFiles) {
-    const fragmentName = basename(fragmentPath).replace(BRAND.fileExtension, "");
+    const fragmentName = basename2(fragmentPath).replace(BRAND.fileExtension, "");
     try {
       const content = readFileSync2(fragmentPath, "utf-8");
       const fragment = JSON.parse(content);
@@ -419,8 +708,8 @@ async function generateRegistry(options) {
       if (publicOnly && !extracted.exports.includes(componentName)) {
         continue;
       }
-      const componentDir = dirname2(filePath);
-      const baseNameWithoutExt = basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+      const componentDir = dirname3(filePath);
+      const baseNameWithoutExt = basename2(filePath).replace(/\.(tsx?|jsx?)$/, "");
       const storyPath = storyMap.get(`${componentDir}/${baseNameWithoutExt}`);
       if (requireStory && !storyPath) {
         continue;
@@ -801,7 +1090,7 @@ function estimateTokens(text) {
 
 // src/core/loader.ts
 import { unlink } from "fs/promises";
-import { dirname as dirname3, basename as basename2, join as join2 } from "path";
+import { dirname as dirname4, basename as basename3, join as join2 } from "path";
 import { pathToFileURL } from "url";
 import { build } from "esbuild";
 var DEFINE_FRAGMENT_SHIM = `
@@ -862,8 +1151,8 @@ async function loadFragmentFile(absolutePath) {
     const module = await import(fileUrl);
     return unwrapFragmentExport(module.default ?? null);
   }
-  const sourceDir = dirname3(absolutePath);
-  const baseName = basename2(absolutePath, `.${ext}`);
+  const sourceDir = dirname4(absolutePath);
+  const baseName = basename3(absolutePath, `.${ext}`);
   const tempFile = join2(sourceDir, `.${baseName}.fragments-temp-${Date.now()}.mjs`);
   try {
     await build({
@@ -1322,91 +1611,27 @@ function extractLiteralValue(expr) {
 }
 
 // src/core/previewLoader.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, resolve as resolve2 } from "path";
-var PREVIEW_FILES = [
-  "preview.tsx",
-  "preview.ts",
-  "preview.jsx",
-  "preview.js"
-];
-function findPreviewConfigPath(storybookDir) {
-  for (const fileName of PREVIEW_FILES) {
-    const filePath = join3(storybookDir, fileName);
-    if (existsSync3(filePath)) {
-      return filePath;
-    }
-  }
-  return null;
-}
-function findStorybookDir(projectRoot) {
-  const possiblePaths = [
-    join3(projectRoot, ".storybook"),
-    join3(projectRoot, "storybook")
-  ];
-  for (const dir of possiblePaths) {
-    if (existsSync3(dir)) {
-      return dir;
-    }
-  }
-  return null;
-}
-function generatePreviewModule(previewPath) {
-  if (!previewPath) {
-    return `
-export const decorators = [];
-export const parameters = {};
-export const globalTypes = {};
-export const args = {};
-export const argTypes = {};
-export const loaders = [];
-
-export default {
-  decorators,
-  parameters,
-  globalTypes,
-  args,
-  argTypes,
-  loaders,
-};
-`;
-  }
-  return `
-import * as preview from "${previewPath}";
-
-export const decorators = preview.decorators ?? preview.default?.decorators ?? [];
-export const parameters = preview.parameters ?? preview.default?.parameters ?? {};
-export const globalTypes = preview.globalTypes ?? preview.default?.globalTypes ?? {};
-export const args = preview.args ?? preview.default?.args ?? {};
-export const argTypes = preview.argTypes ?? preview.default?.argTypes ?? {};
-export const loaders = preview.loaders ?? preview.default?.loaders ?? [];
-
-export default {
-  decorators,
-  parameters,
-  globalTypes,
-  args,
-  argTypes,
-  loaders,
-};
-`;
-}
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
 
 // src/core/importAnalyzer.ts
 import ts3 from "typescript";
 import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname4, basename as basename3 } from "path";
+import { dirname as dirname5, basename as basename4 } from "path";
 
 export {
   findConfigFile,
   loadConfig,
+  discoverBlockFiles,
+  discoverFragmentFiles,
+  discoverComponentFiles,
+  extractComponentName,
+  discoverTokenFiles,
+  discoverAllComponents,
   loadFragmentFile,
   parseFragmentFile,
-  findPreviewConfigPath,
-  findStorybookDir,
-  generatePreviewModule,
   extractPropsFromFile,
   generateRegistry,
   generateContextMd
 };
-//# sourceMappingURL=chunk-55KERLWL.js.map
+//# sourceMappingURL=chunk-65WSVDV5.js.map