@contentful/experience-design-system-extraction 2.36.2-dev-build-a6f80ae6.0 → 2.36.2-dev-build-450d231a.0

package/dist/src/extract/non-authorable-filter.js

@@ -1,60 +0,0 @@
-const HANDLER_TYPE_PATTERN = /=>|EventHandler|Dispatch<|SetStateAction/;
-const REF_TYPE_PATTERN = /Ref<|RefObject<|MutableRefObject/;
-function isHandlerOrRefProp(prop) {
-    if (HANDLER_TYPE_PATTERN.test(prop.type))
-        return true;
-    if (REF_TYPE_PATTERN.test(prop.type))
-        return true;
-    if (/^on[A-Z]/.test(prop.name) || /^set[A-Z]/.test(prop.name))
-        return true;
-    if (prop.name === 'ref' || prop.name === 'innerRef')
-        return true;
-    return false;
-}
-/**
- * Decides whether a component is non-authorable infrastructure (Context.Provider,
- * analytics shim, layout-only utility, etc.) and should be filtered out of the
- * analyze TUI before authoring-token generation.
- *
- * Uses prop-shape signals only — no component-name or source-path patterns.
- * A design system can live anywhere under any naming convention; relying on
- * suffixes like `*Provider` or paths like `src/lib/` would silently fail in
- * other repos.
- */
-export function isNonAuthorableComponent(component) {
-    const { props, slots, usesCreateContext } = component;
-    // R1: zero props AND zero slots — nothing for an editor to author.
-    // Catches analytics scripts, GTM tags, layout fixers, security tokens, etc.
-    if (props.length === 0 && slots.length === 0) {
-        return { skip: true, reason: 'component has no props and no slots' };
-    }
-    // R2: createContext source + prop literally named `value` — canonical
-    // `<Context.Provider value={...}>` call site.
-    if (usesCreateContext && props.some((p) => p.name === 'value')) {
-        return {
-            skip: true,
-            reason: 'source uses createContext and component exposes a Context.Provider value prop',
-        };
-    }
-    // R3: createContext source + zero props — Provider wrapper that hard-codes
-    // the context value internally (e.g. FontProvider, BottomSheetProvider).
-    if (usesCreateContext && props.length === 0) {
-        return { skip: true, reason: 'source uses createContext and component has no props' };
-    }
-    // R4: createContext source + exactly one non-handler prop — Provider that
-    // takes the context value as its sole data prop, named after the data
-    // (e.g. `LocaleProvider({ locale })`, `NavigationProvider({ navItems })`).
-    if (usesCreateContext && props.length === 1 && !isHandlerOrRefProp(props[0])) {
-        return {
-            skip: true,
-            reason: 'source uses createContext and component has a single non-handler prop',
-        };
-    }
-    // R5: every prop is a handler/ref — pure data plumbing, no authoring surface.
-    // Catches components like `OsanoCookiePlaceholder({ onBannerLoaded })` or
-    // `FeedbackCard({ setShowModal })`.
-    if (props.length > 0 && props.every(isHandlerOrRefProp)) {
-        return { skip: true, reason: 'every prop is a handler or ref' };
-    }
-    return { skip: false };
-}

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

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

package/dist/src/extract/pipeline.js

@@ -1,343 +0,0 @@
-import { extractStencilComponents } from './stencil.js';
-import { extractReactComponents } from './react.js';
-import { extractVueTsxComponents } from './vue-tsx.js';
-import { extractVueComponents } from './vue.js';
-import { extractAstroComponents } from './astro.js';
-import { extractWebComponentDefinitions } from './web-components.js';
-import { extractSvelteComponents } from './svelte.js';
-const extractors = [
-    {
-        name: 'stencil',
-        fileFilter: (f) => /\.[jt]sx$/.test(f),
-        extract: extractStencilComponents,
-    },
-    {
-        name: 'react',
-        fileFilter: (f) => /\.[jt]sx?$/.test(f) && !f.endsWith('.d.ts'),
-        extract: extractReactComponents,
-    },
-    {
-        name: 'vue-tsx',
-        fileFilter: (f) => /\.[jt]sx?$/.test(f) && !f.endsWith('.d.ts'),
-        extract: extractVueTsxComponents,
-    },
-    {
-        name: 'vue',
-        fileFilter: (f) => f.endsWith('.vue'),
-        extract: extractVueComponents,
-    },
-    {
-        name: 'astro',
-        fileFilter: (f) => f.endsWith('.astro'),
-        extract: extractAstroComponents,
-    },
-    {
-        name: 'web-components',
-        fileFilter: (f) => /\.[jt]s$/.test(f) && !/\.[jt]sx$/.test(f) && !f.endsWith('.d.ts'),
-        extract: extractWebComponentDefinitions,
-    },
-    {
-        name: 'svelte',
-        fileFilter: (f) => {
-            if (!f.endsWith('.svelte'))
-                return false;
-            // SvelteKit route conventions: +page.svelte, +layout.svelte, +error.svelte
-            // are framework-managed entrypoints, not authorable design-system components.
-            // Mirrors how Next.js page.tsx / layout.tsx are filtered in pre-classify.
-            const filename = f.replace(/\\/g, '/').split('/').pop() ?? '';
-            if (/^\+(page|layout|error)\.svelte$/.test(filename))
-                return false;
-            return true;
-        },
-        extract: extractSvelteComponents,
-    },
-];
-function getPathPreferenceScore(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const segments = normalized.split('/').filter(Boolean);
-    const filename = segments.at(-1) ?? '';
-    const basename = filename.replace(/\.[^.]+$/, '');
-    let score = 0;
-    if (/^index\.[jt]sx?$/.test(filename))
-        score += 100;
-    if (basename && segments.at(-2) === basename)
-        score -= 10;
-    const componentsSegmentCount = segments.filter((segment) => segment === 'components').length;
-    score -= componentsSegmentCount * 8;
-    score -= segments.length;
-    return score;
-}
-function getPackageRootInfo(segments) {
-    for (let index = 0; index < segments.length; index += 1) {
-        const segment = segments[index];
-        if ((segment === '.packages' || segment === 'packages') && segments[index + 1]) {
-            return {
-                rootSegments: segments.slice(0, index + 2),
-                relativeSegments: segments.slice(index + 2),
-            };
-        }
-    }
-    const srcIndex = segments.lastIndexOf('src');
-    if (srcIndex >= 0) {
-        return {
-            rootSegments: segments.slice(0, srcIndex),
-            relativeSegments: segments.slice(srcIndex),
-        };
-    }
-    return null;
-}
-function getScopeInfo(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const segments = normalized.split('/').filter(Boolean);
-    const rootInfo = getPackageRootInfo(segments);
-    if (!rootInfo) {
-        return null;
-    }
-    const { rootSegments, relativeSegments } = rootInfo;
-    return {
-        rootKey: rootSegments.join('/'),
-        relativeSegments,
-    };
-}
-function getTopLevelFamilyName(relativeSegments) {
-    const [first, second, third] = relativeSegments;
-    if (relativeSegments.length === 1 && first) {
-        return first.replace(/\.[^.]+$/, '');
-    }
-    if (first === 'src' && second === 'components' && third) {
-        const fileSegment = relativeSegments[3];
-        if (fileSegment &&
-            (fileSegment === `${third}.tsx` ||
-                fileSegment === `${third}.ts` ||
-                fileSegment === 'index.tsx' ||
-                fileSegment === 'index.ts')) {
-            return third;
-        }
-        return null;
-    }
-    if (first === 'src' && second) {
-        const fileSegment = relativeSegments[2];
-        if (fileSegment &&
-            (fileSegment === `${second}.vue` ||
-                fileSegment === `${second}.tsx` ||
-                fileSegment === `${second}.ts` ||
-                fileSegment === 'index.tsx' ||
-                fileSegment === 'index.ts' ||
-                fileSegment === 'index.vue')) {
-            return second;
-        }
-        return null;
-    }
-    if (first) {
-        const fileSegment = relativeSegments[1];
-        if (fileSegment === `${first}.tsx` ||
-            fileSegment === `${first}.ts` ||
-            fileSegment === `${first}.vue` ||
-            fileSegment === 'index.tsx' ||
-            fileSegment === 'index.ts' ||
-            fileSegment === 'index.vue') {
-            return first;
-        }
-    }
-    return null;
-}
-function isWithinTopLevelFamily(relativeSegments, componentName) {
-    const [first, second, third] = relativeSegments;
-    const componentFilenames = new Set([
-        `${componentName}.tsx`,
-        `${componentName}.ts`,
-        `${componentName}.vue`,
-        'index.tsx',
-        'index.ts',
-        'index.vue',
-    ]);
-    if (relativeSegments.length === 1) {
-        return new Set([`${componentName}.tsx`, `${componentName}.ts`, `${componentName}.vue`]).has(first);
-    }
-    if (first === 'src' && second === 'components' && third === componentName) {
-        return true;
-    }
-    if (first === 'components' && second === componentName) {
-        return true;
-    }
-    if (first === 'src' && second === componentName) {
-        return true;
-    }
-    if (first === componentName) {
-        return componentFilenames.has(second) || relativeSegments.length > 2;
-    }
-    return false;
-}
-function getFamilyScopeKey(filePath, componentName, topLevelFamiliesByRoot) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const scopeInfo = getScopeInfo(filePath);
-    if (!scopeInfo) {
-        return normalized;
-    }
-    const { rootKey, relativeSegments } = scopeInfo;
-    const topLevelFamilies = topLevelFamiliesByRoot.get(rootKey);
-    if (topLevelFamilies?.has(componentName) && isWithinTopLevelFamily(relativeSegments, componentName)) {
-        return `${rootKey}::${componentName}`;
-    }
-    const [first, second, third] = relativeSegments;
-    if (first === 'src' && second === 'components' && third) {
-        return `${rootKey}/src/components/${third}`;
-    }
-    if (first === 'components' && second) {
-        return `${rootKey}/components/${second}`;
-    }
-    if (first === 'src' && second && relativeSegments.length > 2) {
-        return `${rootKey}/src/${second}`;
-    }
-    if (first && relativeSegments.length > 1) {
-        return `${rootKey}/${first}`;
-    }
-    return rootKey;
-}
-function choosePreferredComponent(existing, candidate) {
-    const existingScore = getPathPreferenceScore(existing.source);
-    const candidateScore = getPathPreferenceScore(candidate.source);
-    if (candidateScore > existingScore) {
-        return {
-            winner: candidate,
-            loser: existing,
-            reason: `preferred ${candidate.source} over ${existing.source} based on path heuristics`,
-        };
-    }
-    if (candidateScore < existingScore) {
-        return {
-            winner: existing,
-            loser: candidate,
-            reason: `kept ${existing.source} over ${candidate.source} based on path heuristics`,
-        };
-    }
-    if (candidate.source.length < existing.source.length) {
-        return {
-            winner: candidate,
-            loser: existing,
-            reason: `preferred shorter path ${candidate.source} over ${existing.source}`,
-        };
-    }
-    return {
-        winner: existing,
-        loser: candidate,
-        reason: `kept ${existing.source} over ${candidate.source} by stable first-seen order`,
-    };
-}
-export async function extractComponents(filePaths, onProgress, opts) {
-    const filesByExtractor = new Map();
-    const exclusions = [];
-    for (const extractor of extractors) {
-        filesByExtractor.set(extractor, []);
-    }
-    for (const filePath of filePaths) {
-        for (const extractor of extractors) {
-            if (extractor.fileFilter(filePath)) {
-                filesByExtractor.get(extractor).push(filePath);
-            }
-            else if (extractor.name === 'svelte' && filePath.endsWith('.svelte')) {
-                const filename = filePath.replace(/\\/g, '/').split('/').pop() ?? '';
-                if (/^\+(page|layout|error)\.svelte$/.test(filename)) {
-                    exclusions.push({
-                        itemType: 'file',
-                        name: filename,
-                        source: filePath,
-                        reason: 'SvelteKit route entrypoints are framework-managed, not authorable components',
-                        stage: 'file-filter',
-                    });
-                }
-            }
-        }
-    }
-    const perExtractorFiles = new Map();
-    const perExtractorComponents = new Map();
-    let totalFilesProcessed = 0;
-    let totalComponentsFound = 0;
-    const results = await Promise.all(extractors.map(async (extractor) => {
-        const files = filesByExtractor.get(extractor);
-        if (files.length === 0)
-            return { components: [], warnings: [] };
-        perExtractorFiles.set(extractor, 0);
-        perExtractorComponents.set(extractor, 0);
-        const result = await extractor.extract(files, (p) => {
-            const prevFiles = perExtractorFiles.get(extractor) ?? 0;
-            const prevComponents = perExtractorComponents.get(extractor) ?? 0;
-            totalFilesProcessed += p.filesProcessed - prevFiles;
-            totalComponentsFound += p.componentsFound - prevComponents;
-            perExtractorFiles.set(extractor, p.filesProcessed);
-            perExtractorComponents.set(extractor, p.componentsFound);
-            onProgress?.({ filesProcessed: totalFilesProcessed, componentsFound: totalComponentsFound });
-        }, opts);
-        return result;
-    }));
-    const allWarnings = [];
-    const componentsByKey = new Map();
-    const keysByName = new Map();
-    const topLevelFamiliesByRoot = new Map();
-    for (const result of results) {
-        for (const component of result.components) {
-            const scopeInfo = getScopeInfo(component.source);
-            if (!scopeInfo)
-                continue;
-            const familyName = getTopLevelFamilyName(scopeInfo.relativeSegments);
-            if (!familyName)
-                continue;
-            const existingFamilies = topLevelFamiliesByRoot.get(scopeInfo.rootKey) ?? new Set();
-            existingFamilies.add(familyName);
-            topLevelFamiliesByRoot.set(scopeInfo.rootKey, existingFamilies);
-        }
-    }
-    for (const result of results) {
-        allWarnings.push(...result.warnings);
-        exclusions.push(...(result.exclusions ?? []));
-        for (const component of result.components) {
-            const scopeKey = getFamilyScopeKey(component.source, component.name, topLevelFamiliesByRoot);
-            const identityKey = `${component.name}::${scopeKey}`;
-            const existing = componentsByKey.get(identityKey);
-            if (existing) {
-                const selected = choosePreferredComponent(existing, component);
-                allWarnings.push(`Duplicate component "${component.name}" found in ${component.source} (already seen in ${existing.source}); ${selected.reason}`);
-                exclusions.push({
-                    itemType: 'component',
-                    name: selected.loser.name,
-                    source: selected.loser.source,
-                    reason: `duplicate identity; ${selected.reason}`,
-                    stage: 'duplicate-filter',
-                });
-                componentsByKey.set(identityKey, selected.winner);
-                continue;
-            }
-            const existingKeys = keysByName.get(component.name) ?? [];
-            const crossPackageKey = existingKeys.find((key) => key !== identityKey);
-            if (crossPackageKey) {
-                const crossPackageComponent = componentsByKey.get(crossPackageKey);
-                if (crossPackageComponent) {
-                    allWarnings.push(`Component name collision "${component.name}" found in ${component.source} (also seen in ${crossPackageComponent.source})`);
-                }
-            }
-            componentsByKey.set(identityKey, component);
-            keysByName.set(component.name, [...existingKeys, identityKey]);
-        }
-    }
-    const allComponents = [...componentsByKey.values()];
-    const filteredComponents = [];
-    for (const component of allComponents) {
-        if (/^use[A-Z]/.test(component.name)) {
-            allWarnings.push(`Skipped hook: ${component.name} (hooks are not renderable components)`);
-            exclusions.push({
-                itemType: 'component',
-                name: component.name,
-                source: component.source,
-                reason: 'Hook names are not renderable components',
-                stage: 'component-filter',
-            });
-            continue;
-        }
-        filteredComponents.push(component);
-    }
-    return {
-        components: filteredComponents.sort((a, b) => a.name.localeCompare(b.name)),
-        warnings: allWarnings,
-        exclusions,
-    };
-}