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

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

@@ -1,220 +0,0 @@
-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/adapters/support/file-processing/project-source-files.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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

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

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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/adapters/web-components/properties.d.ts

@@ -1,9 +0,0 @@
-import { type ClassDeclaration } from 'ts-morph';
-import type { RawPropDefinition } from '../../model/component.js';
-export declare function extractObservedAttributes(classDecl: ClassDeclaration): RawPropDefinition[];
-export declare function hasShoelaceRuntimeBookkeepingField(classDecl: ClassDeclaration): boolean;
-export declare function extractClassProperties(classDecl: ClassDeclaration, applyRuntimeFieldDenylist?: boolean): RawPropDefinition[];
-export declare function extractAccessorProperties(classDecl: ClassDeclaration, applyRuntimeFieldDenylist?: boolean): RawPropDefinition[];
-export declare function extractJsDocAttributeProps(classDecl: ClassDeclaration): RawPropDefinition[];
-export declare function mergePropLists(...propLists: RawPropDefinition[][]): RawPropDefinition[];
-export declare function mergeProps(observed: RawPropDefinition[], classProps: RawPropDefinition[]): RawPropDefinition[];

package/dist/src/extract/adapters/web-components/properties.js

@@ -1,212 +0,0 @@
-import { Node } from 'ts-morph';
-function kebabToCamel(input) {
-    return input.replace(/-([a-z0-9])/gi, (_, char) => char.toUpperCase());
-}
-export function extractObservedAttributes(classDecl) {
-    const props = [];
-    const getter = classDecl.getGetAccessor('observedAttributes');
-    if (!getter || !getter.isStatic())
-        return props;
-    const body = getter.getBody();
-    if (!body)
-        return props;
-    // Find the return statement containing an array literal
-    body.forEachDescendant((node) => {
-        if (!Node.isReturnStatement(node))
-            return;
-        const expression = node.getExpression();
-        if (!expression || !Node.isArrayLiteralExpression(expression))
-            return;
-        for (const element of expression.getElements()) {
-            if (Node.isStringLiteral(element)) {
-                const attrName = element.getLiteralValue();
-                props.push({
-                    name: attrName,
-                    type: 'string',
-                    required: false,
-                });
-            }
-        }
-    });
-    return props;
-}
-function hasInternalJsDocTag(member) {
-    return member.getJsDocs().some((doc) => doc.getTags().some((tag) => tag.getTagName() === 'internal'));
-}
-const NON_PUBLIC_LIT_DECORATORS = new Set(['consume', 'provide', 'query', 'queryAsync', 'state']);
-const INTERNAL_RUNTIME_FIELD_NAMES = new Set(['dir', 'initialReflectedProperties', 'lang']);
-function isNonPublicLitMember(member) {
-    return member.getDecorators().some((decorator) => NON_PUBLIC_LIT_DECORATORS.has(decorator.getName()));
-}
-export function hasShoelaceRuntimeBookkeepingField(classDecl) {
-    return classDecl.getProperties().some((property) => property.getName() === 'initialReflectedProperties');
-}
-function isInternalRuntimeField(name, applyRuntimeFieldDenylist) {
-    return applyRuntimeFieldDenylist && INTERNAL_RUNTIME_FIELD_NAMES.has(name);
-}
-function getExplicitLitPropertyAttributeName(property) {
-    const decorator = property.getDecorators().find((candidate) => candidate.getName() === 'property');
-    const firstArg = decorator?.getArguments()[0];
-    if (!firstArg || !Node.isObjectLiteralExpression(firstArg)) {
-        return null;
-    }
-    const attributeProp = firstArg.getProperty('attribute');
-    if (!attributeProp || !Node.isPropertyAssignment(attributeProp)) {
-        return null;
-    }
-    const initializer = attributeProp.getInitializer();
-    if (!initializer || !Node.isStringLiteral(initializer)) {
-        return null;
-    }
-    return initializer.getLiteralValue();
-}
-export function extractClassProperties(classDecl, applyRuntimeFieldDenylist = false) {
-    const props = [];
-    for (const property of classDecl.getProperties()) {
-        if (property.isStatic())
-            continue;
-        if (hasInternalJsDocTag(property))
-            continue;
-        if (isNonPublicLitMember(property))
-            continue;
-        const name = property.getName();
-        if (name.startsWith('#') || isInternalRuntimeField(name, applyRuntimeFieldDenylist))
-            continue;
-        const scope = property.getScope();
-        if (scope === 'private' || scope === 'protected')
-            continue;
-        const initializer = property.getInitializer();
-        const hasDecorators = property.getDecorators().length > 0;
-        // Skip undecorated arrow-function properties (internal event handlers / callbacks)
-        if (!hasDecorators && initializer && Node.isArrowFunction(initializer)) {
-            continue;
-        }
-        // Skip properties initialized with this.attachInternals() (ElementInternals)
-        if (initializer &&
-            Node.isCallExpression(initializer) &&
-            initializer.getExpression().getText() === 'this.attachInternals') {
-            continue;
-        }
-        const typeNode = property.getTypeNode();
-        const type = typeNode ? typeNode.getText() : 'any';
-        const publicName = name.startsWith('_') && hasDecorators ? getExplicitLitPropertyAttributeName(property) : null;
-        let defaultValue;
-        if (initializer) {
-            if (Node.isStringLiteral(initializer)) {
-                defaultValue = initializer.getLiteralValue();
-            }
-            else {
-                defaultValue = initializer.getText();
-            }
-        }
-        props.push({
-            name: publicName ? kebabToCamel(publicName) : name,
-            type,
-            required: false,
-            ...(defaultValue !== undefined && { defaultValue }),
-            sourceStartLine: property.getStartLineNumber(),
-            sourceEndLine: property.getEndLineNumber(),
-        });
-    }
-    return props;
-}
-export function extractAccessorProperties(classDecl, applyRuntimeFieldDenylist = false) {
-    const props = [];
-    const accessors = new Map();
-    for (const getter of classDecl.getGetAccessors()) {
-        if (getter.isStatic())
-            continue;
-        if (hasInternalJsDocTag(getter))
-            continue;
-        if (isNonPublicLitMember(getter))
-            continue;
-        const name = getter.getName();
-        if (name === 'observedAttributes' ||
-            name === 'template' ||
-            name.startsWith('#') ||
-            isInternalRuntimeField(name, applyRuntimeFieldDenylist))
-            continue;
-        const scope = getter.getScope();
-        if (scope === 'private' || scope === 'protected')
-            continue;
-        const entry = accessors.get(name) ?? {};
-        entry.getter = getter;
-        accessors.set(name, entry);
-    }
-    for (const setter of classDecl.getSetAccessors()) {
-        if (setter.isStatic())
-            continue;
-        if (hasInternalJsDocTag(setter))
-            continue;
-        if (isNonPublicLitMember(setter))
-            continue;
-        const name = setter.getName();
-        if (name === 'observedAttributes' ||
-            name === 'template' ||
-            name.startsWith('#') ||
-            isInternalRuntimeField(name, applyRuntimeFieldDenylist))
-            continue;
-        const scope = setter.getScope();
-        if (scope === 'private' || scope === 'protected')
-            continue;
-        const entry = accessors.get(name) ?? {};
-        entry.setter = setter;
-        accessors.set(name, entry);
-    }
-    for (const [name, { getter, setter }] of accessors) {
-        const hasPropertyDecorator = getter?.getDecorators().some((decorator) => decorator.getName() === 'property') ||
-            setter?.getDecorators().some((decorator) => decorator.getName() === 'property');
-        if (!hasPropertyDecorator && !(getter && setter))
-            continue;
-        const type = getter?.getReturnTypeNode()?.getText() ?? setter?.getParameters()[0]?.getTypeNode()?.getText() ?? 'any';
-        const accessorNode = getter ?? setter;
-        props.push({
-            name,
-            type,
-            required: false,
-            ...(accessorNode
-                ? {
-                    sourceStartLine: accessorNode.getStartLineNumber(),
-                    sourceEndLine: accessorNode.getEndLineNumber(),
-                }
-                : {}),
-        });
-    }
-    return props;
-}
-export function extractJsDocAttributeProps(classDecl) {
-    const props = [];
-    for (const doc of classDecl.getJsDocs()) {
-        for (const tag of doc.getTags()) {
-            if (tag.getTagName() !== 'attribute')
-                continue;
-            const tagComment = tag.getCommentText();
-            const normalizedComment = Array.isArray(tagComment) ? tagComment.join(' ') : tagComment;
-            const match = normalizedComment?.match(/(?:\{([^}]+)\}\s+)?([^\s]+)(?:\s*-\s*([\s\S]*))?/);
-            if (!match)
-                continue;
-            const [, type, name, description] = match;
-            if (!name || name.startsWith('#'))
-                continue;
-            props.push({
-                name,
-                type: type?.trim() || 'any',
-                required: false,
-                ...(description ? { description: description.replace(/\s+/g, ' ').trim() } : {}),
-            });
-        }
-    }
-    return props;
-}
-export function mergePropLists(...propLists) {
-    const merged = new Map();
-    for (const propList of propLists) {
-        for (const prop of propList) {
-            merged.set(prop.name, prop);
-        }
-    }
-    return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-export function mergeProps(observed, classProps) {
-    return mergePropLists(observed, classProps);
-}

package/dist/src/extract/controller/extract-controller.d.ts

@@ -1,10 +0,0 @@
-import type { ExtractionEndpointRequest, ExtractionEndpointResponse } from '../model/contract.js';
-export type { ExtractionEndpointProgress, ExtractionEndpointRequest, ExtractionEndpointResponse, } from '../model/contract.js';
-/**
- * Stable in-process extraction contract.
- *
- * The controller owns public request validation and progress translation. The
- * extraction service owns source analysis and quality policy; neither layer
- * scans directories, invokes agents, or persists sessions.
- */
-export declare function extractEndpoint(request: ExtractionEndpointRequest): Promise<ExtractionEndpointResponse>;

package/dist/src/extract/controller/extract-controller.js

@@ -1,56 +0,0 @@
-import { runExtractionService } from '../services/extraction-service.js';
-function validateRequest(request) {
-    if (request === null || typeof request !== 'object') {
-        throw new TypeError('extractEndpoint requires a request object');
-    }
-    if (!Array.isArray(request.filePaths)) {
-        throw new TypeError('extractEndpoint requires filePaths to be an array');
-    }
-    if (request.filePaths.some((filePath) => typeof filePath !== 'string' || filePath.trim().length === 0)) {
-        throw new TypeError('extractEndpoint requires filePaths to contain non-empty strings');
-    }
-    if (request.projectRoot !== undefined &&
-        (typeof request.projectRoot !== 'string' || request.projectRoot.trim().length === 0)) {
-        throw new TypeError('extractEndpoint requires projectRoot to be a non-empty string when provided');
-    }
-    if (request.resolveUnreachable !== undefined &&
-        request.resolveUnreachable !== 'auto' &&
-        request.resolveUnreachable !== 'always' &&
-        request.resolveUnreachable !== 'never') {
-        throw new TypeError("extractEndpoint requires resolveUnreachable to be 'auto', 'always', or 'never'");
-    }
-    if (request.onProgress !== undefined && typeof request.onProgress !== 'function') {
-        throw new TypeError('extractEndpoint requires onProgress to be a function when provided');
-    }
-}
-/**
- * Stable in-process extraction contract.
- *
- * The controller owns public request validation and progress translation. The
- * extraction service owns source analysis and quality policy; neither layer
- * scans directories, invokes agents, or persists sessions.
- */
-export async function extractEndpoint(request) {
-    validateRequest(request);
-    const filePaths = [...request.filePaths];
-    const result = await runExtractionService({
-        filePaths,
-        ...(request.resolveUnreachable !== undefined ? { resolveUnreachable: request.resolveUnreachable } : {}),
-        ...(request.projectRoot !== undefined ? { projectRoot: request.projectRoot } : {}),
-        onProgress: ({ filesProcessed, componentsFound }) => {
-            request.onProgress?.({
-                phase: 'extract',
-                filesProcessed,
-                totalFiles: filePaths.length,
-                componentsFound,
-            });
-        },
-    });
-    request.onProgress?.({
-        phase: 'extract',
-        filesProcessed: filePaths.length,
-        totalFiles: filePaths.length,
-        componentsFound: result.components.length,
-    });
-    return result;
-}