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

package/dist/src/extract/orchestrator/execute-extraction-orchestrator.js

@@ -1,17 +0,0 @@
-import { extractComponents } from '../services/extraction/extract-components.js';
-import { preClassifyComponent } from '../services/classification/classify-component-props.js';
-import { evaluateExtractionQuality } from '../services/quality/evaluate-extraction-quality.js';
-/**
- * Executes the extraction use case after the controller has validated the
- * public request. Owns extraction-time classification, inspection,
- * quality signals, scoring, and validation, but not transport or persistence.
- */
-export async function executeExtractionOrchestrator(request) {
-    const filePaths = [...request.filePaths];
-    const extraction = await extractComponents(filePaths, request.onProgress, {
-        ...(request.resolveUnreachable !== undefined ? { resolveUnreachable: request.resolveUnreachable } : {}),
-        ...(request.projectRoot !== undefined ? { projectRoot: request.projectRoot } : {}),
-    });
-    const classifiedComponents = extraction.components.map(preClassifyComponent);
-    return evaluateExtractionQuality(classifiedComponents, extraction.warnings);
-}

package/dist/src/extract/services/classification/helpers/check-prop-types.d.ts

@@ -1,7 +0,0 @@
-/** Primitive-type predicates used by the classification rule engine. */
-export declare function isStringLiteralUnion(type: string): boolean;
-export declare function isSimpleType(type: string): boolean;
-export declare function isBooleanType(type: string): boolean;
-export declare function isStringType(type: string): boolean;
-export declare function isNumberType(type: string): boolean;
-export declare function isComplexType(type: string): boolean;

package/dist/src/extract/services/classification/helpers/check-prop-types.js

@@ -1,22 +0,0 @@
-/** Primitive-type predicates used by the classification rule engine. */
-export function isStringLiteralUnion(type) {
-    return type.includes('|') && type.includes("'");
-}
-export function isSimpleType(type) {
-    const t = type.trim();
-    if (t === 'string' || t === 'boolean' || t === 'number')
-        return true;
-    return isStringLiteralUnion(t);
-}
-export function isBooleanType(type) {
-    return type.trim() === 'boolean';
-}
-export function isStringType(type) {
-    return type.trim() === 'string';
-}
-export function isNumberType(type) {
-    return type.trim() === 'number';
-}
-export function isComplexType(type) {
-    return !isSimpleType(type);
-}

package/dist/src/extract/services/classification/helpers/detect-dom-props.d.ts

@@ -1,2 +0,0 @@
-/** Returns true when the prop name is a DOM attribute, a11y attribute, or framework pass-through escape hatch. */
-export declare function isDomPassThroughProp(name: string): boolean;

package/dist/src/extract/services/classification/helpers/detect-dom-props.js

@@ -1,63 +0,0 @@
-const DOM_PASS_THROUGH_PROPS = new Set([
-    // Bare HTML / framework styling pass-through
-    'className',
-    'class',
-    'classes',
-    'classNames',
-    'rootClassName',
-    'prefixCls',
-    'style',
-    'styles',
-    // Bare HTML attributes
-    'id',
-    'role',
-    'tabIndex',
-    'tabindex',
-    'htmlFor',
-    'for',
-    'slot',
-    'is',
-    'lang',
-    'dir',
-    'hidden',
-    'draggable',
-    'spellCheck',
-    'spellcheck',
-    'contentEditable',
-    'contenteditable',
-    'inputMode',
-    'inputmode',
-    'autoComplete',
-    'autocomplete',
-    'autoFocus',
-    'autofocus',
-    'translate',
-    'part',
-    'exportparts',
-    'aria',
-    // Framework theming / pass-through escape hatches — dev-facing, never marketer-configurable
-    'dt',
-    'pt',
-    'ptOptions',
-    'unstyled',
-    'sx',
-    // Polymorphic component props — change rendered HTML/component, not marketer-visible behavior
-    'as',
-    'element',
-    'component',
-    // QA / vendor test attributes
-    'dataQa',
-    'data-qa',
-    // Vue v-model internals — framework wiring, never marketer-configurable
-    'modelValue',
-    'modelModifiers',
-]);
-/** Returns true when the prop name is a DOM attribute, a11y attribute, or framework pass-through escape hatch. */
-export function isDomPassThroughProp(name) {
-    if (DOM_PASS_THROUGH_PROPS.has(name))
-        return true;
-    // aria-label, aria-hidden, ariaLabel, ariaHidden — both kebab and camel forms
-    if (/^aria[-A-Z]/.test(name))
-        return true;
-    return name.startsWith('data-');
-}

package/dist/src/extract/services/deduplication/deduplicate-components.d.ts

@@ -1,2 +0,0 @@
-import type { ComponentExtractionResult } from '../../types/component.js';
-export declare function deduplicateComponents(results: readonly ComponentExtractionResult[]): ComponentExtractionResult;

package/dist/src/extract/services/deduplication/deduplicate-components.js

@@ -1,58 +0,0 @@
-import { resolveComponentScopeInfo, resolveTopLevelFamilyName, resolveDeduplicationScopeKey, selectPreferredComponentSource, } from './helpers/component-path-scoring.js';
-export function deduplicateComponents(results) {
-    const allWarnings = [];
-    const exclusions = [];
-    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 = resolveComponentScopeInfo(component.source);
-            if (!scopeInfo)
-                continue;
-            const familyName = resolveTopLevelFamilyName(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 = resolveDeduplicationScopeKey(component.source, component.name, topLevelFamiliesByRoot);
-            const identityKey = `${component.name}::${scopeKey}`;
-            const existing = componentsByKey.get(identityKey);
-            if (existing) {
-                const selected = selectPreferredComponentSource(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]);
-        }
-    }
-    return {
-        components: [...componentsByKey.values()].sort((a, b) => a.name.localeCompare(b.name)),
-        warnings: allWarnings,
-        exclusions,
-    };
-}

package/dist/src/extract/services/deduplication/helpers/component-path-analysis.d.ts

@@ -1,10 +0,0 @@
-export declare function scoreComponentSourcePath(filePath: string): number;
-export declare function resolvePackageRootInfo(segments: string[]): {
-    rootSegments: string[];
-    relativeSegments: string[];
-} | null;
-export declare function resolveComponentScopeInfo(filePath: string): {
-    rootKey: string;
-    relativeSegments: string[];
-} | null;
-export declare function resolveTopLevelFamilyName(relativeSegments: string[]): string | null;

package/dist/src/extract/services/deduplication/helpers/component-path-analysis.js

@@ -1,85 +0,0 @@
-export function scoreComponentSourcePath(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;
-    score -= segments.filter((segment) => segment === 'components').length * 8;
-    score -= segments.length;
-    return score;
-}
-export function resolvePackageRootInfo(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;
-}
-export function resolveComponentScopeInfo(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const segments = normalized.split('/').filter(Boolean);
-    const rootInfo = resolvePackageRootInfo(segments);
-    if (!rootInfo)
-        return null;
-    return {
-        rootKey: rootInfo.rootSegments.join('/'),
-        relativeSegments: rootInfo.relativeSegments,
-    };
-}
-export function resolveTopLevelFamilyName(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;
-}

package/dist/src/extract/services/deduplication/helpers/component-path-scoring.d.ts

@@ -1,10 +0,0 @@
-import type { RawComponentDefinition } from '../../../types/component.js';
-import { scoreComponentSourcePath, resolvePackageRootInfo, resolveComponentScopeInfo, resolveTopLevelFamilyName } from './component-path-analysis.js';
-export { scoreComponentSourcePath, resolvePackageRootInfo, resolveComponentScopeInfo, resolveTopLevelFamilyName };
-export declare function isWithinComponentFamily(relativeSegments: string[], componentName: string): boolean;
-export declare function resolveDeduplicationScopeKey(filePath: string, componentName: string, topLevelFamiliesByRoot: Map<string, Set<string>>): string;
-export declare function selectPreferredComponentSource(existing: RawComponentDefinition, candidate: RawComponentDefinition): {
-    winner: RawComponentDefinition;
-    loser: RawComponentDefinition;
-    reason: string;
-};

package/dist/src/extract/services/deduplication/helpers/component-path-scoring.js

@@ -1,73 +0,0 @@
-import { scoreComponentSourcePath, resolvePackageRootInfo, resolveComponentScopeInfo, resolveTopLevelFamilyName, } from './component-path-analysis.js';
-export { scoreComponentSourcePath, resolvePackageRootInfo, resolveComponentScopeInfo, resolveTopLevelFamilyName };
-export function isWithinComponentFamily(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;
-}
-export function resolveDeduplicationScopeKey(filePath, componentName, topLevelFamiliesByRoot) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const scopeInfo = resolveComponentScopeInfo(filePath);
-    if (!scopeInfo)
-        return normalized;
-    const { rootKey, relativeSegments } = scopeInfo;
-    const topLevelFamilies = topLevelFamiliesByRoot.get(rootKey);
-    if (topLevelFamilies?.has(componentName) && isWithinComponentFamily(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;
-}
-export function selectPreferredComponentSource(existing, candidate) {
-    const existingScore = scoreComponentSourcePath(existing.source);
-    const candidateScore = scoreComponentSourcePath(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`,
-    };
-}

package/dist/src/extract/services/extraction/extract-components.d.ts

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

package/dist/src/extract/services/extraction/extract-components.js

@@ -1,19 +0,0 @@
-import { deduplicateComponents } from '../deduplication/deduplicate-components.js';
-import { extractorRegistry, routeFilesToExtractors } from './helpers/register-extractors.js';
-import { runExtractorBatches } from './helpers/run-extractor-batches.js';
-import { collectSvelteKitRouteExclusions } from './helpers/collect-sveltekit-route-exclusions.js';
-import { filterHookComponents } from './helpers/filter-hook-components.js';
-export async function extractComponents(filePaths, onProgress, opts) {
-    const routeExclusions = collectSvelteKitRouteExclusions(filePaths);
-    const routedFiles = routeFilesToExtractors(filePaths, extractorRegistry);
-    const results = await runExtractorBatches(routedFiles, onProgress, opts);
-    const deduplicated = deduplicateComponents(results);
-    const { components, exclusions: hookExclusions, warnings: hookWarnings, } = filterHookComponents(deduplicated.components);
-    deduplicated.warnings.push(...hookWarnings);
-    const allExclusions = [...routeExclusions, ...hookExclusions, ...(deduplicated.exclusions ?? [])];
-    return {
-        components,
-        warnings: deduplicated.warnings,
-        ...(allExclusions.length > 0 ? { exclusions: allExclusions } : {}),
-    };
-}

package/dist/src/extract/services/extraction/helpers/collect-sveltekit-route-exclusions.d.ts

@@ -1,2 +0,0 @@
-import type { ExtractionExclusion } from '../../../types/component.js';
-export declare function collectSvelteKitRouteExclusions(filePaths: string[]): ExtractionExclusion[];

package/dist/src/extract/services/extraction/helpers/collect-sveltekit-route-exclusions.js

@@ -1,18 +0,0 @@
-export function collectSvelteKitRouteExclusions(filePaths) {
-    return filePaths.flatMap((filePath) => {
-        if (!filePath.endsWith('.svelte'))
-            return [];
-        const name = filePath.replace(/\\/g, '/').split('/').pop() ?? '';
-        if (!/^\+(page|layout|error)\.svelte$/.test(name))
-            return [];
-        return [
-            {
-                itemType: 'file',
-                name,
-                source: filePath,
-                reason: 'SvelteKit route entrypoints are framework-managed, not authorable components',
-                stage: 'file-filter',
-            },
-        ];
-    });
-}

package/dist/src/extract/services/extraction/helpers/filter-hook-components.d.ts

@@ -1,6 +0,0 @@
-import type { ExtractionExclusion, RawComponentDefinition } from '../../../types/component.js';
-export declare function filterHookComponents(components: RawComponentDefinition[]): {
-    components: RawComponentDefinition[];
-    exclusions: ExtractionExclusion[];
-    warnings: string[];
-};

package/dist/src/extract/services/extraction/helpers/filter-hook-components.js

@@ -1,18 +0,0 @@
-export function filterHookComponents(components) {
-    const exclusions = [];
-    const warnings = [];
-    const kept = components.filter((component) => {
-        if (!/^use[A-Z]/.test(component.name))
-            return true;
-        warnings.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',
-        });
-        return false;
-    });
-    return { components: kept, exclusions, warnings };
-}

package/dist/src/extract/services/extraction/helpers/register-extractors.d.ts

@@ -1,8 +0,0 @@
-import type { ComponentExtractor } from '../../../types/component-extractor.js';
-export interface ExtractorFileGroup {
-    extractor: ComponentExtractor;
-    filePaths: string[];
-}
-/** Ordered adapter registration; overlapping filters intentionally allow a file to be inspected by multiple adapters. */
-export declare const extractorRegistry: readonly ComponentExtractor[];
-export declare function routeFilesToExtractors(filePaths: readonly string[], extractors?: readonly ComponentExtractor[]): ExtractorFileGroup[];

package/dist/src/extract/services/extraction/helpers/register-extractors.js

@@ -1,71 +0,0 @@
-import { extractAstroComponents } from '../../../framework-adapters/astro/extractor.js';
-import { extractReactComponents } from '../../../framework-adapters/react/extractor.js';
-import { extractStencilComponents } from '../../../framework-adapters/stencil/extractor.js';
-import { extractSvelteComponents } from '../../../framework-adapters/svelte/extractor.js';
-import { extractVueTsxComponents } from '../../../framework-adapters/vue-tsx/extractor.js';
-import { extractVueComponents } from '../../../framework-adapters/vue/extractor.js';
-import { extractWebComponentDefinitions } from '../../../framework-adapters/web-components/extractor.js';
-/** Ordered adapter registration; overlapping filters intentionally allow a file to be inspected by multiple adapters. */
-export const extractorRegistry = [
-    {
-        name: 'stencil',
-        fileFilter: (filePath) => /\.[jt]sx$/.test(filePath),
-        extract: extractStencilComponents,
-    },
-    {
-        name: 'react',
-        fileFilter: (filePath) => /\.[jt]sx?$/.test(filePath) && !filePath.endsWith('.d.ts'),
-        extract: extractReactComponents,
-    },
-    {
-        name: 'vue-tsx',
-        fileFilter: (filePath) => /\.[jt]sx?$/.test(filePath) && !filePath.endsWith('.d.ts'),
-        extract: extractVueTsxComponents,
-    },
-    {
-        name: 'vue',
-        fileFilter: (filePath) => filePath.endsWith('.vue'),
-        extract: extractVueComponents,
-    },
-    {
-        name: 'astro',
-        fileFilter: (filePath) => filePath.endsWith('.astro'),
-        extract: extractAstroComponents,
-    },
-    {
-        name: 'web-components',
-        fileFilter: (filePath) => /\.[jt]s$/.test(filePath) && !/\.[jt]sx$/.test(filePath) && !filePath.endsWith('.d.ts'),
-        extract: extractWebComponentDefinitions,
-    },
-    {
-        name: 'svelte',
-        fileFilter: (filePath) => {
-            if (!filePath.endsWith('.svelte'))
-                return false;
-            const filename = filePath.replace(/\\/g, '/').split('/').pop() ?? '';
-            if (/^\+(page|layout|error)\.svelte$/.test(filename))
-                return false;
-            return true;
-        },
-        extract: extractSvelteComponents,
-    },
-];
-export function routeFilesToExtractors(filePaths, extractors = extractorRegistry) {
-    const filesByExtractor = new Map();
-    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);
-            }
-        }
-    }
-    return extractors
-        .map((extractor) => ({
-        extractor,
-        filePaths: filesByExtractor.get(extractor) ?? [],
-    }))
-        .filter(({ filePaths: groupedFilePaths }) => groupedFilePaths.length > 0);
-}

package/dist/src/extract/services/extraction/helpers/run-extractor-batches.d.ts

@@ -1,4 +0,0 @@
-import type { ComponentExtractionResult, ExtractorProgress } from '../../../types/component.js';
-import type { ExtractorOptions } from '../../../types/options.js';
-import type { ExtractorFileGroup } from './register-extractors.js';
-export declare function runExtractorBatches(batches: readonly ExtractorFileGroup[], onProgress?: (progress: ExtractorProgress) => void, options?: ExtractorOptions): Promise<ComponentExtractionResult[]>;

package/dist/src/extract/services/extraction/helpers/run-extractor-batches.js

@@ -1,24 +0,0 @@
-export async function runExtractorBatches(batches, onProgress, options) {
-    const perExtractorFiles = new Map();
-    const perExtractorComponents = new Map();
-    let totalFilesProcessed = 0;
-    let totalComponentsFound = 0;
-    return Promise.all(batches.map(async ({ extractor, filePaths }) => {
-        if (filePaths.length === 0)
-            return { components: [], warnings: [] };
-        perExtractorFiles.set(extractor, 0);
-        perExtractorComponents.set(extractor, 0);
-        return extractor.extract(filePaths, (progress) => {
-            const previousFiles = perExtractorFiles.get(extractor) ?? 0;
-            const previousComponents = perExtractorComponents.get(extractor) ?? 0;
-            totalFilesProcessed += progress.filesProcessed - previousFiles;
-            totalComponentsFound += progress.componentsFound - previousComponents;
-            perExtractorFiles.set(extractor, progress.filesProcessed);
-            perExtractorComponents.set(extractor, progress.componentsFound);
-            onProgress?.({
-                filesProcessed: totalFilesProcessed,
-                componentsFound: totalComponentsFound,
-            });
-        }, options);
-    }));
-}

package/dist/src/extract/services/quality/evaluate-extraction-quality.d.ts

@@ -1,4 +0,0 @@
-import type { RawComponentDefinition } from '../../types/component.js';
-import type { ExtractionEndpointResponse } from '../../types/contract.js';
-/** Applies inspection, authorability, scoring, review, and validation policies to extracted models. */
-export declare function evaluateExtractionQuality(components: readonly RawComponentDefinition[], initialWarnings?: readonly string[]): Promise<ExtractionEndpointResponse>;

package/dist/src/extract/services/quality/evaluate-extraction-quality.js

@@ -1,61 +0,0 @@
-import { hasNoAuthoringSurface } from './helpers/authorability/evaluate-authorability.js';
-import { computeExtractionScore, deriveNeedsReview } from './helpers/scoring/compute-extraction-score.js';
-import { inspectComponentSource, describeReviewReasons } from './helpers/inspection/inspect-component-source.js';
-import { validateExtractedComponents } from './helpers/inspection/validate-extracted-components.js';
-function wrapperConfidenceToIssueCount(confidence) {
-    if (confidence >= 4)
-        return 2;
-    if (confidence === 3)
-        return 1;
-    return 0;
-}
-/** Applies inspection, authorability, scoring, review, and validation policies to extracted models. */
-export async function evaluateExtractionQuality(components, initialWarnings = []) {
-    const inspectedComponents = await Promise.all(components.map(async (component) => ({
-        component,
-        inspection: await inspectComponentSource(component),
-    })));
-    const scoredComponents = [];
-    const warnings = [...initialWarnings];
-    for (const { component, inspection } of inspectedComponents) {
-        const verdict = hasNoAuthoringSurface(component);
-        const keepDespiteZeroSurface = verdict.skip && verdict.reason === 'component has no props and no slots' && inspection.keepDespiteZeroSurface;
-        const retainedForReview = verdict.skip && !keepDespiteZeroSurface;
-        if (retainedForReview) {
-            warnings.push(`${component.name}: requires operator review (${verdict.reason})`);
-        }
-        if (keepDespiteZeroSurface) {
-            warnings.push(`${component.name}: retained despite 0 props/slots because the source renders visible or compositional UI`);
-        }
-        if (inspection.reviewReasons.length > 0) {
-            const reviewNotes = describeReviewReasons(inspection.reviewReasons)
-                .filter((note) => note !== 'high-confidence data-fetch wrapper')
-                .join('; ');
-            if (reviewNotes)
-                warnings.push(`${component.name}: ${reviewNotes}`);
-        }
-        const extractorReasons = component.reviewReasons ?? [];
-        const nonAuthorableReason = retainedForReview ? [`non-authorable:${verdict.reason}`] : [];
-        const { confidence, reasons } = computeExtractionScore(component, {
-            additionalIssueCount: wrapperConfidenceToIssueCount(inspection.wrapperConfidence) +
-                extractorReasons.length +
-                nonAuthorableReason.length,
-            additionalReasons: [...extractorReasons, ...inspection.reviewReasons, ...nonAuthorableReason],
-        });
-        scoredComponents.push({
-            ...component,
-            extractionConfidence: confidence,
-            reviewReasons: reasons,
-            needsReview: deriveNeedsReview(confidence) ||
-                inspection.wrapperConfidence >= 4 ||
-                inspection.keepDespiteZeroSurface ||
-                retainedForReview ||
-                extractorReasons.includes('props-type-unresolved') ||
-                (component.needsReview ?? false),
-        });
-    }
-    return {
-        components: validateExtractedComponents(scoredComponents),
-        warnings,
-    };
-}

package/dist/src/extract/services/quality/helpers/authorability/evaluate-authorability.d.ts

@@ -1,28 +0,0 @@
-import type { RawComponentDefinition, RawPropDefinition, RawSlotDefinition } from '../../../../types/component.js';
-export interface AuthoringSurfaceCheck {
-    skip: boolean;
-    reason?: string;
-}
-/** Returns true when the prop is an event-handler function or a React ref — not something a content editor configures. */
-export declare function isHandlerOrRefProp(prop: RawPropDefinition): boolean;
-/** Rule 1: no props AND no slots — analytics scripts, GTM tags, layout fixers, security tokens, etc. */
-export declare function hasNoPropsAndNoSlots(props: RawPropDefinition[], slots: RawSlotDefinition[]): boolean;
-/** Rule 2: createContext source with a prop literally named `value` — the canonical `<Context.Provider value={...}>` call site. */
-export declare function isContextProviderWithValueProp(props: RawPropDefinition[], usesCreateContext: boolean | undefined): boolean;
-/** Rule 3: createContext source with zero props — a Provider that hard-codes its context value internally (e.g. FontProvider). */
-export declare function isHardwiredContextProvider(props: RawPropDefinition[], usesCreateContext: boolean | undefined): boolean;
-/** Rule 4: createContext source with exactly one non-handler prop — a Provider that takes its context value as a single data prop (e.g. LocaleProvider, NavigationProvider). */
-export declare function isSingleDataPropContextWrapper(props: RawPropDefinition[], usesCreateContext: boolean | undefined): boolean;
-/** Rule 5: every prop is an event handler or ref — pure plumbing with no authoring surface (e.g. OsanoCookiePlaceholder({ onBannerLoaded })). */
-export declare function hasOnlyEventHandlers(props: RawPropDefinition[]): boolean;
-/**
- * Checks whether a component has no surface for a content editor to configure.
- * Returns { skip: true, reason } for infrastructure components that should be
- * flagged for operator review 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 declare function hasNoAuthoringSurface(component: RawComponentDefinition): AuthoringSurfaceCheck;