@contentful/experience-design-system-extraction 2.34.5-dev-build-ec126bf0.0 → 2.34.5-dev-build-4a4b9e84.0

package/dist/src/extract/adapters/react/prop-dataflow.js

@@ -0,0 +1,220 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { getJsxTagNameNode, getNodeDefinitions, getValueTargetDeclarations, isIntrinsicJsxElement, } from '../support/tsx-shared.js';
+import { resolveFunctionNode } from './function-resolution.js';
+function getDeclarationIdentity(node) {
+    if (Node.isIdentifier(node)) {
+        const parent = node.getParent();
+        if ((Node.isVariableDeclaration(parent) || Node.isBindingElement(parent) || Node.isParameterDeclaration(parent)) &&
+            parent.getNameNode() === node) {
+            return parent;
+        }
+    }
+    return getNodeDefinitions(node)[0]?.getDeclarationNode() ?? node;
+}
+export function getComponentIdentity(func) {
+    return `${func.getSourceFile().getFilePath()}:${func.getStart()}`;
+}
+function resolveForwardedComponentIdentity(tagNameNode) {
+    if (!Node.isIdentifier(tagNameNode))
+        return undefined;
+    for (const declaration of getValueTargetDeclarations(tagNameNode)) {
+        const func = resolveFunctionNode(declaration);
+        if (func)
+            return getComponentIdentity(func);
+    }
+    return undefined;
+}
+/**
+ * Declarations that are rebound somewhere in the body, so their initializer no
+ * longer describes the value that reaches JSX.
+ */
+function collectReboundDeclarations(body) {
+    const rebound = new Set();
+    const recordTarget = (target) => {
+        if (Node.isIdentifier(target)) {
+            rebound.add(getDeclarationIdentity(target));
+            return;
+        }
+        if ((Node.isPropertyAccessExpression(target) || Node.isElementAccessExpression(target)) &&
+            Node.isIdentifier(target.getExpression())) {
+            rebound.add(getDeclarationIdentity(target.getExpression()));
+        }
+    };
+    for (const assignment of body?.getDescendantsOfKind(SyntaxKind.BinaryExpression) ?? []) {
+        // Covers `=` and every compound form (`+=`, `??=`, `>>>=`, ...).
+        const operator = assignment.getOperatorToken().getKind();
+        if (operator < SyntaxKind.FirstAssignment || operator > SyntaxKind.LastAssignment)
+            continue;
+        recordTarget(assignment.getLeft());
+    }
+    // Only `++`/`--` rebind the operand. Reading a prop through `!`, `-`, `+`, or
+    // `~` leaves the alias intact, so those operators must not invalidate it.
+    for (const update of body?.getDescendantsOfKind(SyntaxKind.PrefixUnaryExpression) ?? []) {
+        const operator = update.getOperatorToken();
+        if (operator !== SyntaxKind.PlusPlusToken && operator !== SyntaxKind.MinusMinusToken)
+            continue;
+        recordTarget(update.getOperand());
+    }
+    for (const update of body?.getDescendantsOfKind(SyntaxKind.PostfixUnaryExpression) ?? []) {
+        recordTarget(update.getOperand());
+    }
+    return rebound;
+}
+/** Trace only statically resolvable, component-local prop dataflow into JSX. */
+export function collectPropDataflow(func, param, availablePropNames) {
+    const valueAliases = new Map();
+    const objectAliases = new Map();
+    const fullPropsShape = new Map([...availablePropNames].map((name) => [name, name]));
+    const belongsToComponentFunction = (node) => node.getFirstAncestor((ancestor) => Node.isFunctionDeclaration(ancestor) || Node.isArrowFunction(ancestor) || Node.isFunctionExpression(ancestor)) === func;
+    const resolveValue = (expression) => {
+        if (!expression)
+            return undefined;
+        if (Node.isParenthesizedExpression(expression))
+            return resolveValue(expression.getExpression());
+        if (Node.isIdentifier(expression))
+            return valueAliases.get(getDeclarationIdentity(expression));
+        if (Node.isPropertyAccessExpression(expression)) {
+            const object = expression.getExpression();
+            return Node.isIdentifier(object)
+                ? objectAliases.get(getDeclarationIdentity(object))?.get(expression.getName())
+                : undefined;
+        }
+        if (Node.isElementAccessExpression(expression)) {
+            const argument = expression.getArgumentExpression();
+            if (!argument || (!Node.isStringLiteral(argument) && !Node.isNoSubstitutionTemplateLiteral(argument))) {
+                return undefined;
+            }
+            const object = expression.getExpression();
+            return Node.isIdentifier(object)
+                ? objectAliases.get(getDeclarationIdentity(object))?.get(argument.getLiteralText())
+                : undefined;
+        }
+        return undefined;
+    };
+    const resolveObject = (expression) => {
+        if (!expression)
+            return undefined;
+        if (Node.isParenthesizedExpression(expression))
+            return resolveObject(expression.getExpression());
+        if (Node.isIdentifier(expression))
+            return objectAliases.get(getDeclarationIdentity(expression));
+        if (!Node.isObjectLiteralExpression(expression))
+            return undefined;
+        const shape = new Map();
+        for (const property of expression.getProperties()) {
+            if (Node.isSpreadAssignment(property)) {
+                const spreadShape = resolveObject(property.getExpression());
+                for (const [targetProp, sourceProp] of spreadShape ?? [])
+                    shape.set(targetProp, sourceProp);
+            }
+            else if (Node.isShorthandPropertyAssignment(property)) {
+                const sourceProp = resolveValue(property.getNameNode());
+                if (sourceProp)
+                    shape.set(property.getName(), sourceProp);
+            }
+            else if (Node.isPropertyAssignment(property)) {
+                const propertyNameNode = property.getNameNode();
+                if (!Node.isIdentifier(propertyNameNode) && !Node.isStringLiteral(propertyNameNode))
+                    continue;
+                const sourceProp = resolveValue(property.getInitializer());
+                if (sourceProp)
+                    shape.set(property.getName(), sourceProp);
+            }
+        }
+        return shape;
+    };
+    const addBindings = (pattern, sourceShape) => {
+        const omittedProps = new Set(pattern
+            .getElements()
+            .filter((element) => !element.getDotDotDotToken())
+            .map((element) => element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText()));
+        for (const element of pattern.getElements()) {
+            const localName = element.getNameNode();
+            if (!Node.isIdentifier(localName))
+                continue;
+            if (element.getDotDotDotToken()) {
+                objectAliases.set(getDeclarationIdentity(localName), new Map([...sourceShape].filter(([targetProp]) => !omittedProps.has(targetProp))));
+                continue;
+            }
+            const targetProp = element.getPropertyNameNode()?.getText() ?? localName.getText();
+            const sourceProp = sourceShape.get(targetProp);
+            if (sourceProp)
+                valueAliases.set(getDeclarationIdentity(localName), sourceProp);
+        }
+    };
+    const paramNameNode = param.getNameNode();
+    if (Node.isIdentifier(paramNameNode))
+        objectAliases.set(getDeclarationIdentity(paramNameNode), fullPropsShape);
+    else if (Node.isObjectBindingPattern(paramNameNode))
+        addBindings(paramNameNode, fullPropsShape);
+    const body = func.getBody();
+    const reboundDeclarations = collectReboundDeclarations(body);
+    for (const declaration of reboundDeclarations) {
+        valueAliases.delete(declaration);
+        objectAliases.delete(declaration);
+    }
+    for (const declaration of body?.getDescendantsOfKind(SyntaxKind.VariableDeclaration) ?? []) {
+        if (!belongsToComponentFunction(declaration))
+            continue;
+        const initializer = declaration.getInitializer();
+        const declarationName = declaration.getNameNode();
+        if (Node.isIdentifier(declarationName)) {
+            const aliasDeclaration = getDeclarationIdentity(declarationName);
+            if (reboundDeclarations.has(aliasDeclaration))
+                continue;
+            const sourceProp = resolveValue(initializer);
+            if (sourceProp)
+                valueAliases.set(aliasDeclaration, sourceProp);
+            const sourceShape = resolveObject(initializer);
+            if (sourceShape)
+                objectAliases.set(aliasDeclaration, new Map(sourceShape));
+        }
+        else if (Node.isObjectBindingPattern(declarationName)) {
+            const sourceShape = resolveObject(initializer);
+            if (sourceShape) {
+                const hasInvalidatedBinding = declarationName
+                    .getElements()
+                    .some((element) => reboundDeclarations.has(getDeclarationIdentity(element.getNameNode())));
+                if (!hasInvalidatedBinding)
+                    addBindings(declarationName, sourceShape);
+            }
+        }
+    }
+    const intrinsicDomProps = new Set();
+    const componentEdges = [];
+    const recordForwarding = (tagNameNode, targetProp, sourceProp) => {
+        const tagName = tagNameNode.getText();
+        if (isIntrinsicJsxElement(tagName)) {
+            if (targetProp === sourceProp)
+                intrinsicDomProps.add(sourceProp);
+            return;
+        }
+        const targetComponentIdentity = resolveForwardedComponentIdentity(tagNameNode);
+        if (targetComponentIdentity)
+            componentEdges.push({ sourceProp, targetComponentIdentity, targetProp });
+    };
+    for (const attribute of func.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+        if (!belongsToComponentFunction(attribute))
+            continue;
+        const tagNameNode = getJsxTagNameNode(attribute);
+        if (!tagNameNode)
+            continue;
+        const initializer = attribute.getInitializer();
+        if (!initializer || !Node.isJsxExpression(initializer))
+            continue;
+        const sourceProp = resolveValue(initializer.getExpression());
+        if (sourceProp)
+            recordForwarding(tagNameNode, attribute.getNameNode().getText(), sourceProp);
+    }
+    for (const spread of func.getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)) {
+        if (!belongsToComponentFunction(spread))
+            continue;
+        const tagNameNode = getJsxTagNameNode(spread);
+        if (!tagNameNode)
+            continue;
+        const shape = resolveObject(spread.getExpression());
+        for (const [targetProp, sourceProp] of shape ?? [])
+            recordForwarding(tagNameNode, targetProp, sourceProp);
+    }
+    return { intrinsicDomProps, componentEdges };
+}

package/dist/src/extract/{stencil.d.ts → adapters/stencil/extractor.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../types.js';
+import type { ComponentExtractionResult } from '../../model/component.js';
 export declare function extractStencilComponents(filePaths: string[]): Promise<ComponentExtractionResult>;

package/dist/src/extract/{stencil.js → adapters/stencil/extractor.js}

@@ -1,6 +1,7 @@
 import { Project, Node, SyntaxKind } from 'ts-morph';
-import { getJsxTagNameNode, isIntrinsicJsxElement, kebabToPascal } from './tsx-shared.js';
-import { createSortedExtractionResult, extractProjectSourceFiles } from './file-extraction-workers.js';
+import { getJsxTagNameNode, isIntrinsicJsxElement, kebabToPascal } from '../support/tsx-shared.js';
+import { createSortedExtractionResult } from '../support/file-processing/result-normalizer.js';
+import { extractProjectSourceFiles } from '../support/file-processing/project-source-files.js';
 function isStencilFile(sourceFile) {
     return sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === '@stencil/core');
 }

package/dist/src/extract/{file-extraction-workers.d.ts → adapters/support/file-processing/file-workers.d.ts}

@@ -1,10 +1,9 @@
-import type { Project, SourceFile } from 'ts-morph';
 export type FileExtractionOutcome<T, M = undefined> = {
     item: T | null;
     warnings?: string[];
     metadata?: M;
 };
-type FileExtractionProgress = {
+export type FileExtractionProgress = {
     filesProcessed: number;
     componentsFound: number;
 };
@@ -12,14 +11,3 @@ export declare function runFileExtractionWorkers<T, M = undefined>(filePaths: st
     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 → adapters/support/file-processing/file-workers.js}

@@ -27,22 +27,3 @@ export async function runFileExtractionWorkers(filePaths, concurrency, extractFi
     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/adapters/support/file-processing/project-source-files.d.ts

@@ -0,0 +1,5 @@
+import type { Project, SourceFile } from 'ts-morph';
+export declare function extractProjectSourceFiles<T>(project: Project, extractFile: (sourceFile: SourceFile, warnings: string[]) => T[]): {
+    items: T[];
+    warnings: string[];
+};

package/dist/src/extract/adapters/support/file-processing/project-source-files.js

@@ -0,0 +1,13 @@
+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/adapters/support/file-processing/result-normalizer.d.ts

@@ -0,0 +1,6 @@
+export declare function createSortedExtractionResult<T extends {
+    name: string;
+}>(components: T[], warnings: string[]): {
+    components: T[];
+    warnings: string[];
+};

package/dist/src/extract/adapters/support/file-processing/result-normalizer.js

@@ -0,0 +1,6 @@
+export function createSortedExtractionResult(components, warnings) {
+    return {
+        components: components.sort((a, b) => a.name.localeCompare(b.name)),
+        warnings,
+    };
+}

package/dist/src/extract/{source-line-metadata.d.ts → adapters/support/resolution/source-location.d.ts}

@@ -1,3 +1,3 @@
 import type { Node } from 'ts-morph';
-import type { RawPropDefinition } from '../types.js';
+import type { RawPropDefinition } from '../../../model/component.js';
 export declare function getSourceLineMetadata(declaration: Node | undefined): Pick<RawPropDefinition, 'sourceStartLine' | 'sourceEndLine'>;

package/dist/src/extract/{tsx-shared.d.ts → adapters/support/tsx-shared.d.ts}

@@ -1,5 +1,5 @@
 import { Node, Project, type SourceFile, type Type } from 'ts-morph';
-import type { ExtractionExclusion } from '../types.js';
+import type { ExtractionExclusion } from '../../model/component.js';
 export declare function getTsxExtractionContext(filePaths: string[], componentFilePattern: RegExp): {
     componentFiles: string[];
     project: Project;

package/dist/src/extract/adapters/svelte/ast.d.ts

@@ -0,0 +1,12 @@
+export interface AstNode {
+    type: string;
+    loc?: {
+        start?: {
+            line?: number;
+        };
+        end?: {
+            line?: number;
+        };
+    };
+    [key: string]: unknown;
+}

package/dist/src/extract/adapters/svelte/ast.js

@@ -0,0 +1 @@
+export {};

package/dist/src/extract/{svelte.d.ts → adapters/svelte/extractor.d.ts}

@@ -1,4 +1,5 @@
-import type { ComponentExtractionResult, ExtractorOptions } from '../types.js';
+import type { ComponentExtractionResult } from '../../model/component.js';
+import type { ExtractorOptions } from '../../model/options.js';
 export declare function extractSvelteComponents(filePaths: string[], onProgress?: (p: {
     filesProcessed: number;
     componentsFound: number;

package/dist/src/extract/{svelte.js → adapters/svelte/extractor.js}

@@ -1,13 +1,15 @@
 import os from 'node:os';
-import { basename, dirname, resolve, join } from 'node:path';
+import { dirname, resolve, join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { parse as parseSvelte } from 'svelte/compiler';
 import { Project, Node, ScriptTarget, ModuleKind, ts } from 'ts-morph';
-import { computeExtractionScore, deriveNeedsReview } from './scoring.js';
-import { extractAllowedComponentsFromTypeText } from './slot-allowed-components.js';
-import { runFileExtractionWorkers } from './file-extraction-workers.js';
-import { resolveLocalModule } from './resolve-local-module.js';
+import { computeExtractionScore, deriveNeedsReview } from '../../policies/quality/scoring.js';
+import { extractAllowedComponentsFromTypeText } from '../../evidence/allowed-components.js';
+import { runFileExtractionWorkers } from '../support/file-processing/file-workers.js';
+import { resolveLocalModule } from '../support/resolution/local-module.js';
+import { getSvelteComponentName } from './identity.js';
+import { extractTemplateSlots, mergeSlots } from './slots.js';
 export async function extractSvelteComponents(filePaths, onProgress, opts) {
     const svelteFiles = filePaths.filter((f) => f.endsWith('.svelte'));
     const retryContexts = new Map();
@@ -466,31 +468,6 @@ async function extractFromSvelteFile(filePath, source) {
     }
     return { component, warnings, ...(retryContext ? { retryContext } : {}) };
 }
-const ANATOMY_FOLDERS = new Set(['anatomy', 'parts']);
-function getSvelteComponentName(filePath) {
-    const file = basename(filePath, '.svelte');
-    const parentDir = basename(dirname(filePath));
-    if (file === 'index')
-        return toPascalCase(parentDir);
-    if (ANATOMY_FOLDERS.has(parentDir)) {
-        const grandparent = basename(dirname(dirname(filePath)));
-        if (grandparent && grandparent !== '.' && grandparent !== '/') {
-            return `${toPascalCase(grandparent)}${toPascalCase(file)}`;
-        }
-    }
-    return toPascalCase(file);
-}
-function toPascalCase(s) {
-    if (!s)
-        return s;
-    if (/^[A-Z]/.test(s) && !s.includes('-') && !s.includes('_'))
-        return s;
-    return s
-        .split(/[-_]+/)
-        .filter(Boolean)
-        .map((part) => part[0].toUpperCase() + part.slice(1))
-        .join('');
-}
 function hasV4ExportLetProps(instance) {
     const body = instance['content']?.['body'];
     if (!body)
@@ -1246,64 +1223,3 @@ function extractAllowedValuesFromText(typeText) {
     }
     return out.length > 0 ? out : undefined;
 }
-function extractTemplateSlots(fragment) {
-    const slots = [];
-    const seen = new Set();
-    walk(fragment);
-    return slots;
-    function walk(node) {
-        if (!node)
-            return;
-        if (node.type === 'SlotElement') {
-            const name = readSlotName(node);
-            if (!seen.has(name)) {
-                seen.add(name);
-                slots.push({ name, isDefault: name === 'default' });
-            }
-        }
-        const children = node['nodes'] ?? node['children'] ?? [];
-        for (const c of children)
-            walk(c);
-        const fragChild = node['fragment'];
-        if (fragChild)
-            walk(fragChild);
-    }
-}
-function readSlotName(slotEl) {
-    const attrs = slotEl['attributes'] ?? [];
-    for (const attr of attrs) {
-        if (attr['name'] !== 'name')
-            continue;
-        const value = attr['value'];
-        if (Array.isArray(value)) {
-            for (const v of value) {
-                if (v.type === 'Text' && typeof v['data'] === 'string')
-                    return v['data'];
-            }
-        }
-    }
-    return 'default';
-}
-function mergeSlots(fromSnippetProps, fromTemplate) {
-    if (fromSnippetProps.length === 0)
-        return { slots: fromTemplate, mixedWarning: false };
-    if (fromTemplate.length === 0)
-        return { slots: fromSnippetProps, mixedWarning: false };
-    const byName = new Map();
-    for (const s of fromSnippetProps)
-        byName.set(s.name, s);
-    const snippetHasDefault = fromSnippetProps.some((s) => s.isDefault);
-    let mixed = false;
-    for (const s of fromTemplate) {
-        if (s.isDefault && snippetHasDefault) {
-            mixed = true;
-            continue;
-        }
-        if (byName.has(s.name)) {
-            mixed = true;
-            continue;
-        }
-        byName.set(s.name, s);
-    }
-    return { slots: [...byName.values()], mixedWarning: mixed };
-}

package/dist/src/extract/adapters/svelte/identity.d.ts

@@ -0,0 +1 @@
+export declare function getSvelteComponentName(filePath: string): string;

package/dist/src/extract/adapters/svelte/identity.js

@@ -0,0 +1,26 @@
+import { basename, dirname } from 'node:path';
+const ANATOMY_FOLDERS = new Set(['anatomy', 'parts']);
+export function getSvelteComponentName(filePath) {
+    const file = basename(filePath, '.svelte');
+    const parentDir = basename(dirname(filePath));
+    if (file === 'index')
+        return toPascalCase(parentDir);
+    if (ANATOMY_FOLDERS.has(parentDir)) {
+        const grandparent = basename(dirname(dirname(filePath)));
+        if (grandparent && grandparent !== '.' && grandparent !== '/') {
+            return `${toPascalCase(grandparent)}${toPascalCase(file)}`;
+        }
+    }
+    return toPascalCase(file);
+}
+function toPascalCase(s) {
+    if (!s)
+        return s;
+    if (/^[A-Z]/.test(s) && !s.includes('-') && !s.includes('_'))
+        return s;
+    return s
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}

package/dist/src/extract/adapters/svelte/slots.d.ts

@@ -0,0 +1,7 @@
+import type { RawSlotDefinition } from '../../model/component.js';
+import type { AstNode } from './ast.js';
+export declare function extractTemplateSlots(fragment: AstNode): RawSlotDefinition[];
+export declare function mergeSlots(fromSnippetProps: RawSlotDefinition[], fromTemplate: RawSlotDefinition[]): {
+    slots: RawSlotDefinition[];
+    mixedWarning: boolean;
+};

package/dist/src/extract/adapters/svelte/slots.js

@@ -0,0 +1,63 @@
+export function extractTemplateSlots(fragment) {
+    const slots = new Map();
+    const seen = new Set();
+    walk(fragment);
+    return [...slots.entries()]
+        .map(([name, isDefault]) => ({ name, isDefault }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    function walk(node) {
+        if (!node)
+            return;
+        if (node.type === 'SlotElement') {
+            const name = readSlotName(node);
+            if (!seen.has(name)) {
+                seen.add(name);
+                slots.set(name, name === 'default');
+            }
+        }
+        const children = node['nodes'] ?? node['children'] ?? [];
+        for (const child of children)
+            walk(child);
+        const fragmentChild = node['fragment'];
+        if (fragmentChild)
+            walk(fragmentChild);
+    }
+}
+function readSlotName(slotElement) {
+    const attrs = slotElement['attributes'] ?? [];
+    for (const attr of attrs) {
+        if (attr['name'] !== 'name')
+            continue;
+        const value = attr['value'];
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item.type === 'Text' && typeof item['data'] === 'string')
+                    return item['data'];
+            }
+        }
+    }
+    return 'default';
+}
+export function mergeSlots(fromSnippetProps, fromTemplate) {
+    if (fromSnippetProps.length === 0)
+        return { slots: fromTemplate, mixedWarning: false };
+    if (fromTemplate.length === 0)
+        return { slots: fromSnippetProps, mixedWarning: false };
+    const byName = new Map();
+    for (const slot of fromSnippetProps)
+        byName.set(slot.name, slot);
+    const snippetHasDefault = fromSnippetProps.some((slot) => slot.isDefault);
+    let mixed = false;
+    for (const slot of fromTemplate) {
+        if (slot.isDefault && snippetHasDefault) {
+            mixed = true;
+            continue;
+        }
+        if (byName.has(slot.name)) {
+            mixed = true;
+            continue;
+        }
+        byName.set(slot.name, slot);
+    }
+    return { slots: [...byName.values()], mixedWarning: mixed };
+}

package/dist/src/extract/{vue.d.ts → adapters/vue/extractor.d.ts}

@@ -1,4 +1,4 @@
-import type { ComponentExtractionResult } from '../types.js';
+import type { ComponentExtractionResult } from '../../model/component.js';
 export declare function extractVueComponents(filePaths: string[], onProgress?: (p: {
     filesProcessed: number;
     componentsFound: number;

package/dist/src/extract/{vue.js → adapters/vue/extractor.js}

@@ -4,9 +4,10 @@ import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { parse as parseSFC } from '@vue/compiler-sfc';
 import { Project, Node } from 'ts-morph';
-import { createSortedExtractionResult, runFileExtractionWorkers } from './file-extraction-workers.js';
-import { resolveLocalModule } from './resolve-local-module.js';
-import { resolveTypeProperty } from './resolve-type-property.js';
+import { runFileExtractionWorkers } from '../support/file-processing/file-workers.js';
+import { createSortedExtractionResult } from '../support/file-processing/result-normalizer.js';
+import { resolveLocalModule } from '../support/resolution/local-module.js';
+import { resolveTypeProperty } from '../support/resolution/type-property.js';
 // @vue/compiler-core NodeTypes enum values (stable since Vue 3.0)
 const ELEMENT_TYPE = 1;
 const ATTRIBUTE_TYPE = 6;

package/dist/src/extract/{vue-tsx.d.ts → adapters/vue-tsx/extractor.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../types.js';
+import type { ComponentExtractionResult } from '../../model/component.js';
 export declare function extractVueTsxComponents(filePaths: string[]): Promise<ComponentExtractionResult>;

package/dist/src/extract/{vue-tsx.js → adapters/vue-tsx/extractor.js}

@@ -1,5 +1,5 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { extractAllowedValues, extractTsxComponents, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getRenderableExports, } from './tsx-shared.js';
+import { extractAllowedValues, extractTsxComponents, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getRenderableExports, } from '../support/tsx-shared.js';
 export async function extractVueTsxComponents(filePaths) {
     const { components, warnings, exclusions } = extractTsxComponents(filePaths, /\.tsx$/, extractFromSourceFile);
     return {

package/dist/src/extract/{web-components.d.ts → adapters/web-components/extractor.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../types.js';
+import type { ComponentExtractionResult } from '../../model/component.js';
 export declare function extractWebComponentDefinitions(filePaths: string[]): Promise<ComponentExtractionResult>;