nestjs-openapi-next 1.0.0

package/dist/plugin/utils/ast-utils.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDocNode = renderDocNode;
+exports.isArray = isArray;
+exports.getTypeArguments = getTypeArguments;
+exports.isBoolean = isBoolean;
+exports.isString = isString;
+exports.isStringLiteral = isStringLiteral;
+exports.isStringMapping = isStringMapping;
+exports.isNumber = isNumber;
+exports.isBigInt = isBigInt;
+exports.isInterface = isInterface;
+exports.isEnum = isEnum;
+exports.isEnumLiteral = isEnumLiteral;
+exports.hasFlag = hasFlag;
+exports.hasObjectFlag = hasObjectFlag;
+exports.getText = getText;
+exports.getDefaultTypeFormatFlags = getDefaultTypeFormatFlags;
+exports.getDocComment = getDocComment;
+exports.getMainCommentOfNode = getMainCommentOfNode;
+exports.parseCommentDocValue = parseCommentDocValue;
+exports.getTsDocTagsOfNode = getTsDocTagsOfNode;
+exports.getTsDocErrorsOfNode = getTsDocErrorsOfNode;
+exports.getDecoratorArguments = getDecoratorArguments;
+exports.getDecoratorName = getDecoratorName;
+exports.findNullableTypeFromUnion = findNullableTypeFromUnion;
+exports.createBooleanLiteral = createBooleanLiteral;
+exports.createPrimitiveLiteral = createPrimitiveLiteral;
+exports.createLiteralFromAnyValue = createLiteralFromAnyValue;
+const tsdoc_1 = require("@microsoft/tsdoc");
+const typescript_1 = require("typescript");
+const plugin_utils_1 = require("./plugin-utils");
+function renderDocNode(docNode) {
+    let result = '';
+    if (docNode) {
+        if (docNode instanceof tsdoc_1.DocExcerpt) {
+            result += docNode.content.toString();
+        }
+        for (const childNode of docNode.getChildNodes()) {
+            result += renderDocNode(childNode);
+        }
+    }
+    return result;
+}
+function isArray(type) {
+    const symbol = type.getSymbol();
+    if (!symbol) {
+        return false;
+    }
+    return symbol.getName() === 'Array' && getTypeArguments(type).length === 1;
+}
+function getTypeArguments(type) {
+    return type.typeArguments || [];
+}
+function isBoolean(type) {
+    return hasFlag(type, typescript_1.TypeFlags.Boolean);
+}
+function isString(type) {
+    return hasFlag(type, typescript_1.TypeFlags.String);
+}
+function isStringLiteral(type) {
+    return hasFlag(type, typescript_1.TypeFlags.StringLiteral) && !type.isUnion();
+}
+function isStringMapping(type) {
+    return hasFlag(type, typescript_1.TypeFlags.StringMapping);
+}
+function isNumber(type) {
+    return hasFlag(type, typescript_1.TypeFlags.Number);
+}
+function isBigInt(type) {
+    return hasFlag(type, typescript_1.TypeFlags.BigInt);
+}
+function isInterface(type) {
+    return hasObjectFlag(type, typescript_1.ObjectFlags.Interface);
+}
+function isEnum(type) {
+    const hasEnumFlag = hasFlag(type, typescript_1.TypeFlags.Enum);
+    if (hasEnumFlag) {
+        return true;
+    }
+    if (isEnumLiteral(type)) {
+        return false;
+    }
+    const symbol = type.getSymbol();
+    if (!symbol) {
+        return false;
+    }
+    const valueDeclaration = symbol.valueDeclaration;
+    if (!valueDeclaration) {
+        return false;
+    }
+    return valueDeclaration.kind === typescript_1.SyntaxKind.EnumDeclaration;
+}
+function isEnumLiteral(type) {
+    return hasFlag(type, typescript_1.TypeFlags.EnumLiteral) && !type.isUnion();
+}
+function hasFlag(type, flag) {
+    return (type.flags & flag) === flag;
+}
+function hasObjectFlag(type, flag) {
+    return (type.objectFlags & flag) === flag;
+}
+function getText(type, typeChecker, enclosingNode, typeFormatFlags) {
+    if (!typeFormatFlags) {
+        typeFormatFlags = getDefaultTypeFormatFlags(enclosingNode);
+    }
+    const compilerNode = !enclosingNode ? undefined : enclosingNode;
+    return typeChecker.typeToString(type, compilerNode, typeFormatFlags);
+}
+function getDefaultTypeFormatFlags(enclosingNode) {
+    let formatFlags = typescript_1.TypeFormatFlags.UseTypeOfFunction |
+        typescript_1.TypeFormatFlags.NoTruncation |
+        typescript_1.TypeFormatFlags.UseFullyQualifiedType |
+        typescript_1.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+    if (enclosingNode && enclosingNode.kind === typescript_1.SyntaxKind.TypeAliasDeclaration)
+        formatFlags |= typescript_1.TypeFormatFlags.InTypeAlias;
+    return formatFlags;
+}
+function getDocComment(node) {
+    const tsdocParser = new tsdoc_1.TSDocParser();
+    const parserContext = tsdocParser.parseString(node.getFullText());
+    return parserContext.docComment;
+}
+function getMainCommentOfNode(node) {
+    const docComment = getDocComment(node);
+    return renderDocNode(docComment.summarySection).trim();
+}
+function parseCommentDocValue(docValue, type) {
+    let value = docValue.replace(/'/g, '"').trim();
+    if (!type || !isString(type)) {
+        try {
+            value = JSON.parse(value);
+        }
+        catch (_a) {
+        }
+    }
+    else if (isString(type)) {
+        if (value.split(' ').length !== 1 && !value.startsWith('"')) {
+            value = null;
+        }
+        else {
+            value = value.replace(/"/g, '');
+        }
+    }
+    return value;
+}
+function getTsDocTagsOfNode(node, typeChecker) {
+    const docComment = getDocComment(node);
+    const tagDefinitions = {
+        example: {
+            hasProperties: true,
+            repeatable: true
+        }
+    };
+    const tagResults = {};
+    const introspectTsDocTags = (docComment) => {
+        for (const tag in tagDefinitions) {
+            const { hasProperties, repeatable } = tagDefinitions[tag];
+            const blocks = docComment.customBlocks.filter((block) => block.blockTag.tagName === `@${tag}`);
+            if (blocks.length === 0) {
+                continue;
+            }
+            if (repeatable && !tagResults[tag]) {
+                tagResults[tag] = [];
+            }
+            const type = typeChecker.getTypeAtLocation(node);
+            if (hasProperties) {
+                blocks.forEach((block) => {
+                    const docValue = renderDocNode(block.content).split('\n')[0];
+                    const value = parseCommentDocValue(docValue, type);
+                    if (value !== null) {
+                        if (repeatable) {
+                            tagResults[tag].push(value);
+                        }
+                        else {
+                            tagResults[tag] = value;
+                        }
+                    }
+                });
+            }
+            else {
+                tagResults[tag] = true;
+            }
+        }
+        if (docComment.remarksBlock) {
+            tagResults['remarks'] = renderDocNode(docComment.remarksBlock.content).trim();
+        }
+        if (docComment.deprecatedBlock) {
+            tagResults['deprecated'] = true;
+        }
+    };
+    introspectTsDocTags(docComment);
+    return tagResults;
+}
+function getTsDocErrorsOfNode(node) {
+    const tsdocParser = new tsdoc_1.TSDocParser();
+    const parserContext = tsdocParser.parseString(node.getFullText());
+    const docComment = parserContext.docComment;
+    const tagResults = [];
+    const errorParsingRegex = /{(\d+)} (.*)/;
+    const introspectTsDocTags = (docComment) => {
+        const blocks = docComment.customBlocks.filter((block) => block.blockTag.tagName === '@throws');
+        blocks.forEach((block) => {
+            try {
+                const docValue = renderDocNode(block.content).split('\n')[0].trim();
+                const match = docValue.match(errorParsingRegex);
+                tagResults.push({
+                    status: match[1],
+                    description: `"${match[2]}"`
+                });
+            }
+            catch (_a) {
+            }
+        });
+    };
+    introspectTsDocTags(docComment);
+    return tagResults;
+}
+function getDecoratorArguments(decorator) {
+    const callExpression = decorator.expression;
+    return (callExpression && callExpression.arguments) || [];
+}
+function getDecoratorName(decorator) {
+    const isDecoratorFactory = decorator.expression.kind === typescript_1.SyntaxKind.CallExpression;
+    if (isDecoratorFactory) {
+        const callExpression = decorator.expression;
+        const identifier = callExpression
+            .expression;
+        if ((0, plugin_utils_1.isDynamicallyAdded)(identifier)) {
+            return undefined;
+        }
+        return getIdentifierFromName(callExpression.expression).getText();
+    }
+    return getIdentifierFromName(decorator.expression).getText();
+}
+function getIdentifierFromName(expression) {
+    const identifier = getNameFromExpression(expression);
+    if (expression && expression.kind !== typescript_1.SyntaxKind.Identifier) {
+        throw new Error();
+    }
+    return identifier;
+}
+function getNameFromExpression(expression) {
+    if (expression && expression.kind === typescript_1.SyntaxKind.PropertyAccessExpression) {
+        return expression.name;
+    }
+    return expression;
+}
+function findNullableTypeFromUnion(typeNode, typeChecker) {
+    return typeNode.types.find((tNode) => hasFlag(typeChecker.getTypeAtLocation(tNode), typescript_1.TypeFlags.Null));
+}
+function createBooleanLiteral(factory, flag) {
+    return flag ? factory.createTrue() : factory.createFalse();
+}
+function createPrimitiveLiteral(factory, item, typeOfItem = typeof item) {
+    switch (typeOfItem) {
+        case 'boolean':
+            return createBooleanLiteral(factory, item);
+        case 'number': {
+            if (item < 0) {
+                return factory.createPrefixUnaryExpression(typescript_1.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(item)));
+            }
+            return factory.createNumericLiteral(item);
+        }
+        case 'string':
+            return factory.createStringLiteral(item);
+    }
+}
+function createLiteralFromAnyValue(factory, item) {
+    return Array.isArray(item)
+        ? factory.createArrayLiteralExpression(item.map((item) => createLiteralFromAnyValue(factory, item)))
+        : createPrimitiveLiteral(factory, item);
+}

package/dist/plugin/utils/is-filename-matched.util.d.ts

@@ -0,0 +1 @@
+export declare const isFilenameMatched: (patterns: string[], filename: string) => boolean;

package/dist/plugin/utils/is-filename-matched.util.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFilenameMatched = void 0;
+const isFilenameMatched = (patterns, filename) => patterns.some((path) => filename.includes(path));
+exports.isFilenameMatched = isFilenameMatched;

package/dist/plugin/utils/plugin-utils.d.ts

@@ -0,0 +1,30 @@
+import * as ts from 'typescript';
+import { PluginOptions } from '../merge-options';
+export declare function getDecoratorOrUndefinedByNames(names: string[], decorators: readonly ts.Decorator[], factory: ts.NodeFactory): ts.Decorator | undefined;
+export declare function getTypeReferenceAsString(type: ts.Type, typeChecker: ts.TypeChecker, arrayDepth?: number): {
+    typeName: string;
+    isArray?: boolean;
+    arrayDepth?: number;
+};
+export declare function isPromiseOrObservable(type: string): boolean;
+export declare function hasPropertyKey(key: string, properties: ts.NodeArray<ts.PropertyAssignment>): boolean;
+export declare function getOutputExtension(fileName: string): string;
+export declare function replaceImportPath(typeReference: string, fileName: string, options: PluginOptions): {
+    typeReference: string;
+    typeName: string;
+    importPath: string;
+} | {
+    typeReference: string;
+    importPath: string;
+    typeName?: undefined;
+};
+export declare function insertAt(string: string, index: number, substring: string): string;
+export declare function isDynamicallyAdded(identifier: ts.Node): boolean;
+export declare function isAutoGeneratedEnumUnion(type: ts.Type, typeChecker: ts.TypeChecker): ts.Type;
+export declare function isAutoGeneratedTypeUnion(type: ts.Type): boolean;
+export declare function extractTypeArgumentIfArray(type: ts.Type): {
+    type: ts.Type;
+    isArray: boolean;
+};
+export declare function convertPath(windowsPath: string): string;
+export declare function canReferenceNode(node: ts.Node, options: PluginOptions): boolean;

package/dist/plugin/utils/plugin-utils.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDecoratorOrUndefinedByNames = getDecoratorOrUndefinedByNames;
+exports.getTypeReferenceAsString = getTypeReferenceAsString;
+exports.isPromiseOrObservable = isPromiseOrObservable;
+exports.hasPropertyKey = hasPropertyKey;
+exports.getOutputExtension = getOutputExtension;
+exports.replaceImportPath = replaceImportPath;
+exports.insertAt = insertAt;
+exports.isDynamicallyAdded = isDynamicallyAdded;
+exports.isAutoGeneratedEnumUnion = isAutoGeneratedEnumUnion;
+exports.isAutoGeneratedTypeUnion = isAutoGeneratedTypeUnion;
+exports.extractTypeArgumentIfArray = extractTypeArgumentIfArray;
+exports.convertPath = convertPath;
+exports.canReferenceNode = canReferenceNode;
+const lodash_1 = require("lodash");
+const path_1 = require("path");
+const ts = require("typescript");
+const ast_utils_1 = require("./ast-utils");
+function getDecoratorOrUndefinedByNames(names, decorators, factory) {
+    return (decorators || factory.createNodeArray()).find((item) => {
+        try {
+            const decoratorName = (0, ast_utils_1.getDecoratorName)(item);
+            return names.includes(decoratorName);
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function getTypeReferenceAsString(type, typeChecker, arrayDepth = 0) {
+    if ((0, ast_utils_1.isArray)(type)) {
+        const arrayType = (0, ast_utils_1.getTypeArguments)(type)[0];
+        const { typeName, arrayDepth: depth } = getTypeReferenceAsString(arrayType, typeChecker, arrayDepth + 1);
+        if (!typeName) {
+            return { typeName: undefined };
+        }
+        return {
+            typeName: `${typeName}`,
+            isArray: true,
+            arrayDepth: depth
+        };
+    }
+    if ((0, ast_utils_1.isBoolean)(type)) {
+        return { typeName: Boolean.name, arrayDepth };
+    }
+    if ((0, ast_utils_1.isNumber)(type)) {
+        return { typeName: Number.name, arrayDepth };
+    }
+    if ((0, ast_utils_1.isBigInt)(type)) {
+        return { typeName: BigInt.name, arrayDepth };
+    }
+    if ((0, ast_utils_1.isString)(type) || (0, ast_utils_1.isStringLiteral)(type) || (0, ast_utils_1.isStringMapping)(type)) {
+        return { typeName: String.name, arrayDepth };
+    }
+    if (isPromiseOrObservable((0, ast_utils_1.getText)(type, typeChecker))) {
+        const typeArguments = (0, ast_utils_1.getTypeArguments)(type);
+        const elementType = getTypeReferenceAsString((0, lodash_1.head)(typeArguments), typeChecker, arrayDepth);
+        return elementType;
+    }
+    if (type.isClass()) {
+        return { typeName: (0, ast_utils_1.getText)(type, typeChecker), arrayDepth };
+    }
+    try {
+        const text = (0, ast_utils_1.getText)(type, typeChecker);
+        if (text === Date.name) {
+            return { typeName: text, arrayDepth };
+        }
+        if (isOptionalBoolean(text)) {
+            return { typeName: Boolean.name, arrayDepth };
+        }
+        if (isAutoGeneratedTypeUnion(type) ||
+            isAutoGeneratedEnumUnion(type, typeChecker)) {
+            const types = type.types;
+            return getTypeReferenceAsString(types[types.length - 1], typeChecker, arrayDepth);
+        }
+        if (text === 'any' ||
+            text === 'unknown' ||
+            text === 'object' ||
+            (0, ast_utils_1.isInterface)(type) ||
+            (type.isUnionOrIntersection() && !(0, ast_utils_1.isEnum)(type))) {
+            return { typeName: 'Object', arrayDepth };
+        }
+        if ((0, ast_utils_1.isEnum)(type)) {
+            return { typeName: undefined, arrayDepth };
+        }
+        if (type.aliasSymbol) {
+            return { typeName: 'Object', arrayDepth };
+        }
+        if (typeChecker.getApparentType(type).getSymbol().getEscapedName() ===
+            'String') {
+            return { typeName: String.name, arrayDepth };
+        }
+        return { typeName: undefined };
+    }
+    catch (_a) {
+        return { typeName: undefined };
+    }
+}
+function isPromiseOrObservable(type) {
+    return type.includes('Promise<') || type.includes('Observable<');
+}
+function hasPropertyKey(key, properties) {
+    return properties
+        .filter((item) => !isDynamicallyAdded(item))
+        .some((item) => item.name.getText() === key);
+}
+function getOutputExtension(fileName) {
+    if (fileName.endsWith('.mts')) {
+        return '.mjs';
+    }
+    else if (fileName.endsWith('.cts')) {
+        return '.cjs';
+    }
+    else {
+        return '.js';
+    }
+}
+function replaceImportPath(typeReference, fileName, options) {
+    if (!typeReference.includes('import')) {
+        return { typeReference, importPath: null };
+    }
+    if (options.esmCompatible) {
+        typeReference = typeReference.replace(', { with: { "resolution-mode": "import" } }', '');
+    }
+    let importPath = /\(\"([^)]).+(\")/.exec(typeReference)[0];
+    if (!importPath) {
+        return { typeReference: undefined, importPath: null };
+    }
+    importPath = convertPath(importPath);
+    importPath = importPath.slice(2, importPath.length - 1);
+    try {
+        if ((0, path_1.isAbsolute)(importPath)) {
+            throw new Error('Absolute import paths are not supported.');
+        }
+        require.resolve(importPath);
+        if (!options.esmCompatible) {
+            typeReference = typeReference.replace('import', 'require');
+        }
+        return {
+            typeReference,
+            importPath: null
+        };
+    }
+    catch (_a) {
+        const from = (options === null || options === void 0 ? void 0 : options.readonly)
+            ? convertPath(options.pathToSource)
+            : path_1.posix.dirname(convertPath(fileName));
+        let relativePath = path_1.posix.relative(from, importPath);
+        relativePath = relativePath[0] !== '.' ? './' + relativePath : relativePath;
+        const nodeModulesText = 'node_modules';
+        const nodeModulePos = relativePath.indexOf(nodeModulesText);
+        if (nodeModulePos >= 0) {
+            relativePath = relativePath.slice(nodeModulePos + nodeModulesText.length + 1);
+            const typesText = '@types';
+            const typesPos = relativePath.indexOf(typesText);
+            if (typesPos >= 0) {
+                relativePath = relativePath.slice(typesPos + typesText.length + 1);
+            }
+            const indexText = '/index';
+            const indexPos = relativePath.indexOf(indexText);
+            if (indexPos >= 0) {
+                relativePath = relativePath.slice(0, indexPos);
+            }
+        }
+        else if (options.esmCompatible) {
+            const extension = getOutputExtension(fileName);
+            relativePath += extension;
+        }
+        typeReference = typeReference.replace(importPath, relativePath);
+        if (options.readonly) {
+            const { typeName, typeImportStatement } = convertToAsyncImport(typeReference);
+            return {
+                typeReference: typeImportStatement,
+                typeName,
+                importPath: relativePath
+            };
+        }
+        if (options.esmCompatible) {
+            const { typeName, typeImportStatement } = convertToAsyncImport(typeReference);
+            return {
+                typeReference: `(${typeImportStatement}).${typeName}`,
+                importPath: relativePath
+            };
+        }
+        return {
+            typeReference: typeReference.replace('import', 'require'),
+            importPath: relativePath
+        };
+    }
+}
+function convertToAsyncImport(typeReference) {
+    const regexp = /import\(.+\).([^\]]+)(\])?/;
+    const match = regexp.exec(typeReference);
+    if ((match === null || match === void 0 ? void 0 : match.length) >= 2) {
+        const importPos = typeReference.indexOf(match[0]);
+        typeReference = typeReference.replace(`.${match[1]}`, '');
+        return {
+            typeImportStatement: insertAt(typeReference, importPos, 'await '),
+            typeName: match[1]
+        };
+    }
+    return { typeImportStatement: typeReference };
+}
+function insertAt(string, index, substring) {
+    return string.slice(0, index) + substring + string.slice(index);
+}
+function isDynamicallyAdded(identifier) {
+    return identifier && !identifier.parent && identifier.pos === -1;
+}
+function isAutoGeneratedEnumUnion(type, typeChecker) {
+    if (type.isUnionOrIntersection() && !(0, ast_utils_1.isEnum)(type)) {
+        if (!type.types) {
+            return undefined;
+        }
+        const undefinedTypeIndex = type.types.findIndex((type) => type.intrinsicName === 'undefined' || type.intrinsicName === 'null');
+        if (undefinedTypeIndex < 0) {
+            return undefined;
+        }
+        let parentType = undefined;
+        const isParentSymbolEqual = type.types.every((item, index) => {
+            if (index === undefinedTypeIndex) {
+                return true;
+            }
+            if (!item.symbol) {
+                return false;
+            }
+            if (!item.symbol.parent ||
+                item.symbol.flags !== ts.SymbolFlags.EnumMember) {
+                return false;
+            }
+            const symbolType = typeChecker.getDeclaredTypeOfSymbol(item.symbol.parent);
+            if (symbolType === parentType || !parentType) {
+                parentType = symbolType;
+                return true;
+            }
+            return false;
+        });
+        if (isParentSymbolEqual) {
+            return parentType;
+        }
+    }
+    return undefined;
+}
+function isAutoGeneratedTypeUnion(type) {
+    if (type.isUnionOrIntersection() && !(0, ast_utils_1.isEnum)(type)) {
+        if (!type.types) {
+            return false;
+        }
+        const undefinedTypeIndex = type.types.findIndex((type) => type.intrinsicName === 'undefined');
+        if (type.types.length === 2 && undefinedTypeIndex >= 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function extractTypeArgumentIfArray(type) {
+    if ((0, ast_utils_1.isArray)(type)) {
+        type = (0, ast_utils_1.getTypeArguments)(type)[0];
+        if (!type) {
+            return undefined;
+        }
+        return {
+            type,
+            isArray: true
+        };
+    }
+    return {
+        type,
+        isArray: false
+    };
+}
+function isOptionalBoolean(text) {
+    return typeof text === 'string' && text === 'boolean | undefined';
+}
+function convertPath(windowsPath) {
+    return windowsPath
+        .replace(/^\\\\\?\\/, '')
+        .replace(/\\/g, '/')
+        .replace(/\/\/+/g, '/');
+}
+function canReferenceNode(node, options) {
+    var _a;
+    if (!options.readonly) {
+        return true;
+    }
+    if (ts.isCallExpression(node) || ts.isIdentifier(node)) {
+        return false;
+    }
+    if (ts.isNewExpression(node)) {
+        if (((_a = node.expression) === null || _a === void 0 ? void 0 : _a.escapedText) === 'Date') {
+            return true;
+        }
+        return false;
+    }
+    if (node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword) {
+        return true;
+    }
+    if (ts.isNumericLiteral(node) ||
+        ts.isPrefixUnaryExpression(node) ||
+        ts.isStringLiteral(node)) {
+        return true;
+    }
+    return false;
+}

package/dist/plugin/utils/type-reference-to-identifier.util.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { PluginOptions } from '../merge-options';
+export declare function typeReferenceToIdentifier(typeReferenceDescriptor: {
+    typeName: string;
+    isArray?: boolean;
+    arrayDepth?: number;
+}, hostFilename: string, options: PluginOptions, factory: ts.NodeFactory, type: ts.Type, typeImports: Record<string, string>): ts.Identifier;

package/dist/plugin/utils/type-reference-to-identifier.util.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeReferenceToIdentifier = typeReferenceToIdentifier;
+const plugin_debug_logger_1 = require("../plugin-debug-logger");
+const plugin_utils_1 = require("./plugin-utils");
+function typeReferenceToIdentifier(typeReferenceDescriptor, hostFilename, options, factory, type, typeImports) {
+    if (options.readonly) {
+        assertReferenceableType(type, typeReferenceDescriptor.typeName, hostFilename, options);
+    }
+    const { typeReference, importPath, typeName } = (0, plugin_utils_1.replaceImportPath)(typeReferenceDescriptor.typeName, hostFilename, options);
+    let identifier;
+    if (options.readonly && (typeReference === null || typeReference === void 0 ? void 0 : typeReference.includes('import'))) {
+        if (!typeImports[importPath]) {
+            typeImports[importPath] = typeReference;
+        }
+        let ref = `t["${importPath}"].${typeName}`;
+        if (typeReferenceDescriptor.isArray) {
+            ref = wrapTypeInArray(ref, typeReferenceDescriptor.arrayDepth);
+        }
+        identifier = factory.createIdentifier(ref);
+    }
+    else {
+        let ref = typeReference;
+        if (typeReferenceDescriptor.isArray) {
+            ref = wrapTypeInArray(ref, typeReferenceDescriptor.arrayDepth);
+        }
+        identifier = factory.createIdentifier(ref);
+    }
+    return identifier;
+}
+function wrapTypeInArray(typeRef, arrayDepth) {
+    for (let i = 0; i < arrayDepth; i++) {
+        typeRef = `[${typeRef}]`;
+    }
+    return typeRef;
+}
+function assertReferenceableType(type, parsedTypeName, hostFilename, options) {
+    if (!type.symbol) {
+        return true;
+    }
+    if (!type.symbol.isReferenced) {
+        return true;
+    }
+    if (parsedTypeName.includes('import')) {
+        return true;
+    }
+    const errorMessage = `Type "${parsedTypeName}" is not referenceable ("${hostFilename}"). To fix this, make sure to export this type.`;
+    if (options.debug) {
+        plugin_debug_logger_1.pluginDebugLogger.debug(errorMessage);
+    }
+    throw new Error(errorMessage);
+}

package/dist/plugin/visitors/abstract.visitor.d.ts

@@ -0,0 +1,4 @@
+import * as ts from 'typescript';
+export declare class AbstractFileVisitor {
+    updateImports(sourceFile: ts.SourceFile, factory: ts.NodeFactory | undefined, program: ts.Program): ts.SourceFile;
+}