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

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-setup-props.js

@@ -0,0 +1,66 @@
+import { Project, Node } from 'ts-morph';
+import { resolveTypeProperty } from '../../shared/helpers/resolve-type-symbol.js';
+import { collectSetupImportedObjectRefs, mergeSetupObjectProps } from './extract-vue-setup-object-props.js';
+function extractGenericSetupProps(typeText) {
+    const project = new Project({
+        compilerOptions: { strict: true, target: 99, module: 99 },
+        useInMemoryFileSystem: true,
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sf = project.createSourceFile('__props__.ts', `type __Props__ = ${typeText};`);
+    const typeAlias = sf.getTypeAlias('__Props__');
+    if (!typeAlias)
+        return [];
+    const props = [];
+    for (const property of typeAlias.getType().getProperties()) {
+        const resolved = resolveTypeProperty(property);
+        if (!resolved)
+            continue;
+        let { typeText: resolvedTypeText } = resolved;
+        if (!resolved.required) {
+            resolvedTypeText = resolvedTypeText.replace(/\s*\|\s*undefined$/, '').replace(/^undefined\s*\|\s*/, '');
+        }
+        props.push({
+            name: resolved.name,
+            type: resolvedTypeText,
+            required: resolved.required,
+        });
+    }
+    return props.sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function extractVueSetupProps(filePath, scriptSetupContent) {
+    const project = new Project({
+        compilerOptions: { strict: false, target: 99, module: 99, allowJs: true },
+        useInMemoryFileSystem: true,
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sf = project.createSourceFile('__setup__.ts', scriptSetupContent);
+    let genericTypeText = null;
+    sf.forEachDescendant((node) => {
+        if (genericTypeText !== null)
+            return;
+        if (Node.isCallExpression(node) &&
+            node.getExpression().getText() === 'defineProps' &&
+            node.getTypeArguments().length > 0) {
+            genericTypeText = node.getTypeArguments()[0].getText();
+        }
+    });
+    if (genericTypeText !== null)
+        return extractGenericSetupProps(genericTypeText);
+    const importedObjectRefs = collectSetupImportedObjectRefs(sf, filePath);
+    let objectProps = null;
+    const visitedImports = new Set();
+    for (const node of sf.getDescendants()) {
+        if (objectProps !== null)
+            break;
+        if (Node.isCallExpression(node) &&
+            node.getExpression().getText() === 'defineProps' &&
+            node.getTypeArguments().length === 0) {
+            const args = node.getArguments();
+            if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                objectProps = await mergeSetupObjectProps(args[0], importedObjectRefs, visitedImports);
+            }
+        }
+    }
+    return objectProps;
+}

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-slots.d.ts

@@ -0,0 +1,24 @@
+import type { RawSlotDefinition } from '../../../types/component.js';
+interface TemplateAttrNode {
+    type: number;
+    name?: string;
+    value?: {
+        content?: string;
+    };
+}
+interface TemplateAstNode {
+    type: number;
+    tag?: string;
+    props?: TemplateAttrNode[];
+    children?: (TemplateAstNode | unknown)[];
+}
+/** Walks the Vue template AST and collects all `<slot>` elements. */
+export declare function extractSlotsFromVueTemplate(ast: TemplateAstNode): RawSlotDefinition[];
+/**
+ * Detects slots referenced via `$slots.name` or `$slots['name']` in template or
+ * script content that aren't declared as `<slot>` tags.
+ */
+export declare function collectRuntimeAccessSlots(source: string): RawSlotDefinition[];
+/** Merges two slot arrays, keeping the first occurrence of each slot name. */
+export declare function mergeVueSlots(base: RawSlotDefinition[], extra: RawSlotDefinition[]): RawSlotDefinition[];
+export {};

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-slots.js

@@ -0,0 +1,56 @@
+// @vue/compiler-core NodeTypes enum values (stable since Vue 3.0)
+const ELEMENT_TYPE = 1;
+const ATTRIBUTE_TYPE = 6;
+/** Walks the Vue template AST and collects all `<slot>` elements. */
+export function extractSlotsFromVueTemplate(ast) {
+    const slots = [];
+    function walk(node) {
+        if (node.type === ELEMENT_TYPE && node.tag === 'slot') {
+            const nameProp = node.props?.find((p) => p.type === ATTRIBUTE_TYPE && p.name === 'name');
+            const slotName = nameProp?.value?.content ?? 'default';
+            if (!slots.some((s) => s.name === slotName)) {
+                slots.push({ name: slotName, isDefault: slotName === 'default' });
+            }
+        }
+        if (node.children) {
+            for (const child of node.children) {
+                if (typeof child === 'object' && child !== null && 'type' in child) {
+                    walk(child);
+                }
+            }
+        }
+    }
+    walk(ast);
+    return slots;
+}
+/**
+ * Detects slots referenced via `$slots.name` or `$slots['name']` in template or
+ * script content that aren't declared as `<slot>` tags.
+ */
+export function collectRuntimeAccessSlots(source) {
+    const slots = [];
+    const seen = new Set();
+    const dotPattern = /\$slots\.([a-zA-Z_]\w*)/g;
+    const bracketPattern = /\$slots\[['"]([a-zA-Z_][\w-]*)['"]\]/g;
+    for (const pattern of [dotPattern, bracketPattern]) {
+        let match;
+        while ((match = pattern.exec(source)) !== null) {
+            const name = match[1];
+            if (!seen.has(name)) {
+                seen.add(name);
+                slots.push({ name, isDefault: name === 'default' });
+            }
+        }
+    }
+    return slots;
+}
+/** Merges two slot arrays, keeping the first occurrence of each slot name. */
+export function mergeVueSlots(base, extra) {
+    const merged = [...base];
+    for (const slot of extra) {
+        if (!merged.some((s) => s.name === slot.name)) {
+            merged.push(slot);
+        }
+    }
+    return merged;
+}

package/dist/src/extract/framework-adapters/vue/helpers/resolve-vue-component-name.d.ts

@@ -0,0 +1,2 @@
+/** Derives the component name from its .vue file path (uses parent directory name for index.vue files). */
+export declare function resolveVueComponentName(filePath: string): string;

package/dist/src/extract/framework-adapters/vue/helpers/resolve-vue-component-name.js

@@ -0,0 +1,9 @@
+import { basename, dirname } from 'node:path';
+/** Derives the component name from its .vue file path (uses parent directory name for index.vue files). */
+export function resolveVueComponentName(filePath) {
+    const fileName = basename(filePath, '.vue');
+    if (fileName !== 'index') {
+        return fileName;
+    }
+    return basename(dirname(filePath)) || fileName;
+}

package/dist/src/extract/framework-adapters/vue/helpers/resolve-workspace-module.d.ts

@@ -0,0 +1 @@
+export declare function resolveWorkspaceVueImport(specifier: string, importingFilePath: string): string | null;

package/dist/src/extract/framework-adapters/vue/helpers/resolve-workspace-module.js

@@ -0,0 +1,76 @@
+import { dirname, join, resolve } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { findWorkspaceRoot, collectWorkspacePackageDirs } from './workspace-package-dirs.js';
+export function resolveWorkspaceVueImport(specifier, importingFilePath) {
+    const workspaceRoot = findWorkspaceRoot(dirname(importingFilePath));
+    if (!workspaceRoot)
+        return null;
+    const packageDirs = collectWorkspacePackageDirs(workspaceRoot);
+    let packageName;
+    let subpath;
+    if (specifier.startsWith('@')) {
+        const parts = specifier.split('/');
+        if (parts.length < 2)
+            return null;
+        packageName = `${parts[0]}/${parts[1]}`;
+        subpath = parts.length > 2 ? './' + parts.slice(2).join('/') : '.';
+    }
+    else {
+        const slashIndex = specifier.indexOf('/');
+        if (slashIndex === -1) {
+            packageName = specifier;
+            subpath = '.';
+        }
+        else {
+            packageName = specifier.substring(0, slashIndex);
+            subpath = './' + specifier.substring(slashIndex + 1);
+        }
+    }
+    const packageDir = packageDirs.get(packageName);
+    if (!packageDir)
+        return null;
+    const pkgJsonPath = join(packageDir, 'package.json');
+    try {
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+        if (pkg.exports && subpath !== '.') {
+            const exportValue = pkg.exports[subpath];
+            if (typeof exportValue === 'string' && exportValue.endsWith('.vue')) {
+                const resolved = resolve(packageDir, exportValue);
+                if (existsSync(resolved))
+                    return resolved;
+            }
+        }
+        if (subpath !== '.') {
+            const subDir = resolve(packageDir, subpath.replace(/^\.\//, ''));
+            for (const base of [join(packageDir, 'src', subpath.replace(/^\.\//, '')), subDir]) {
+                const subPkgPath = join(base, 'package.json');
+                if (existsSync(subPkgPath)) {
+                    try {
+                        const subPkg = JSON.parse(readFileSync(subPkgPath, 'utf8'));
+                        const main = subPkg.main || subPkg.module;
+                        if (typeof main === 'string' && main.endsWith('.vue')) {
+                            const resolved = resolve(base, main);
+                            if (existsSync(resolved))
+                                return resolved;
+                        }
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+            }
+        }
+        if (subpath === '.') {
+            const main = pkg.main || pkg.module;
+            if (typeof main === 'string' && main.endsWith('.vue')) {
+                const resolved = resolve(packageDir, main);
+                if (existsSync(resolved))
+                    return resolved;
+            }
+        }
+    }
+    catch {
+        /* skip malformed */
+    }
+    return null;
+}

package/dist/src/extract/framework-adapters/vue/helpers/workspace-package-dirs.d.ts

@@ -0,0 +1,2 @@
+export declare function findWorkspaceRoot(startDir: string): string | null;
+export declare function collectWorkspacePackageDirs(workspaceRoot: string): Map<string, string>;

package/dist/src/extract/framework-adapters/vue/helpers/workspace-package-dirs.js

@@ -0,0 +1,77 @@
+import { dirname, join } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+const workspaceRootCache = new Map();
+export function findWorkspaceRoot(startDir) {
+    if (workspaceRootCache.has(startDir))
+        return workspaceRootCache.get(startDir);
+    let dir = startDir;
+    while (true) {
+        const pkgJsonPath = join(dir, 'package.json');
+        if (existsSync(pkgJsonPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+                if (pkg.workspaces || existsSync(join(dir, 'pnpm-workspace.yaml'))) {
+                    workspaceRootCache.set(startDir, dir);
+                    return dir;
+                }
+            }
+            catch {
+                /* skip malformed */
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            workspaceRootCache.set(startDir, null);
+            return null;
+        }
+        dir = parent;
+    }
+}
+const workspacePackageDirsCache = new Map();
+export function collectWorkspacePackageDirs(workspaceRoot) {
+    if (workspacePackageDirsCache.has(workspaceRoot))
+        return workspacePackageDirsCache.get(workspaceRoot);
+    const packageMap = new Map();
+    const packagesDir = join(workspaceRoot, 'packages');
+    if (!existsSync(packagesDir)) {
+        workspacePackageDirsCache.set(workspaceRoot, packageMap);
+        return packageMap;
+    }
+    function scanDir(dir, depth) {
+        if (depth > 3)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        const pkgJsonPath = join(dir, 'package.json');
+        if (existsSync(pkgJsonPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+                if (typeof pkg.name === 'string')
+                    packageMap.set(pkg.name, dir);
+            }
+            catch {
+                /* skip */
+            }
+        }
+        for (const entry of entries) {
+            if (entry === 'node_modules' || entry === '.git' || entry.startsWith('.'))
+                continue;
+            const entryPath = join(dir, entry);
+            try {
+                if (statSync(entryPath).isDirectory())
+                    scanDir(entryPath, depth + 1);
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    scanDir(packagesDir, 0);
+    workspacePackageDirsCache.set(workspaceRoot, packageMap);
+    return packageMap;
+}

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

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

package/dist/src/extract/framework-adapters/vue-tsx/extractor.js

@@ -0,0 +1,82 @@
+import { Node } from 'ts-morph';
+import { extractTsxComponents, getRenderableExports } from '../shared/helpers/tsx-shared.js';
+import { extractVueTsxComponentProps } from './helpers/extract-vue-tsx-props.js';
+import { extractVueTsxComponentSlots } from './helpers/extract-vue-tsx-slots.js';
+export async function extractVueTsxComponents(filePaths) {
+    const { components, warnings, exclusions } = extractTsxComponents(filePaths, /\.tsx$/, extractFromSourceFile);
+    return {
+        components: components.sort((a, b) => a.name.localeCompare(b.name)),
+        warnings,
+        exclusions,
+    };
+}
+function extractFromSourceFile(sourceFile, exclusions) {
+    const components = [];
+    for (const { name, declarations } of getRenderableExports(sourceFile, exclusions, {
+        hookReason: 'Vue composition hook names are not renderable components',
+    })) {
+        const component = extractVueTsxComponent(declarations, name, sourceFile);
+        if (component)
+            components.push(component);
+    }
+    return components;
+}
+function extractVueTsxComponent(declarations, exportName, sourceFile) {
+    for (const declaration of declarations) {
+        if (!Node.isVariableDeclaration(declaration))
+            continue;
+        if (declaration.getSourceFile().getFilePath() !== sourceFile.getFilePath())
+            continue;
+        const resolved = resolveDefineComponentCall(declaration.getInitializer());
+        if (!resolved)
+            continue;
+        const name = readComponentName(resolved.options) ?? exportName;
+        const props = extractVueTsxComponentProps(resolved.options);
+        const slots = extractVueTsxComponentSlots(resolved.options, resolved.slotsTypeNode);
+        return {
+            name,
+            source: sourceFile.getFilePath(),
+            framework: 'vue',
+            props,
+            slots,
+        };
+    }
+    return undefined;
+}
+function resolveDefineComponentCall(node) {
+    if (!node || !Node.isCallExpression(node))
+        return undefined;
+    const directExpressionText = node.getExpression().getText();
+    if (/(^|\.)defineComponent$/.test(directExpressionText)) {
+        const optionsArg = node.getArguments()[0];
+        if (!optionsArg || !Node.isObjectLiteralExpression(optionsArg))
+            return undefined;
+        return { options: optionsArg };
+    }
+    if (!Node.isCallExpression(node.getExpression()))
+        return undefined;
+    const outerArgs = node.getArguments();
+    if (outerArgs.length !== 1)
+        return undefined;
+    const optionsArg = outerArgs[0];
+    if (!Node.isObjectLiteralExpression(optionsArg))
+        return undefined;
+    const innerCall = node.getExpression();
+    if (!Node.isCallExpression(innerCall))
+        return undefined;
+    if (!/(^|\.)genericComponent$/.test(innerCall.getExpression().getText()))
+        return undefined;
+    return {
+        options: optionsArg,
+        slotsTypeNode: innerCall.getTypeArguments()[0],
+    };
+}
+function readComponentName(options) {
+    const nameProp = options.getProperty('name');
+    if (!nameProp || !Node.isPropertyAssignment(nameProp))
+        return undefined;
+    const initializer = nameProp.getInitializer();
+    if (!initializer || !Node.isStringLiteral(initializer))
+        return undefined;
+    return initializer.getLiteralText();
+}

package/dist/src/extract/framework-adapters/vue-tsx/helpers/extract-vue-tsx-props.d.ts

@@ -0,0 +1,5 @@
+import { Node } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractPropsFromExpression(node: Node, seen: Set<Node>): RawPropDefinition[];
+/** Extracts all props from a `defineComponent({ props: ... })` options object. */
+export declare function extractVueTsxComponentProps(options: import('ts-morph').ObjectLiteralExpression): RawPropDefinition[];

package/dist/src/extract/framework-adapters/vue-tsx/helpers/extract-vue-tsx-props.js

@@ -0,0 +1,189 @@
+import { Node } from 'ts-morph';
+import { extractAllowedValues, getTypeReferenceName, getValueTargetDeclarations, } from '../../shared/helpers/tsx-shared.js';
+import { resolveReturnedObjectLiteral, resolveObjectLiteralFromCallExpression, getExpressionTerminalName, extractStringArrayLiteralValues, } from './resolve-ast-object.js';
+const VUE_PROP_VALUE_TYPE_MAP = {
+    String: 'string',
+    Number: 'number',
+    Boolean: 'boolean',
+    Array: 'any[]',
+    Object: 'object',
+    Function: 'function',
+};
+function extractPropTypeArgument(typeNode) {
+    if (!typeNode || !Node.isTypeReference(typeNode))
+        return undefined;
+    if (getTypeReferenceName(typeNode) !== 'PropType')
+        return undefined;
+    return typeNode.getTypeArguments()[0]?.getText();
+}
+function resolveVueTsxPropType(node) {
+    if (Node.isAsExpression(node) || Node.isTypeAssertion(node)) {
+        const typeNode = node.getTypeNode();
+        const propTypeArg = extractPropTypeArgument(typeNode);
+        if (propTypeArg)
+            return propTypeArg;
+        return resolveVueTsxPropType(node.getExpression());
+    }
+    if (Node.isParenthesizedExpression(node)) {
+        return resolveVueTsxPropType(node.getExpression());
+    }
+    if (Node.isArrayLiteralExpression(node)) {
+        const memberTypes = node.getElements().flatMap((element) => {
+            const memberType = resolveVueTsxPropType(element);
+            return memberType === 'any' ? [] : [memberType];
+        });
+        return memberTypes.length > 0 ? [...new Set(memberTypes)].sort().join(' | ') : 'any';
+    }
+    if (Node.isIdentifier(node)) {
+        return VUE_PROP_VALUE_TYPE_MAP[node.getText()] ?? node.getText();
+    }
+    if (Node.isNullLiteral(node))
+        return 'any';
+    return node.getType().getText(node);
+}
+function readVueTsxObjectPropertyName(property) {
+    const nameNode = property.getNameNode();
+    if (Node.isIdentifier(nameNode) || Node.isPrivateIdentifier(nameNode))
+        return nameNode.getText();
+    if (Node.isStringLiteral(nameNode) || Node.isNoSubstitutionTemplateLiteral(nameNode))
+        return nameNode.getLiteralText();
+    if (Node.isComputedPropertyName(nameNode)) {
+        const expression = nameNode.getExpression();
+        if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+            return expression.getLiteralText();
+        }
+    }
+    return property.getName();
+}
+function buildPropFromObjectLiteral(propName, initializer) {
+    let type = 'any';
+    let required = false;
+    let defaultValue;
+    let allowedValues;
+    for (const property of initializer.getProperties()) {
+        if (!Node.isPropertyAssignment(property))
+            continue;
+        const name = property.getName();
+        const value = property.getInitializer();
+        if (!value)
+            continue;
+        if (name === 'type') {
+            type = resolveVueTsxPropType(value);
+            allowedValues = extractAllowedValues(value.getType());
+        }
+        else if (name === 'required') {
+            required = value.getText() === 'true';
+        }
+        else if (name === 'default') {
+            defaultValue = value.getText();
+        }
+    }
+    return {
+        name: propName,
+        type,
+        required,
+        ...(defaultValue !== undefined && { defaultValue }),
+        ...(allowedValues && { allowedValues }),
+    };
+}
+function buildPropFromInitializer(propName, initializer) {
+    if (!initializer)
+        return undefined;
+    if (Node.isObjectLiteralExpression(initializer)) {
+        return buildPropFromObjectLiteral(propName, initializer);
+    }
+    return {
+        name: propName,
+        type: resolveVueTsxPropType(initializer),
+        required: false,
+    };
+}
+function extractPropsFromObjectLiteral(objectLiteral, seen) {
+    const propsByName = new Map();
+    for (const property of objectLiteral.getProperties()) {
+        if (Node.isPropertyAssignment(property)) {
+            const propName = readVueTsxObjectPropertyName(property);
+            if (!propName)
+                continue;
+            const definition = buildPropFromInitializer(propName, property.getInitializer());
+            if (definition)
+                propsByName.set(definition.name, definition);
+            continue;
+        }
+        if (Node.isSpreadAssignment(property)) {
+            for (const definition of extractPropsFromExpression(property.getExpression(), seen)) {
+                propsByName.set(definition.name, definition);
+            }
+        }
+    }
+    return [...propsByName.values()];
+}
+function resolvePropsObjectLiteral(node) {
+    if (Node.isObjectLiteralExpression(node))
+        return node;
+    if (!Node.isCallExpression(node))
+        return undefined;
+    const returnedObject = resolveObjectLiteralFromCallExpression(node, new Set());
+    if (returnedObject)
+        return returnedObject;
+    const expression = node.getExpression();
+    if (Node.isIdentifier(expression)) {
+        for (const declaration of getValueTargetDeclarations(expression)) {
+            if (!Node.isVariableDeclaration(declaration))
+                continue;
+            const initializer = declaration.getInitializer();
+            if (!initializer || !Node.isCallExpression(initializer))
+                continue;
+            if (!/(^|\.)propsFactory$/.test(initializer.getExpression().getText()))
+                continue;
+            const propsArg = initializer.getArguments()[0];
+            if (propsArg && Node.isObjectLiteralExpression(propsArg))
+                return propsArg;
+        }
+    }
+    return undefined;
+}
+export function extractPropsFromExpression(node, seen) {
+    if (seen.has(node))
+        return [];
+    seen.add(node);
+    if (Node.isObjectLiteralExpression(node)) {
+        return extractPropsFromObjectLiteral(node, seen);
+    }
+    if (Node.isCallExpression(node)) {
+        const expressionName = getExpressionTerminalName(node.getExpression());
+        if (expressionName === 'pick' || expressionName === 'omit') {
+            const sourceArg = node.getArguments()[0];
+            const keyArg = node.getArguments()[1];
+            if (!sourceArg || !keyArg)
+                return [];
+            const keys = extractStringArrayLiteralValues(keyArg);
+            if (!keys)
+                return [];
+            const sourceProps = extractPropsFromExpression(sourceArg, seen);
+            const keySet = new Set(keys);
+            return sourceProps.filter((p) => (expressionName === 'pick' ? keySet.has(p.name) : !keySet.has(p.name)));
+        }
+        const propsObject = resolvePropsObjectLiteral(node);
+        if (propsObject)
+            return extractPropsFromObjectLiteral(propsObject, seen);
+    }
+    if (Node.isIdentifier(node)) {
+        for (const declaration of getValueTargetDeclarations(node)) {
+            const resolved = resolveReturnedObjectLiteral(declaration, seen);
+            if (resolved)
+                return extractPropsFromObjectLiteral(resolved, seen);
+        }
+    }
+    return [];
+}
+/** Extracts all props from a `defineComponent({ props: ... })` options object. */
+export function extractVueTsxComponentProps(options) {
+    const propsProp = options.getProperty('props');
+    if (!propsProp || !Node.isPropertyAssignment(propsProp))
+        return [];
+    const initializer = propsProp.getInitializer();
+    if (!initializer)
+        return [];
+    return extractPropsFromExpression(initializer, new Set()).sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/src/extract/framework-adapters/vue-tsx/helpers/extract-vue-tsx-slots.d.ts

@@ -0,0 +1,4 @@
+import { Node } from 'ts-morph';
+import type { RawSlotDefinition } from '../../../types/component.js';
+/** Extracts slots from a `defineComponent` options object, preferring type-level declarations over setup access. */
+export declare function extractVueTsxComponentSlots(options: import('ts-morph').ObjectLiteralExpression, slotsTypeNode: Node | undefined): RawSlotDefinition[];