@resistdesign/voltra 3.0.0-alpha.3 → 3.0.0-alpha.4

package/src/common/TypeParsing/ParsingUtils/checkUnionType.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkUnionType = void 0;
-const extractLiteralValues_1 = require("./extractLiteralValues");
-const checkUnionType = (unionType) => {
-    const extracted = (0, extractLiteralValues_1.extractLiteralValues)(unionType);
-    let typeKeyword = "string";
-    let options;
-    if (extracted) {
-        options = extracted.values;
-        typeKeyword = extracted.type;
-    }
-    return { options: options || [], typeKeyword };
-};
-exports.checkUnionType = checkUnionType;

package/src/common/TypeParsing/ParsingUtils/extractCommentTags.d.ts

@@ -1,2 +0,0 @@
-import { Node } from "typescript";
-export declare const extractCommentTags: (node: Node) => Record<any, any>;

package/src/common/TypeParsing/ParsingUtils/extractCommentTags.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractCommentTags = void 0;
-const Routing_1 = require("../../Routing");
-const TAG_NAME_PATH_DELIMITER = ".";
-const getFlatTagValue = (tagValue) => {
-    if (typeof tagValue === "undefined") {
-        return "";
-    }
-    else if (Array.isArray(tagValue)) {
-        const valueNodeArray = tagValue;
-        const valueList = [];
-        for (let i = 0; i < valueNodeArray.length; i++) {
-            const { text } = valueNodeArray[i];
-            valueList.push(getFlatTagValue(text));
-        }
-        return valueList.join(" ");
-    }
-    else {
-        return `${tagValue}`;
-    }
-};
-const getTagNameAndValue = (tag) => {
-    let name = tag.tagName.text, value = getFlatTagValue(tag.comment);
-    if (value.startsWith(TAG_NAME_PATH_DELIMITER)) {
-        const extendedTagNameEndIndex = value.indexOf(" ");
-        const hasActualValue = extendedTagNameEndIndex !== -1;
-        name += hasActualValue ? value.slice(0, extendedTagNameEndIndex) : value;
-        value = hasActualValue ? value.slice(extendedTagNameEndIndex + 1) : "";
-    }
-    if (value === "") {
-        value = "true";
-    }
-    return {
-        name,
-        value,
-    };
-};
-const getObjectWithValueAppliedToPath = (path = [], value, baseObject) => {
-    let baseParentObject = undefined, currentParent = undefined;
-    if (path.length === 0) {
-        baseParentObject = value;
-    }
-    else {
-        for (let i = 0; i < path.length; i++) {
-            const pathPart = path[i];
-            const cleanPathPart = typeof pathPart === "number"
-                ? pathPart
-                : `${typeof pathPart !== "undefined" ? pathPart : ""}`;
-            const isNum = typeof cleanPathPart === "number";
-            let newCurrentParent = undefined;
-            if (i === 0) {
-                if (!baseObject) {
-                    baseParentObject = isNum ? [] : {};
-                }
-                else {
-                    baseParentObject = isNum
-                        ? [...(Array.isArray(baseObject) ? baseObject : [])]
-                        : {
-                            ...(typeof baseObject === "object" ? baseObject : {}),
-                        };
-                }
-                currentParent = baseParentObject;
-            }
-            if (i < path.length - 1) {
-                const existingNewCurrentParent = currentParent[cleanPathPart];
-                newCurrentParent = isNum
-                    ? [
-                        ...(Array.isArray(existingNewCurrentParent)
-                            ? existingNewCurrentParent
-                            : []),
-                    ]
-                    : {
-                        ...(typeof existingNewCurrentParent === "object"
-                            ? existingNewCurrentParent
-                            : {}),
-                    };
-                currentParent[cleanPathPart] = newCurrentParent;
-                currentParent = newCurrentParent;
-            }
-            else {
-                currentParent[cleanPathPart] = value;
-            }
-        }
-    }
-    return baseParentObject;
-};
-const extractCommentTags = (node) => {
-    const jsDocComments = node["jsDoc"];
-    let commentTags = {};
-    if (jsDocComments) {
-        jsDocComments.forEach((jsDoc) => {
-            const tags = jsDoc.tags;
-            if (tags) {
-                tags.forEach((tag) => {
-                    const { name: tagName, value: tagValue } = getTagNameAndValue(tag);
-                    const potentialJSONValue = (0, Routing_1.getPotentialJSONValue)(tagValue);
-                    commentTags = getObjectWithValueAppliedToPath((0, Routing_1.getPathArray)(tagName, TAG_NAME_PATH_DELIMITER), potentialJSONValue, commentTags);
-                });
-            }
-        });
-    }
-    return commentTags;
-};
-exports.extractCommentTags = extractCommentTags;

package/src/common/TypeParsing/ParsingUtils/extractLiteralValues.d.ts

@@ -1,6 +0,0 @@
-import { UnionTypeNode } from 'typescript';
-import { LiteralValue, TypeKeyword } from '../TypeInfo';
-export declare const extractLiteralValues: (node: UnionTypeNode) => {
-    values: LiteralValue[];
-    type: TypeKeyword;
-} | undefined;

package/src/common/TypeParsing/ParsingUtils/extractLiteralValues.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractLiteralValues = void 0;
-const typescript_1 = require("typescript");
-const extractLiteralValues = (node) => {
-    const literalValues = [];
-    let detectedTypeKeyword;
-    for (const type of node.types) {
-        if ((0, typescript_1.isLiteralTypeNode)(type)) {
-            const literal = type.literal;
-            if ((0, typescript_1.isStringLiteral)(literal)) {
-                if (!detectedTypeKeyword)
-                    detectedTypeKeyword = 'string';
-                if (detectedTypeKeyword === 'string') {
-                    literalValues.push(literal.text);
-                }
-            }
-            else if ((0, typescript_1.isNumericLiteral)(literal)) {
-                if (!detectedTypeKeyword)
-                    detectedTypeKeyword = 'number';
-                if (detectedTypeKeyword === 'number') {
-                    literalValues.push(Number(literal.text));
-                }
-            }
-            else if (literal.kind === typescript_1.SyntaxKind.TrueKeyword || literal.kind === typescript_1.SyntaxKind.FalseKeyword) {
-                if (!detectedTypeKeyword)
-                    detectedTypeKeyword = 'boolean';
-                if (detectedTypeKeyword === 'boolean') {
-                    literalValues.push(literal.kind === typescript_1.SyntaxKind.TrueKeyword);
-                }
-            }
-            else if (literal.kind === typescript_1.SyntaxKind.NullKeyword) {
-                literalValues.push(null);
-            }
-        }
-        else {
-            return undefined;
-        }
-    }
-    return literalValues.length ? { values: literalValues, type: detectedTypeKeyword } : undefined;
-};
-exports.extractLiteralValues = extractLiteralValues;

package/src/common/TypeParsing/ParsingUtils/extractTypeDetails.d.ts

@@ -1,8 +0,0 @@
-import { TypeNode } from 'typescript';
-import { LiteralValue, TypeKeyword } from '../TypeInfo';
-export declare const extractTypeDetails: (type: TypeNode) => {
-    type: TypeKeyword;
-    typeReference?: string;
-    array: boolean;
-    options?: LiteralValue[];
-};

package/src/common/TypeParsing/ParsingUtils/extractTypeDetails.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractTypeDetails = void 0;
-const checkType_1 = require("./checkType");
-const extractTypeDetails = (type) => {
-    const { isArray, typeReference, options, typeKeyword } = (0, checkType_1.checkType)(type);
-    return {
-        type: typeKeyword || 'string',
-        typeReference,
-        array: !!isArray,
-        options,
-    };
-};
-exports.extractTypeDetails = extractTypeDetails;

package/src/common/TypeParsing/ParsingUtils/getPrimaryFieldForTypeInfo.d.ts

@@ -1,5 +0,0 @@
-import { TypeInfo } from "../TypeInfo";
-export declare enum TypeInfoPrimaryFieldErrors {
-    READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED = "READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED"
-}
-export declare const getPrimaryFieldForTypeInfo: (typeInfo: TypeInfo) => string | undefined;

package/src/common/TypeParsing/ParsingUtils/getPrimaryFieldForTypeInfo.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPrimaryFieldForTypeInfo = exports.TypeInfoPrimaryFieldErrors = void 0;
-var TypeInfoPrimaryFieldErrors;
-(function (TypeInfoPrimaryFieldErrors) {
-    TypeInfoPrimaryFieldErrors["READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED"] = "READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED";
-})(TypeInfoPrimaryFieldErrors || (exports.TypeInfoPrimaryFieldErrors = TypeInfoPrimaryFieldErrors = {}));
-const getPrimaryFieldForTypeInfo = (typeInfo) => {
-    const { fields } = typeInfo;
-    let primaryField = undefined, primaryFieldReadDenied = false;
-    for (const fieldName in fields) {
-        const field = fields[fieldName];
-        const { tags: { primaryField: isPrimaryField = false, deniedOperations: { READ: readDenied = false } = {}, } = {}, } = field;
-        if (isPrimaryField || !primaryField) {
-            primaryField = fieldName;
-            primaryFieldReadDenied = readDenied;
-        }
-        if (isPrimaryField) {
-            break;
-        }
-    }
-    if (primaryFieldReadDenied) {
-        throw new Error(TypeInfoPrimaryFieldErrors.READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED);
-    }
-    return primaryField;
-};
-exports.getPrimaryFieldForTypeInfo = getPrimaryFieldForTypeInfo;

package/src/common/TypeParsing/ParsingUtils/getTypeInfo.d.ts

@@ -1,3 +0,0 @@
-import { TypeLiteralNode } from "typescript";
-import { TypeInfo } from "../TypeInfo";
-export declare const getTypeInfo: (typeLiteral: TypeLiteralNode) => TypeInfo;

package/src/common/TypeParsing/ParsingUtils/getTypeInfo.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeInfo = void 0;
-const typescript_1 = require("typescript");
-const extractCommentTags_1 = require("./extractCommentTags");
-const getTypeInfoField_1 = require("./getTypeInfoField");
-const getTypeInfo = (typeLiteral) => {
-    const { members } = typeLiteral;
-    const tags = (0, extractCommentTags_1.extractCommentTags)(typeLiteral);
-    let fields = {};
-    for (const m of members) {
-        const { name, kind } = m;
-        if (name && kind === typescript_1.SyntaxKind.PropertySignature) {
-            const fieldName = name.getText();
-            const field = (0, getTypeInfoField_1.getTypeInfoField)(m);
-            fields = {
-                ...fields,
-                [fieldName]: field,
-            };
-        }
-    }
-    return {
-        fields,
-        tags,
-    };
-};
-exports.getTypeInfo = getTypeInfo;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoField.d.ts

@@ -1,3 +0,0 @@
-import { PropertySignature } from "typescript";
-import { TypeInfoField } from "../TypeInfo";
-export declare const getTypeInfoField: (propertySignature: PropertySignature) => TypeInfoField;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoField.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeInfoField = void 0;
-const typescript_1 = require("typescript");
-const extractTypeDetails_1 = require("./extractTypeDetails");
-const extractCommentTags_1 = require("./extractCommentTags");
-const getTypeInfoField = (propertySignature) => {
-    const { type, modifiers } = propertySignature;
-    const { array, typeReference, type: typeKeyword, options, } = type
-        ? (0, extractTypeDetails_1.extractTypeDetails)(type)
-        : {
-            array: false,
-            typeReference: undefined,
-            type: "string",
-            options: undefined,
-        };
-    const readonly = modifiers
-        ? modifiers.some((modifier) => modifier.kind === typescript_1.SyntaxKind.ReadonlyKeyword)
-        : false;
-    const optional = !!propertySignature.questionToken;
-    let tags = (0, extractCommentTags_1.extractCommentTags)(propertySignature);
-    if (readonly) {
-        const { deniedOperations, deniedOperations: { CREATE, UPDATE, DELETE } = {}, } = tags || {};
-        tags = {
-            ...tags,
-            deniedOperations: {
-                ...deniedOperations,
-                create: CREATE ?? true,
-                update: UPDATE ?? true,
-                delete: DELETE ?? true,
-            },
-        };
-    }
-    return {
-        type: typeKeyword,
-        array,
-        readonly,
-        optional,
-        typeReference,
-        possibleValues: options,
-        tags,
-    };
-};
-exports.getTypeInfoField = getTypeInfoField;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoFromAliasType.d.ts

@@ -1,4 +0,0 @@
-import { TypeNode } from "typescript";
-import { TypeMap } from "../TypeMapping";
-import { TypeInfo } from "../TypeInfo";
-export declare const getTypeInfoFromAliasType: (type: TypeNode, typeMap: TypeMap) => TypeInfo | undefined;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoFromAliasType.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeInfoFromAliasType = void 0;
-const typescript_1 = require("typescript");
-const getTypeInfo_1 = require("./getTypeInfo");
-const getUnionOrIntersectionTypeInfo_1 = require("./getUnionOrIntersectionTypeInfo");
-const getTypeInfoFromFieldFilter_1 = require("./getTypeInfoFromFieldFilter");
-const getTypeInfoFromTypeLiteral = (type) => (0, getTypeInfo_1.getTypeInfo)(type);
-const getTypeInfoFromUnionOrIntersectionType = (type, typeMap) => (0, getUnionOrIntersectionTypeInfo_1.getUnionOrIntersectionTypeInfo)(type, typeMap);
-const getTypeInfoFromTypeReference = (type, typeMap) => {
-    const typeRef = type;
-    const { typeName } = typeRef;
-    const typeNameStr = typeName.getText();
-    return (0, getTypeInfoFromFieldFilter_1.getTypeInfoFromFieldFilter)(typeNameStr, typeRef, typeMap);
-};
-const ALIAS_TYPE_PROCESSORS = {
-    [typescript_1.SyntaxKind.TypeLiteral]: getTypeInfoFromTypeLiteral,
-    [typescript_1.SyntaxKind.UnionType]: getTypeInfoFromUnionOrIntersectionType,
-    [typescript_1.SyntaxKind.IntersectionType]: getTypeInfoFromUnionOrIntersectionType,
-    [typescript_1.SyntaxKind.TypeReference]: getTypeInfoFromTypeReference,
-};
-const getTypeInfoFromAliasType = (type, typeMap) => {
-    const { kind } = type;
-    const processor = ALIAS_TYPE_PROCESSORS[kind];
-    const typeInfo = processor ? processor(type, typeMap) : undefined;
-    return typeInfo;
-};
-exports.getTypeInfoFromAliasType = getTypeInfoFromAliasType;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoFromFieldFilter.d.ts

@@ -1,4 +0,0 @@
-import { TypeReferenceNode } from "typescript";
-import { TypeMap } from "../TypeMapping";
-import { TypeInfo } from "../TypeInfo";
-export declare const getTypeInfoFromFieldFilter: (typeNameStr: string | undefined, typeRef: TypeReferenceNode, typeMap: TypeMap) => TypeInfo | undefined;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoFromFieldFilter.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeInfoFromFieldFilter = void 0;
-const typescript_1 = require("typescript");
-const Constants_1 = require("./Constants");
-const getUnionOrLiteralStringValues_1 = require("./getUnionOrLiteralStringValues");
-const getTypeInfoFromTypeAlias_1 = require("./getTypeInfoFromTypeAlias");
-const getTypeInfoFromPickOmitFieldFilters = (typeNameStr, typeRef, typeMap) => {
-    const picking = typeNameStr === Constants_1.FIELD_FILTERS.PICK;
-    const omitTypeKind = typeRef.typeArguments?.[0].kind;
-    let typeInfo;
-    if (omitTypeKind === typescript_1.SyntaxKind.TypeReference &&
-        typeRef.typeArguments &&
-        typeRef.typeArguments[0].kind === typescript_1.SyntaxKind.TypeReference) {
-        const omitType = typeRef.typeArguments[0];
-        const omitTypeFields = typeRef.typeArguments[1];
-        const omitTypeName = omitType.typeName.getText();
-        const refNode = typeMap[omitTypeName];
-        if (refNode) {
-            const { fields: existingFields = {}, unionFieldSets: existingUnionFieldSets, ...typeInfoOther } = (0, getTypeInfoFromTypeAlias_1.getTypeInfoFromTypeAlias)(refNode, typeMap) || {};
-            const omitFieldNames = (0, getUnionOrLiteralStringValues_1.getUnionOrLiteralStringValues)(omitTypeFields);
-            const cleanTypeInfoFields = Object.keys(existingFields).reduce((acc, key) => {
-                if (acc &&
-                    ((picking && omitFieldNames.includes(key)) ||
-                        (!picking && !omitFieldNames.includes(key))) &&
-                    existingFields[key]) {
-                    acc[key] = existingFields[key];
-                }
-                return acc;
-            }, {});
-            const cleanUnionFieldSets = existingUnionFieldSets
-                ? existingUnionFieldSets.map((fieldSet) => fieldSet.filter((field) => picking
-                    ? omitFieldNames.includes(field)
-                    : !omitFieldNames.includes(field)))
-                : undefined;
-            typeInfo = {
-                ...typeInfoOther,
-                fields: cleanTypeInfoFields,
-                unionFieldSets: cleanUnionFieldSets,
-            };
-        }
-    }
-    return typeInfo;
-};
-const getTypeInfoFromExcludeFieldFilter = (typeNameStr, typeRef, typeMap) => {
-    const baseTypeKind = typeRef.typeArguments?.[0].kind;
-    const excludeTypeKind = typeRef.typeArguments?.[1].kind;
-    let typeInfo;
-    if (baseTypeKind === typescript_1.SyntaxKind.TypeReference &&
-        excludeTypeKind === typescript_1.SyntaxKind.TypeReference &&
-        typeRef.typeArguments) {
-        const baseType = typeRef.typeArguments[0];
-        const excludeType = typeRef.typeArguments[1];
-        const baseTypeName = baseType.typeName.getText();
-        const excludeTypeName = excludeType.typeName.getText();
-        const refNode = typeMap[baseTypeName];
-        const excludeNode = typeMap[excludeTypeName];
-        if (refNode && excludeNode) {
-            const baseTypeInfo = (0, getTypeInfoFromTypeAlias_1.getTypeInfoFromTypeAlias)(refNode, typeMap);
-            const excludeTypeInfo = (0, getTypeInfoFromTypeAlias_1.getTypeInfoFromTypeAlias)(excludeNode, typeMap);
-            if (baseTypeInfo && excludeTypeInfo) {
-                const { fields: baseFields = {}, unionFieldSets: existingUnionFieldSets, } = baseTypeInfo;
-                const { fields: excludeFields = {} } = excludeTypeInfo;
-                const excludeFieldNames = Object.keys(excludeFields);
-                const cleanTypeInfoFields = Object.keys(baseFields).reduce((acc, key) => {
-                    if (acc && !excludeFieldNames.includes(key) && baseFields[key]) {
-                        acc[key] = baseFields[key];
-                    }
-                    return acc;
-                }, {});
-                const cleanUnionFieldSets = existingUnionFieldSets
-                    ? existingUnionFieldSets.map((fieldSet) => fieldSet.filter((field) => !excludeFieldNames.includes(field)))
-                    : undefined;
-                typeInfo = {
-                    ...baseTypeInfo,
-                    fields: cleanTypeInfoFields,
-                    unionFieldSets: cleanUnionFieldSets,
-                };
-            }
-        }
-    }
-    return typeInfo;
-};
-const defaultFieldFilterProcessor = (typeNameStr, typeRef, typeMap) => {
-    const refNode = typeNameStr ? typeMap[typeNameStr] : undefined;
-    let typeInfo;
-    if (refNode) {
-        typeInfo = (0, getTypeInfoFromTypeAlias_1.getTypeInfoFromTypeAlias)(refNode, typeMap);
-    }
-    return typeInfo;
-};
-const FIELD_FILTER_PROCESSORS = {
-    [Constants_1.FIELD_FILTERS.PICK]: getTypeInfoFromPickOmitFieldFilters,
-    [Constants_1.FIELD_FILTERS.OMIT]: getTypeInfoFromPickOmitFieldFilters,
-    [Constants_1.FIELD_FILTERS.EXCLUDE]: getTypeInfoFromExcludeFieldFilter,
-};
-const getTypeInfoFromFieldFilter = (typeNameStr, typeRef, typeMap) => {
-    const processor = typeNameStr
-        ? FIELD_FILTER_PROCESSORS[typeNameStr]
-        : undefined;
-    return processor
-        ? processor(typeNameStr, typeRef, typeMap)
-        : defaultFieldFilterProcessor(typeNameStr, typeRef, typeMap);
-};
-exports.getTypeInfoFromFieldFilter = getTypeInfoFromFieldFilter;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoFromTypeAlias.d.ts

@@ -1,4 +0,0 @@
-import { TypeAliasDeclaration } from "typescript";
-import { TypeMap } from "../TypeMapping";
-import { TypeInfo } from "../TypeInfo";
-export declare const getTypeInfoFromTypeAlias: (typeAliasDec: TypeAliasDeclaration, typeMap: TypeMap) => TypeInfo | undefined;

package/src/common/TypeParsing/ParsingUtils/getTypeInfoFromTypeAlias.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeInfoFromTypeAlias = void 0;
-const extractCommentTags_1 = require("./extractCommentTags");
-const getTypeInfoFromAliasType_1 = require("./getTypeInfoFromAliasType");
-const getTypeInfoFromTypeAlias = (typeAliasDec, typeMap) => {
-    const { type } = typeAliasDec;
-    const tags = (0, extractCommentTags_1.extractCommentTags)(typeAliasDec);
-    const typeInfo = (0, getTypeInfoFromAliasType_1.getTypeInfoFromAliasType)(type, typeMap);
-    return typeInfo
-        ? {
-            ...typeInfo,
-            tags: {
-                ...tags,
-                ...typeInfo.tags,
-            },
-        }
-        : undefined;
-};
-exports.getTypeInfoFromTypeAlias = getTypeInfoFromTypeAlias;

package/src/common/TypeParsing/ParsingUtils/getTypeKeyword.d.ts

@@ -1,3 +0,0 @@
-import { TypeNode } from "typescript";
-import { TypeKeyword } from "../TypeInfo";
-export declare const getTypeKeyword: (node: TypeNode) => TypeKeyword;

package/src/common/TypeParsing/ParsingUtils/getTypeKeyword.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeKeyword = void 0;
-const typescript_1 = require("typescript");
-const getTypeKeyword = (node) => {
-    switch (node.kind) {
-        case typescript_1.SyntaxKind.StringKeyword:
-            return "string";
-        case typescript_1.SyntaxKind.NumberKeyword:
-            return "number";
-        case typescript_1.SyntaxKind.BooleanKeyword:
-            return "boolean";
-        default:
-            return "string";
-    }
-};
-exports.getTypeKeyword = getTypeKeyword;

package/src/common/TypeParsing/ParsingUtils/getUnionOrIntersectionTypeInfo.d.ts

@@ -1,4 +0,0 @@
-import { IntersectionTypeNode, UnionTypeNode } from "typescript";
-import { TypeMap } from "../TypeMapping";
-import { TypeInfo } from "../TypeInfo";
-export declare const getUnionOrIntersectionTypeInfo: (unionType: UnionTypeNode | IntersectionTypeNode, typeMap: TypeMap) => TypeInfo | undefined;

package/src/common/TypeParsing/ParsingUtils/getUnionOrIntersectionTypeInfo.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnionOrIntersectionTypeInfo = void 0;
-const typescript_1 = require("typescript");
-const getTypeInfoFromTypeAlias_1 = require("./getTypeInfoFromTypeAlias");
-const getTypeInfo_1 = require("./getTypeInfo");
-const getUnionOrIntersectionTypeInfo = (unionType, typeMap) => {
-    const { kind, types } = unionType;
-    const isUnion = kind === typescript_1.SyntaxKind.UnionType;
-    let typeInfo;
-    for (const t of types) {
-        const { kind } = t;
-        let nextTypeInfo;
-        if (kind === typescript_1.SyntaxKind.TypeReference) {
-            const { typeName } = t;
-            const refNode = typeMap[typeName.getText()];
-            if (refNode) {
-                nextTypeInfo = (0, getTypeInfoFromTypeAlias_1.getTypeInfoFromTypeAlias)(refNode, typeMap);
-            }
-        }
-        else if (kind === typescript_1.SyntaxKind.TypeLiteral) {
-            nextTypeInfo = (0, getTypeInfo_1.getTypeInfo)(t);
-        }
-        if (nextTypeInfo) {
-            const { fields: existingFields = {}, unionFieldSets: existingFieldSets = [], } = typeInfo || {};
-            const { fields: nextFields, unionFieldSets: nextUnionFieldSets = [] } = nextTypeInfo;
-            if (isUnion && nextFields) {
-                const newUnionFieldSet = Object.keys(nextFields);
-                typeInfo = {
-                    ...typeInfo,
-                    unionFieldSets: [
-                        ...existingFieldSets,
-                        ...nextUnionFieldSets,
-                        newUnionFieldSet,
-                    ],
-                };
-            }
-            typeInfo = {
-                ...typeInfo,
-                fields: {
-                    ...existingFields,
-                    ...nextFields,
-                },
-            };
-        }
-    }
-    return typeInfo;
-};
-exports.getUnionOrIntersectionTypeInfo = getUnionOrIntersectionTypeInfo;

package/src/common/TypeParsing/ParsingUtils/getUnionOrLiteralStringValues.d.ts

@@ -1,2 +0,0 @@
-import { Node } from 'typescript';
-export declare const getUnionOrLiteralStringValues: (node?: Node) => string[];

package/src/common/TypeParsing/ParsingUtils/getUnionOrLiteralStringValues.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnionOrLiteralStringValues = void 0;
-const typescript_1 = require("typescript");
-const getUnionOrLiteralStringValues = (node) => {
-    let values = [];
-    if (node) {
-        if (node.kind === typescript_1.SyntaxKind.LiteralType) {
-            const { literal } = node;
-            if (literal.kind === typescript_1.SyntaxKind.StringLiteral || literal.kind === typescript_1.SyntaxKind.NumericLiteral) {
-                const { text } = literal;
-                values = [text];
-            }
-        }
-        else if (node.kind === typescript_1.SyntaxKind.UnionType) {
-            const { types } = node;
-            for (const type of types) {
-                values = [...values, ...(0, exports.getUnionOrLiteralStringValues)(type)];
-            }
-        }
-    }
-    return values;
-};
-exports.getUnionOrLiteralStringValues = getUnionOrLiteralStringValues;