@rightcapital/php-parser/dist/php-parser/helpers/type-generation-helpers.js

TypeScript types for PHP Parser JSON representation

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TypeGenerationHelpers = void 0;
const node_path_1 = require("node:path");
class TypeGenerationHelpers {
    static getGroupedTypeNameForNode(nodeName) {
        return `NodeTypeInheritingFrom${nodeName}`;
    }
    static generateCombinationTypesFromNodes(cliContext) {
        const { allNodes } = cliContext;
        const importNodeNamesPart = Object.entries(allNodes)
            .map(([name, nodeItem]) => {
            const importPath = (0, node_path_1.join)('node', nodeItem.filePath);
            return `import type { ${name} } from './${importPath}';`;
        })
            .join('\n');
        const exportNodeNamesPart = Object.entries(allNodes)
            .map(([name, nodeItem]) => {
            const exportPath = (0, node_path_1.join)('node', nodeItem.filePath);
            return `export { ${name} } from './${exportPath}';`;
        })
            .join('\n');
        const combinationTypesPart = Object.entries(allNodes)
            .map(([name, nodeItem]) => {
            const validSubNodeTypes = nodeItem.subNodeNames
                .filter((subNodeName) => {
                const subNode = allNodes[subNodeName];
                const hasNodeType = subNode &&
                    subNode.nodeType !== undefined &&
                    subNode.nodeType !== '';
                const isUnionType = subNode &&
                    subNode.subNodeNames &&
                    subNode.subNodeNames.length > 0;
                return hasNodeType || isUnionType;
            })
                .map((subNodeName) => TypeGenerationHelpers.getGroupedTypeNameForNode(subNodeName));
            const shouldIncludeSelf = nodeItem.nodeType !== undefined && nodeItem.nodeType !== '';
            const typeComponents = [
                ...(shouldIncludeSelf ? [name] : []),
                ...validSubNodeTypes,
            ];
            if (typeComponents.length === 0) {
                typeComponents.push(name);
            }
            return `export type ${TypeGenerationHelpers.getGroupedTypeNameForNode(name)} = ${typeComponents.join(' | ')};`;
        })
            .join('\n');
        return `
${importNodeNamesPart}      

${combinationTypesPart}

${exportNodeNamesPart}

${TypeGenerationHelpers.generateNodeTypeEnum(cliContext)}
      `;
    }
    static generateNodeTypeEnum(cliContext) {
        const { allNodes } = cliContext;
        const nodesThatHasNodeType = Object.values(allNodes)
            .filter((node) => node.nodeType !== undefined && node.nodeType !== '')
            .map((node) => [node.nodeType, node]);
        const nodeEnum = `export enum NodeType {
${nodesThatHasNodeType
            .map(([nodeType, _]) => {
            return `  ${nodeType} = '${nodeType}',`;
        })
            .join('\n')}
}
`;
        const nodeTypeToInterfaceMap = `
export interface NodeTypeToInterfaceMap {
${nodesThatHasNodeType
            .map(([nodeType, node]) => {
            return `  [NodeType.${nodeType}]: ${node.name};`;
        })
            .join('\n')}
}
    `;
        return `
${nodeEnum};
${nodeTypeToInterfaceMap}
`;
    }
}
exports.TypeGenerationHelpers = TypeGenerationHelpers;