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

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

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

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

@@ -1,77 +0,0 @@
-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/framework-adapters/vue-tsx/extractor.js

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

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

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

@@ -1,4 +0,0 @@
-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[];

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

@@ -1,91 +0,0 @@
-import { Node, SyntaxKind } from 'ts-morph';
-import { getTypeTargetDeclarations } from '../../shared/helpers/tsx-shared.js';
-function extractTypeMemberSlots(members, allowMethods) {
-    return members
-        .flatMap((member) => {
-        if (!Node.isPropertySignature(member) && (!allowMethods || !Node.isMethodSignature(member)))
-            return [];
-        const slotName = member.getName();
-        return [{ name: slotName, isDefault: slotName === 'default' }];
-    })
-        .sort((a, b) => a.name.localeCompare(b.name));
-}
-function extractSlotsFromTypeNode(typeNode, seen) {
-    if (!typeNode || seen.has(typeNode))
-        return [];
-    seen.add(typeNode);
-    if (Node.isTypeLiteral(typeNode)) {
-        return extractTypeMemberSlots(typeNode.getMembers(), false);
-    }
-    if (Node.isTypeReference(typeNode)) {
-        for (const declaration of getTypeTargetDeclarations(typeNode.getTypeName(), false)) {
-            if (Node.isTypeAliasDeclaration(declaration)) {
-                return extractSlotsFromTypeNode(declaration.getTypeNode(), seen);
-            }
-            if (Node.isInterfaceDeclaration(declaration)) {
-                return extractTypeMemberSlots(declaration.getMembers(), true);
-            }
-        }
-    }
-    return [];
-}
-function extractSlotsFromSetupFunction(options) {
-    const setupProp = options.getProperty('setup');
-    if (!setupProp)
-        return [];
-    const setupFunction = Node.isMethodDeclaration(setupProp)
-        ? setupProp
-        : Node.isPropertyAssignment(setupProp)
-            ? setupProp.getInitializer()
-            : undefined;
-    if (!setupFunction)
-        return [];
-    if (!Node.isMethodDeclaration(setupFunction) &&
-        !Node.isArrowFunction(setupFunction) &&
-        !Node.isFunctionExpression(setupFunction)) {
-        return [];
-    }
-    const params = setupFunction.getParameters();
-    if (params.length < 2)
-        return [];
-    const contextParam = params[1];
-    const nameNode = contextParam.getNameNode();
-    if (!Node.isObjectBindingPattern(nameNode))
-        return [];
-    const slotsBinding = nameNode
-        .getElements()
-        .find((el) => el.getPropertyNameNode()?.getText() === 'slots' || el.getName() === 'slots');
-    if (!slotsBinding)
-        return [];
-    const slotsName = slotsBinding.getName();
-    const body = setupFunction.getBody();
-    if (!body)
-        return [];
-    const slotsByName = new Map();
-    for (const access of body.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)) {
-        if (access.getExpression().getText() !== slotsName)
-            continue;
-        const slotName = access.getName();
-        if (!slotsByName.has(slotName)) {
-            slotsByName.set(slotName, {
-                name: slotName,
-                isDefault: slotName === 'default',
-            });
-        }
-    }
-    return [...slotsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-/** Extracts slots from a `defineComponent` options object, preferring type-level declarations over setup access. */
-export function extractVueTsxComponentSlots(options, slotsTypeNode) {
-    const slotsByName = new Map();
-    if (slotsTypeNode) {
-        for (const slot of extractSlotsFromTypeNode(slotsTypeNode, new Set())) {
-            slotsByName.set(slot.name, slot);
-        }
-    }
-    for (const slot of extractSlotsFromSetupFunction(options)) {
-        if (!slotsByName.has(slot.name))
-            slotsByName.set(slot.name, slot);
-    }
-    return [...slotsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}

package/dist/src/extract/framework-adapters/vue-tsx/helpers/resolve-ast-object.d.ts

@@ -1,11 +0,0 @@
-import { Node } from 'ts-morph';
-/** Recursively resolves a node to the object literal it represents or returns, or undefined. */
-export declare function resolveReturnedObjectLiteral(node: Node, seen: Set<Node>): import('ts-morph').ObjectLiteralExpression | undefined;
-/** Scans a list of statements for a `return <object literal>` and resolves it. */
-export declare function resolveObjectLiteralFromStatements(statements: import('ts-morph').Statement[], seen: Set<Node>): import('ts-morph').ObjectLiteralExpression | undefined;
-/** Resolves a call expression's callee to an object literal it returns. */
-export declare function resolveObjectLiteralFromCallExpression(callExpression: import('ts-morph').CallExpression, seen: Set<Node>): import('ts-morph').ObjectLiteralExpression | undefined;
-/** Returns the trailing identifier name from an expression (e.g. `foo.bar` → `'bar'`). */
-export declare function getExpressionTerminalName(node: Node): string | undefined;
-/** Extracts an array of string literal values, or returns undefined if any element is not a string literal. */
-export declare function extractStringArrayLiteralValues(node: Node): string[] | undefined;

package/dist/src/extract/framework-adapters/vue-tsx/helpers/resolve-ast-object.js

@@ -1,95 +0,0 @@
-import { Node, SyntaxKind } from 'ts-morph';
-import { getValueTargetDeclarations } from '../../shared/helpers/tsx-shared.js';
-/** Recursively resolves a node to the object literal it represents or returns, or undefined. */
-export function resolveReturnedObjectLiteral(node, seen) {
-    if (seen.has(node))
-        return undefined;
-    seen.add(node);
-    if (Node.isObjectLiteralExpression(node))
-        return node;
-    if (Node.isParenthesizedExpression(node)) {
-        return resolveReturnedObjectLiteral(node.getExpression(), seen);
-    }
-    if (Node.isVariableDeclaration(node)) {
-        const initializer = node.getInitializer();
-        if (!initializer)
-            return undefined;
-        return resolveReturnedObjectLiteral(initializer, seen);
-    }
-    if (Node.isArrowFunction(node)) {
-        const body = node.getBody();
-        if (Node.isObjectLiteralExpression(body))
-            return body;
-        const block = body.asKind(SyntaxKind.Block);
-        if (block)
-            return resolveObjectLiteralFromStatements(block.getStatements(), seen);
-        return resolveReturnedObjectLiteral(body, seen);
-    }
-    if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node)) {
-        const body = node.getBody();
-        if (!body)
-            return undefined;
-        const block = body.asKind(SyntaxKind.Block);
-        if (!block)
-            return undefined;
-        return resolveObjectLiteralFromStatements(block.getStatements(), seen);
-    }
-    if (Node.isCallExpression(node)) {
-        return resolveObjectLiteralFromCallExpression(node, seen);
-    }
-    if (Node.isIdentifier(node)) {
-        for (const declaration of getValueTargetDeclarations(node)) {
-            const resolved = resolveReturnedObjectLiteral(declaration, seen);
-            if (resolved)
-                return resolved;
-        }
-    }
-    return undefined;
-}
-/** Scans a list of statements for a `return <object literal>` and resolves it. */
-export function resolveObjectLiteralFromStatements(statements, seen) {
-    for (const statement of statements) {
-        if (!Node.isReturnStatement(statement))
-            continue;
-        const expression = statement.getExpression();
-        if (!expression)
-            continue;
-        const resolved = resolveReturnedObjectLiteral(expression, seen);
-        if (resolved)
-            return resolved;
-    }
-    return undefined;
-}
-/** Resolves a call expression's callee to an object literal it returns. */
-export function resolveObjectLiteralFromCallExpression(callExpression, seen) {
-    const expression = callExpression.getExpression();
-    if (!Node.isIdentifier(expression))
-        return undefined;
-    for (const declaration of getValueTargetDeclarations(expression)) {
-        const resolved = resolveReturnedObjectLiteral(declaration, seen);
-        if (resolved)
-            return resolved;
-    }
-    return undefined;
-}
-/** Returns the trailing identifier name from an expression (e.g. `foo.bar` → `'bar'`). */
-export function getExpressionTerminalName(node) {
-    if (Node.isIdentifier(node))
-        return node.getText();
-    if (Node.isPropertyAccessExpression(node))
-        return node.getName();
-    return undefined;
-}
-/** Extracts an array of string literal values, or returns undefined if any element is not a string literal. */
-export function extractStringArrayLiteralValues(node) {
-    if (!Node.isArrayLiteralExpression(node))
-        return undefined;
-    const keys = [];
-    for (const element of node.getElements()) {
-        if (!Node.isStringLiteral(element) && !Node.isNoSubstitutionTemplateLiteral(element)) {
-            return undefined;
-        }
-        keys.push(element.getLiteralText());
-    }
-    return keys;
-}