@rightcapital/phpdoc-parser 0.3.52--.370.1.0 → 0.3.52--.372.1.0

package/dist/index.d.ts

@@ -73,3 +73,4 @@ export { ReturnTagValueNode } from './phpdoc-parser/ast/php-doc/return-tag-value
 export { Printer } from './phpdoc-parser/printer/printer';
 export { PhpDocTypeNodeToTypescriptTypeNodeTranspiler } from './phpdoc-parser/transpiler/php-doc-to-typescript-type-transpiler';
 export * from './phpdoc-parser/ast/php-doc/helpers';
+export * from './phpdoc-parser/transpiler/helpers';

package/dist/index.js

@@ -162,3 +162,4 @@ Object.defineProperty(exports, "Printer", { enumerable: true, get: function () {
 var php_doc_to_typescript_type_transpiler_1 = require("./phpdoc-parser/transpiler/php-doc-to-typescript-type-transpiler");
 Object.defineProperty(exports, "PhpDocTypeNodeToTypescriptTypeNodeTranspiler", { enumerable: true, get: function () { return php_doc_to_typescript_type_transpiler_1.PhpDocTypeNodeToTypescriptTypeNodeTranspiler; } });
 __exportStar(require("./phpdoc-parser/ast/php-doc/helpers"), exports);
+__exportStar(require("./phpdoc-parser/transpiler/helpers"), exports);

package/dist/phpdoc-parser/transpiler/helpers.d.ts

@@ -1,50 +1,10 @@
-import * as ts from 'typescript';
-export declare function createSourceFileRoot(fileName: string, sourceText?: string, scriptTarget?: ts.ScriptTarget, scriptKind?: ts.ScriptKind): ts.SourceFile;
-export declare function addStatementsToNode(sourceFile: ts.SourceFile, newStatements: ts.Statement[]): ts.SourceFile;
-export declare function renderTsNodeToString(tsNode: ts.TypeNode | ts.ImportDeclaration): string;
-export declare function createImportDeclarationNode(symbols: string[], fileName: string): ts.ImportDeclaration;
-export declare function createExportDeclarationNode(symbols: string[], moduleSpecifierString?: string): ts.ExportDeclaration;
-export declare function createInterfaceNode(interfaceName: string, members?: ts.TypeElement[], typeParameters?: ts.TypeParameterDeclaration[]): ts.InterfaceDeclaration;
-export declare function createCommentNode(commentText: string, isMultiLine?: boolean, hasTrailingNewLine?: boolean): ts.Statement;
-export declare function createEnumNode(enumName: string, members: [string, number | string][], isConst?: boolean): ts.EnumDeclaration;
-type PhpDocNode = {
-    nodeType: string;
-    children: PhpDocTagNode[];
-};
-type PhpDocTagNode = {
-    nodeType: string;
-    name: string;
-    value: PropertyTagValueNode;
-};
-type PropertyTagValueNode = {
-    nodeType: string;
-    type: UnionTypeNode | ArrayShapeNode;
-    propertyName: string;
-    description: string;
-};
-type UnionTypeNode = {
-    nodeType: string;
-    types: IdentifierTypeNode[];
-};
-type IdentifierTypeNode = {
-    nodeType: string;
-    name: string;
-};
-type ArrayShapeNode = {
-    nodeType: string;
-    items: ArrayShapeItemNode[];
-    sealed: boolean;
-    kind: string;
-};
-type ArrayShapeItemNode = {
-    nodeType: string;
-    keyName: IdentifierTypeNode;
-    optional: boolean;
-    valueType: IdentifierTypeNode;
-};
-type TsProperty = {
-    propertyName: string;
-    type: string;
-};
-export declare function transformPhpDocToTypeScriptObject(phpDocNode: PhpDocNode): TsProperty[];
-export {};
+import { type ImportDeclaration, type ExportDeclaration, type TypeElement, type TypeParameterDeclaration, type HeritageClause, type InterfaceDeclaration, ScriptTarget, type SourceFile, ScriptKind, type Statement, type EnumDeclaration, type ModifierSyntaxKind, type Node } from 'typescript';
+export declare function createSourceFileRoot(fileName: string, sourceText?: string, scriptTarget?: ScriptTarget, scriptKind?: ScriptKind): SourceFile;
+export declare function addStatementsToNode(sourceFile: SourceFile, newStatements: Statement[]): SourceFile;
+export declare function createImportDeclarationNode(symbols: string[], filePath: string): ImportDeclaration;
+export declare function createExportDeclarationNode(symbols: string[], moduleSpecifierString?: string): ExportDeclaration;
+export declare function createInterfaceNode(interfaceName: string, members?: TypeElement[], typeParameters?: TypeParameterDeclaration[], heritageClauses?: HeritageClause[]): InterfaceDeclaration;
+export declare function createCommentNode(commentText: string, isMultiLine?: boolean, hasTrailingNewLine?: boolean): Statement;
+export declare function createEnumNode(enumName: string, members: [string, number | string][], modifiers: ModifierSyntaxKind[]): EnumDeclaration;
+export declare function renderTsNodeToString(tsNode: Node): string;
+export declare function renderTsSourceFileToString(sourceFile: SourceFile): string;

package/dist/phpdoc-parser/transpiler/helpers.js

@@ -1,51 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformPhpDocToTypeScriptObject = exports.createEnumNode = exports.createCommentNode = exports.createInterfaceNode = exports.createExportDeclarationNode = exports.createImportDeclarationNode = exports.renderTsNodeToString = exports.addStatementsToNode = exports.createSourceFileRoot = void 0;
-const _ = require("lodash");
-const ts = require("typescript");
-function createSourceFileRoot(fileName, sourceText = '', scriptTarget = ts.ScriptTarget.Latest, scriptKind = ts.ScriptKind.TS) {
-    const sourceFile = ts.createSourceFile(fileName, sourceText, scriptTarget, true, scriptKind);
+exports.renderTsSourceFileToString = exports.renderTsNodeToString = exports.createEnumNode = exports.createCommentNode = exports.createInterfaceNode = exports.createExportDeclarationNode = exports.createImportDeclarationNode = exports.addStatementsToNode = exports.createSourceFileRoot = void 0;
+const typescript_1 = require("typescript");
+function createSourceFileRoot(fileName, sourceText = '', scriptTarget = typescript_1.ScriptTarget.Latest, scriptKind = typescript_1.ScriptKind.TS) {
+    const sourceFile = (0, typescript_1.createSourceFile)(fileName, sourceText, scriptTarget, true, scriptKind);
     return sourceFile;
 }
 exports.createSourceFileRoot = createSourceFileRoot;
 function addStatementsToNode(sourceFile, newStatements) {
-    const updatedStatements = ts.factory.createNodeArray([
+    const updatedStatements = typescript_1.factory.createNodeArray([
         ...sourceFile.statements,
         ...newStatements,
     ]);
-    return ts.factory.updateSourceFile(sourceFile, updatedStatements);
+    return typescript_1.factory.updateSourceFile(sourceFile, updatedStatements);
 }
 exports.addStatementsToNode = addStatementsToNode;
-function renderTsNodeToString(tsNode) {
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-    const resultFile = createSourceFileRoot('example.ts');
-    return printer.printNode(ts.EmitHint.Unspecified, tsNode, resultFile);
-}
-exports.renderTsNodeToString = renderTsNodeToString;
-function createImportDeclarationNode(symbols, fileName) {
-    const importClause = ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(symbols.map((symbol) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(symbol)))));
-    const moduleSpecifier = ts.factory.createStringLiteral(fileName);
-    const importDeclaration = ts.factory.createImportDeclaration(undefined, importClause, moduleSpecifier);
+function createImportDeclarationNode(symbols, filePath) {
+    const importClause = typescript_1.factory.createImportClause(true, undefined, typescript_1.factory.createNamedImports(symbols.map((symbol) => typescript_1.factory.createImportSpecifier(false, undefined, typescript_1.factory.createIdentifier(symbol)))));
+    const moduleSpecifier = typescript_1.factory.createStringLiteral(filePath);
+    const importDeclaration = typescript_1.factory.createImportDeclaration(undefined, importClause, moduleSpecifier);
     return importDeclaration;
 }
 exports.createImportDeclarationNode = createImportDeclarationNode;
 function createExportDeclarationNode(symbols, moduleSpecifierString) {
-    const exportSpecifiers = symbols.map((symbol) => ts.factory.createExportSpecifier(false, undefined, ts.factory.createIdentifier(symbol)));
-    const namedExports = ts.factory.createNamedExports(exportSpecifiers);
+    const exportSpecifiers = symbols.map((symbol) => typescript_1.factory.createExportSpecifier(false, undefined, typescript_1.factory.createIdentifier(symbol)));
+    const namedExports = typescript_1.factory.createNamedExports(exportSpecifiers);
     const moduleSpecifier = moduleSpecifierString
-        ? ts.factory.createStringLiteral(moduleSpecifierString)
+        ? typescript_1.factory.createStringLiteral(moduleSpecifierString)
         : undefined;
-    const exportDeclaration = ts.factory.createExportDeclaration(undefined, false, namedExports, moduleSpecifier);
+    const exportDeclaration = typescript_1.factory.createExportDeclaration(undefined, false, namedExports, moduleSpecifier);
     return exportDeclaration;
 }
 exports.createExportDeclarationNode = createExportDeclarationNode;
-function createInterfaceNode(interfaceName, members = [], typeParameters = []) {
-    const interfaceDeclaration = ts.factory.createInterfaceDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(interfaceName), typeParameters, undefined, members);
+function createInterfaceNode(interfaceName, members = [], typeParameters = [], heritageClauses = []) {
+    const interfaceDeclaration = typescript_1.factory.createInterfaceDeclaration([typescript_1.factory.createModifier(typescript_1.SyntaxKind.ExportKeyword)], typescript_1.factory.createIdentifier(interfaceName), typeParameters, heritageClauses, members);
     return interfaceDeclaration;
 }
 exports.createInterfaceNode = createInterfaceNode;
 function createCommentNode(commentText, isMultiLine = true, hasTrailingNewLine = true) {
-    const emptyStatement = ts.factory.createEmptyStatement();
+    const emptyStatement = typescript_1.factory.createEmptyStatement();
     let formattedCommentText;
     if (isMultiLine) {
         formattedCommentText = `*\n * ${commentText.split('\n').join('\n * ')}\n `;
@@ -53,76 +46,29 @@ function createCommentNode(commentText, isMultiLine = true, hasTrailingNewLine =
     else {
         formattedCommentText = commentText;
     }
-    const emptyStatementWithComment = ts.addSyntheticLeadingComment(emptyStatement, isMultiLine
-        ? ts.SyntaxKind.MultiLineCommentTrivia
-        : ts.SyntaxKind.SingleLineCommentTrivia, formattedCommentText, hasTrailingNewLine);
+    const emptyStatementWithComment = (0, typescript_1.addSyntheticLeadingComment)(emptyStatement, isMultiLine
+        ? typescript_1.SyntaxKind.MultiLineCommentTrivia
+        : typescript_1.SyntaxKind.SingleLineCommentTrivia, formattedCommentText, hasTrailingNewLine);
     return emptyStatementWithComment;
 }
 exports.createCommentNode = createCommentNode;
-function createEnumNode(enumName, members, isConst = false) {
-    const memberNodes = members.map(([key, value]) => ts.factory.createEnumMember(key, typeof value === 'number'
-        ? ts.factory.createNumericLiteral(value)
-        : ts.factory.createStringLiteral(value)));
-    const enumDeclaration = ts.factory.createEnumDeclaration(isConst
-        ? [
-            ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-            ts.factory.createModifier(ts.SyntaxKind.ConstKeyword),
-        ]
-        : [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(enumName), memberNodes);
+function createEnumNode(enumName, members, modifiers) {
+    const memberNodes = members.map(([key, value]) => typescript_1.factory.createEnumMember(key, typeof value === 'number'
+        ? typescript_1.factory.createNumericLiteral(value)
+        : typescript_1.factory.createStringLiteral(value)));
+    const enumDeclaration = typescript_1.factory.createEnumDeclaration(modifiers.map((modifier) => typescript_1.factory.createToken(modifier)), typescript_1.factory.createIdentifier(enumName), memberNodes);
     return enumDeclaration;
 }
 exports.createEnumNode = createEnumNode;
-function transformPhpDocToTypeScriptObject(phpDocNode) {
-    return phpDocNode.children
-        .filter((tag) => tag.name === '@property-read' || tag.name === '@property')
-        .map((tag) => {
-        const propertyName = _.camelCase(tag.value.propertyName.replace(/^\$/, ''));
-        const type = transformTypeNodeToTypeScript(tag.value.type);
-        return { propertyName, type };
-    });
-}
-exports.transformPhpDocToTypeScriptObject = transformPhpDocToTypeScriptObject;
-function transformTypeNodeToTypeScript(typeNode) {
-    if (typeNode.nodeType === 'UnionTypeNode') {
-        return typeNode.types
-            .map((t) => transformIdentifierTypeNodeToTypeScript(t))
-            .join(' | ');
-    }
-    if (typeNode.nodeType === 'ArrayShapeNode') {
-        const entries = typeNode.items
-            .map((item) => `${_.camelCase(item.keyName.name)}${item.optional ? '?' : ''}: ${transformIdentifierTypeNodeToTypeScript(item.valueType)}`)
-            .join('; ');
-        return `{ ${entries} }`;
-    }
-    return 'any';
+function renderTsNodeToString(tsNode) {
+    const printer = (0, typescript_1.createPrinter)({ newLine: typescript_1.NewLineKind.LineFeed });
+    const resultFile = createSourceFileRoot('temp.ts');
+    return printer.printNode(typescript_1.EmitHint.Unspecified, tsNode, resultFile);
 }
-function transformIdentifierTypeNodeToTypeScript(identifierTypeNode) {
-    switch (identifierTypeNode.name) {
-        case 'string':
-        case 'int':
-        case 'null':
-            return identifierTypeNode.name;
-        case 'float':
-            return 'number';
-        case 'boolean':
-        case 'bool':
-            return 'boolean';
-        case 'date':
-        case 'datetime':
-        case 'immutable_date':
-        case 'immutable_datetime':
-        case 'CarbonInterface':
-        case '\\Carbon\\CarbonInterface':
-        case '\\Carbon\\Carbon':
-        case '\\Carbon\\CarbonImmutable':
-            return 'string';
-        case 'array':
-            return 'any';
-        case 'Collection':
-            return 'any[]';
-        case 'mixed':
-            return 'any';
-        default:
-            return 'any';
-    }
+exports.renderTsNodeToString = renderTsNodeToString;
+function renderTsSourceFileToString(sourceFile) {
+    const printer = (0, typescript_1.createPrinter)({ newLine: typescript_1.NewLineKind.LineFeed });
+    const sourceFileContent = printer.printFile(sourceFile);
+    return sourceFileContent;
 }
+exports.renderTsSourceFileToString = renderTsSourceFileToString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rightcapital/phpdoc-parser",
-  "version": "0.3.52-.370.1.0",
+  "version": "0.3.52-.372.1.0",
   "keywords": [
     "PHP",
     "PHPDoc",

package/dist/phpdoc-parser/transpiler/base-type-transpiler.d.ts

@@ -1,17 +0,0 @@
-import type { ImportDeclaration, TypeNode } from 'typescript';
-export declare abstract class BaseTypeTranspiler<SourceTypeNode> {
-    nameNodePathResolver: (nodeParts: string[]) => {
-        path: string;
-        name: string;
-        isTypeOnly: boolean;
-    };
-    constructor(nameNodePathResolver: (nodeParts: string[]) => {
-        path: string;
-        name: string;
-        isTypeOnly: boolean;
-    });
-    abstract transpile(typeNode: SourceTypeNode): TypeNode;
-    beforeTranspile(): void;
-    getImportDeclarations(): ImportDeclaration[];
-    protected importDeclarations: ImportDeclaration[];
-}

package/dist/phpdoc-parser/transpiler/base-type-transpiler.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTypeTranspiler = void 0;
-class BaseTypeTranspiler {
-    constructor(nameNodePathResolver) {
-        this.nameNodePathResolver = nameNodePathResolver;
-    }
-    beforeTranspile() {
-        this.importDeclarations = [];
-    }
-    getImportDeclarations() {
-        return this.importDeclarations;
-    }
-}
-exports.BaseTypeTranspiler = BaseTypeTranspiler;