@contentful/experience-design-system-extraction 2.33.1-dev-build-d7fc540.0 → 2.33.1-dev-build-1b6f259.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-extraction",
-  "version": "2.33.1-dev-build-d7fc540.0",
+  "version": "2.33.1-dev-build-1b6f259.0",
   "description": "Component extraction engine for the Contentful Experience Design System SDK",
   "license": "MIT",
   "type": "module",

package/dist/src/extract/astro.js

@@ -1,7 +1,9 @@
 import { basename } from 'node:path';
-import { readFile } from 'node:fs/promises';
 import os from 'node:os';
 import { Project, Node } from 'ts-morph';
+import { createSortedExtractionResult, runFileExtractionWorkers } from './file-extraction-workers.js';
+import { resolveTypeProperty } from './resolve-type-property.js';
+import { getSourceLineMetadata } from './source-line-metadata.js';
 function extractAllowedValues(typeText) {
     // Check if the type is a union of string literals like 'a' | 'b' | 'c'
     const parts = typeText.split('|').map((p) => p.trim());
@@ -30,8 +32,8 @@ function extractBindingPropName(element) {
         return null;
     return element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText();
 }
-function extractFallbackPropsFromFrontmatter(frontmatter) {
-    const project = new Project({
+function createAstroFrontmatterProject() {
+    return new Project({
         compilerOptions: {
             strict: false,
             target: 99,
@@ -41,27 +43,33 @@ function extractFallbackPropsFromFrontmatter(frontmatter) {
         useInMemoryFileSystem: true,
         skipAddingFilesFromTsConfig: true,
     });
-    const sf = project.createSourceFile('__frontmatter__.ts', frontmatter);
-    const props = new Map();
+}
+function forEachAstroPropsBinding(frontmatter, visit) {
+    const sf = createAstroFrontmatterProject().createSourceFile('__frontmatter__.ts', frontmatter);
     sf.forEachDescendant((node) => {
         if (!Node.isVariableDeclaration(node))
             return;
         const initializer = node.getInitializer();
-        if (!usesAstroProps(initializer))
+        if (!initializer || !usesAstroProps(initializer))
             return;
         const nameNode = node.getNameNode();
         if (!Node.isObjectBindingPattern(nameNode))
             return;
-        for (const element of nameNode.getElements()) {
-            const propName = extractBindingPropName(element);
-            if (!propName)
-                continue;
-            props.set(propName, {
-                name: propName,
-                type: 'any',
-                required: !element.getInitializer(),
-            });
-        }
+        for (const element of nameNode.getElements())
+            visit(element);
+    });
+}
+function extractFallbackPropsFromFrontmatter(frontmatter) {
+    const props = new Map();
+    forEachAstroPropsBinding(frontmatter, (element) => {
+        const propName = extractBindingPropName(element);
+        if (!propName)
+            return;
+        props.set(propName, {
+            name: propName,
+            type: 'any',
+            required: !element.getInitializer(),
+        });
     });
     return [...props.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -82,17 +90,7 @@ function mergeProps(...propGroups) {
     return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
 function extractPropsFromFrontmatter(frontmatter) {
-    const project = new Project({
-        compilerOptions: {
-            strict: false,
-            target: 99, // ESNext
-            module: 99, // ESNext
-            allowJs: true,
-        },
-        useInMemoryFileSystem: true,
-        skipAddingFilesFromTsConfig: true,
-    });
-    const sf = project.createSourceFile('__frontmatter__.ts', frontmatter);
+    const sf = createAstroFrontmatterProject().createSourceFile('__frontmatter__.ts', frontmatter);
     const props = [];
     // Find `interface Props` or `type Props = ...`
     const propsInterface = sf.getInterface('Props');
@@ -116,25 +114,17 @@ function extractPropsFromFrontmatter(frontmatter) {
     else if (propsTypeAlias) {
         const type = propsTypeAlias.getType();
         for (const property of type.getProperties()) {
-            const name = property.getName();
-            const decl = property.getValueDeclaration() ?? property.getDeclarations()[0];
-            if (!decl)
+            const resolved = resolveTypeProperty(property);
+            if (!resolved)
                 continue;
-            const propType = property.getTypeAtLocation(decl);
-            const typeText = propType.getText(decl);
-            const required = !property.isOptional();
+            const { name, declaration: decl, typeText, required } = resolved;
             const allowedValues = extractAllowedValues(typeText);
             props.push({
                 name,
                 type: typeText,
                 required,
                 ...(allowedValues && { allowedValues }),
-                ...(typeof decl.getStartLineNumber === 'function'
-                    ? {
-                        sourceStartLine: decl.getStartLineNumber(),
-                        sourceEndLine: decl.getEndLineNumber(),
-                    }
-                    : {}),
+                ...getSourceLineMetadata(decl),
             });
         }
     }
@@ -142,38 +132,15 @@ function extractPropsFromFrontmatter(frontmatter) {
 }
 function extractDefaultsFromFrontmatter(frontmatter) {
     const defaults = new Map();
-    const project = new Project({
-        compilerOptions: {
-            strict: false,
-            target: 99,
-            module: 99,
-            allowJs: true,
-        },
-        useInMemoryFileSystem: true,
-        skipAddingFilesFromTsConfig: true,
-    });
-    const sf = project.createSourceFile('__frontmatter__.ts', frontmatter);
-    sf.forEachDescendant((node) => {
-        if (!Node.isVariableDeclaration(node))
-            return;
-        const initializer = node.getInitializer();
-        if (!initializer)
+    forEachAstroPropsBinding(frontmatter, (element) => {
+        const propName = extractBindingPropName(element);
+        if (!propName)
             return;
-        if (!usesAstroProps(initializer))
+        const elementInitializer = element.getInitializer();
+        if (!elementInitializer)
             return;
-        const nameNode = node.getNameNode();
-        if (!Node.isObjectBindingPattern(nameNode))
-            return;
-        for (const element of nameNode.getElements()) {
-            const propName = extractBindingPropName(element);
-            if (!propName)
-                continue;
-            const elementInitializer = element.getInitializer();
-            if (!elementInitializer)
-                continue;
-            const value = elementInitializer.getText().replace(/^['"]|['"]$/g, '');
-            defaults.set(propName, value);
-        }
+        const value = elementInitializer.getText().replace(/^['"]|['"]$/g, '');
+        defaults.set(propName, value);
     });
     return defaults;
 }
@@ -253,37 +220,8 @@ function extractFromAstroFile(filePath, source) {
 const ASTRO_EXTRACT_CONCURRENCY = Number(process.env['EDS_EXTRACT_CONCURRENCY'] ?? 0) || os.cpus().length;
 export async function extractAstroComponents(filePaths, onProgress) {
     const astroFiles = filePaths.filter((f) => f.endsWith('.astro'));
-    if (astroFiles.length === 0) {
-        return { components: [], warnings: [] };
-    }
-    const warnings = [];
-    const components = [];
-    let filesProcessed = 0;
-    let componentsFound = 0;
-    const queue = [...astroFiles];
-    async function worker() {
-        while (queue.length > 0) {
-            const filePath = queue.shift();
-            if (!filePath)
-                break;
-            try {
-                const source = await readFile(filePath, 'utf-8');
-                const component = extractFromAstroFile(filePath, source);
-                if (component) {
-                    components.push(component);
-                    componentsFound++;
-                }
-            }
-            catch (e) {
-                warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
-            }
-            filesProcessed++;
-            onProgress?.({ filesProcessed, componentsFound });
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(ASTRO_EXTRACT_CONCURRENCY, astroFiles.length) }, worker));
-    return {
-        components: components.sort((a, b) => a.name.localeCompare(b.name)),
-        warnings,
-    };
+    const { items: components, warnings } = await runFileExtractionWorkers(astroFiles, ASTRO_EXTRACT_CONCURRENCY, async (filePath, source) => ({
+        item: extractFromAstroFile(filePath, source),
+    }), (filePath, error) => `Failed to extract from ${filePath}: ${error instanceof Error ? error.message : String(error)}`, onProgress);
+    return createSortedExtractionResult(components, warnings);
 }

package/dist/src/extract/file-extraction-workers.d.ts

@@ -0,0 +1,25 @@
+import type { Project, SourceFile } from 'ts-morph';
+export type FileExtractionOutcome<T, M = undefined> = {
+    item: T | null;
+    warnings?: string[];
+    metadata?: M;
+};
+type FileExtractionProgress = {
+    filesProcessed: number;
+    componentsFound: number;
+};
+export declare function runFileExtractionWorkers<T, M = undefined>(filePaths: string[], concurrency: number, extractFile: (filePath: string, source: string) => Promise<FileExtractionOutcome<T, M>>, formatError: (filePath: string, error: unknown) => string, onProgress?: (progress: FileExtractionProgress) => void, onResult?: (filePath: string, outcome: FileExtractionOutcome<T, M>) => void): Promise<{
+    items: T[];
+    warnings: string[];
+}>;
+export declare function createSortedExtractionResult<T extends {
+    name: string;
+}>(components: T[], warnings: string[]): {
+    components: T[];
+    warnings: string[];
+};
+export declare function extractProjectSourceFiles<T>(project: Project, extractFile: (sourceFile: SourceFile, warnings: string[]) => T[]): {
+    items: T[];
+    warnings: string[];
+};
+export {};

package/dist/src/extract/file-extraction-workers.js

@@ -0,0 +1,48 @@
+import { readFile } from 'node:fs/promises';
+export async function runFileExtractionWorkers(filePaths, concurrency, extractFile, formatError, onProgress, onResult) {
+    const warnings = [];
+    const items = [];
+    let filesProcessed = 0;
+    const queue = [...filePaths];
+    async function worker() {
+        while (queue.length > 0) {
+            const filePath = queue.shift();
+            if (!filePath)
+                break;
+            try {
+                const source = await readFile(filePath, 'utf-8');
+                const outcome = await extractFile(filePath, source);
+                warnings.push(...(outcome.warnings ?? []));
+                if (outcome.item)
+                    items.push(outcome.item);
+                onResult?.(filePath, outcome);
+            }
+            catch (error) {
+                warnings.push(formatError(filePath, error));
+            }
+            filesProcessed++;
+            onProgress?.({ filesProcessed, componentsFound: items.length });
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, filePaths.length) }, worker));
+    return { items, warnings };
+}
+export function createSortedExtractionResult(components, warnings) {
+    return {
+        components: components.sort((a, b) => a.name.localeCompare(b.name)),
+        warnings,
+    };
+}
+export function extractProjectSourceFiles(project, extractFile) {
+    const warnings = [];
+    const items = [];
+    for (const sourceFile of project.getSourceFiles()) {
+        try {
+            items.push(...extractFile(sourceFile, warnings));
+        }
+        catch (error) {
+            warnings.push(`Failed to extract from ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { items, warnings };
+}

package/dist/src/extract/non-authorable-filter.d.ts

@@ -1,5 +1,5 @@
 import type { RawComponentDefinition } from '../types.js';
-export interface NonAuthorableResult {
+interface NonAuthorableResult {
     skip: boolean;
     reason?: string;
 }
@@ -14,3 +14,4 @@ export interface NonAuthorableResult {
  * other repos.
  */
 export declare function isNonAuthorableComponent(component: RawComponentDefinition): NonAuthorableResult;
+export {};

package/dist/src/extract/parse-imported-names.d.ts

@@ -0,0 +1 @@
+export declare function parseImportedNames(importClause: string): string[];

package/dist/src/extract/parse-imported-names.js

@@ -0,0 +1,27 @@
+export function parseImportedNames(importClause) {
+    const trimmed = importClause.trim();
+    if (!trimmed)
+        return [];
+    const names = [];
+    const defaultAndNamed = trimmed.split(',').map((part) => part.trim());
+    for (const part of defaultAndNamed) {
+        if (!part)
+            continue;
+        if (part.startsWith('{') && part.endsWith('}')) {
+            for (const named of part
+                .slice(1, -1)
+                .split(',')
+                .map((item) => item.trim())
+                .filter(Boolean)) {
+                const [local] = named.split(/\s+as\s+/i);
+                if (local)
+                    names.push(local.trim());
+            }
+            continue;
+        }
+        const [local] = part.split(/\s+as\s+/i);
+        if (local)
+            names.push(local.trim());
+    }
+    return names;
+}

package/dist/src/extract/pipeline.d.ts

@@ -1,6 +1,7 @@
 import type { ComponentExtractionResult, ExtractorOptions } from '../types.js';
-export type ExtractProgress = {
+type ExtractProgress = {
     filesProcessed: number;
     componentsFound: number;
 };
 export declare function extractComponents(filePaths: string[], onProgress?: (progress: ExtractProgress) => void, opts?: ExtractorOptions): Promise<ComponentExtractionResult>;
+export {};