npm - @rightcapital/phpdoc-parser - Versions diffs - 0.5.3 → 0.6.0 - Mend

@rightcapital/phpdoc-parser 0.5.3 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/dist/phpdoc-parser/parser/type-parser.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import type { BaseNode } from '../ast/base-node';
+import { TemplateTagValueNode } from '../ast/php-doc/template-tag-value-node';
 import { GenericTypeNode } from '../ast/type/generic-type-node';
 import { IdentifierTypeNode } from '../ast/type/identifier-type-node';
 import type { TypeNode } from '../ast/type/type-node';
@@ -6,15 +7,16 @@ import type { ConstExprParser } from './const-expr-parser';
 import type { TokenIterator } from './token-iterator';
 export declare class TypeParser {
     private constExprParser;
-    private quoteAwareConstExprString;
     private useLinesAttributes;
     private useIndexAttributes;
-    constructor(constExprParser?: ConstExprParser | null, quoteAwareConstExprString?: boolean, usedAttributes?: {
+    constructor(constExprParser?: ConstExprParser | null, usedAttributes?: {
         lines?: boolean;
         indexes?: boolean;
     });
     parse(tokens: TokenIterator): TypeNode;
+    private enrichTypeOnUnionOrIntersection;
     enrichWithAttributes<T extends BaseNode>(tokens: TokenIterator, type: T, startLine: number, startIndex: number): T;
+    parseTemplateTagValue(tokens: TokenIterator, parseDescription?: (tokens: TokenIterator) => string): TemplateTagValueNode;
     private subParse;
     private parseAtomic;
     private parseUnion;
@@ -28,6 +30,8 @@ export declare class TypeParser {
     parseGeneric(tokens: TokenIterator, baseType: IdentifierTypeNode): GenericTypeNode;
     private parseGenericTypeArgument;
     private parseCallable;
+    private parseCallableTemplates;
+    private parseCallableTemplateArgument;
     private parseCallableParameter;
     private parseCallableReturnType;
     private tryParseCallable;
@@ -35,6 +39,8 @@ export declare class TypeParser {
     private parseArrayShape;
     private parseArrayShapeItem;
     private parseArrayShapeKey;
+    private parseArrayShapeUnsealedType;
+    private parseListShapeUnsealedType;
     private parseObjectShape;
     private parseObjectShapeItem;
     private parseObjectShapeKey;

package/dist/phpdoc-parser/parser/type-parser.js CHANGED Viewed

@@ -4,9 +4,11 @@ exports.TypeParser = void 0;
 const const_expr_array_node_1 = require("../ast/const-expr/const-expr-array-node");
 const const_expr_integer_node_1 = require("../ast/const-expr/const-expr-integer-node");
 const const_expr_string_node_1 = require("../ast/const-expr/const-expr-string-node");
-const quote_aware_const_expr_string_node_1 = require("../ast/const-expr/quote-aware-const-expr-string-node");
+const const_fetch_node_1 = require("../ast/const-expr/const-fetch-node");
+const template_tag_value_node_1 = require("../ast/php-doc/template-tag-value-node");
 const array_shape_item_node_1 = require("../ast/type/array-shape-item-node");
 const array_shape_node_1 = require("../ast/type/array-shape-node");
+const array_shape_unsealed_type_node_1 = require("../ast/type/array-shape-unsealed-type-node");
 const array_type_node_1 = require("../ast/type/array-type-node");
 const callable_type_node_1 = require("../ast/type/callable-type-node");
 const callable_type_parameter_node_1 = require("../ast/type/callable-type-parameter-node");
@@ -27,42 +29,85 @@ const lexer_1 = require("../lexer/lexer");
 const parser_exception_1 = require("./parser-exception");
 const string_unescaper_1 = require("./string-unescaper");
 class TypeParser {
-    constructor(constExprParser = null, quoteAwareConstExprString = false, usedAttributes = {}) {
+    constructor(constExprParser = null, usedAttributes = {}) {
         var _a, _b;
         this.constExprParser = constExprParser;
-        this.quoteAwareConstExprString = quoteAwareConstExprString;
         this.useLinesAttributes = (_a = usedAttributes.lines) !== null && _a !== void 0 ? _a : false;
         this.useIndexAttributes = (_b = usedAttributes.indexes) !== null && _b !== void 0 ? _b : false;
     }
     parse(tokens) {
+        var _a;
         const startLine = tokens.currentTokenLine();
         const startIndex = tokens.currentTokenIndex();
         if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_NULLABLE)) {
             return this.parseNullable(tokens);
         }
         let type = this.parseAtomic(tokens);
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_UNION)) {
-            type = this.parseUnion(tokens, type);
+        tokens.pushSavePoint();
+        tokens.skipNewLineTokensAndConsumeComments();
+        let enrichedType = null;
+        try {
+            enrichedType = this.enrichTypeOnUnionOrIntersection(tokens, type);
         }
-        else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
-            type = this.parseIntersection(tokens, type);
+        catch (_b) {
+            enrichedType = null;
         }
-        else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-            type = this.tryParseArrayOrOffsetAccess(tokens, type);
+        if (enrichedType !== null) {
+            type = enrichedType;
+            tokens.dropSavePoint();
+        }
+        else {
+            tokens.rollback();
+            type = (_a = this.enrichTypeOnUnionOrIntersection(tokens, type)) !== null && _a !== void 0 ? _a : type;
         }
         return this.enrichWithAttributes(tokens, type, startLine, startIndex);
     }
+    enrichTypeOnUnionOrIntersection(tokens, type) {
+        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_UNION)) {
+            return this.parseUnion(tokens, type);
+        }
+        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
+            return this.parseIntersection(tokens, type);
+        }
+        return null;
+    }
     enrichWithAttributes(tokens, type, startLine, startIndex) {
         if (this.useLinesAttributes) {
             type.setAttribute(types_1.Attribute.START_LINE, startLine);
             type.setAttribute(types_1.Attribute.END_LINE, tokens.currentTokenLine());
         }
+        tokens.flushComments();
         if (this.useIndexAttributes) {
             type.setAttribute(types_1.Attribute.START_INDEX, startIndex);
             type.setAttribute(types_1.Attribute.END_INDEX, tokens.endIndexOfLastRelevantToken());
         }
         return type;
     }
+    parseTemplateTagValue(tokens, parseDescription) {
+        const name = tokens.currentTokenValue();
+        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
+        let upperBound = null;
+        let lowerBound = null;
+        if (tokens.tryConsumeTokenValue('of') ||
+            tokens.tryConsumeTokenValue('as')) {
+            upperBound = this.parse(tokens);
+        }
+        if (tokens.tryConsumeTokenValue('super')) {
+            lowerBound = this.parse(tokens);
+        }
+        let defaultValue = null;
+        if (tokens.tryConsumeTokenValue('=')) {
+            defaultValue = this.parse(tokens);
+        }
+        let description = '';
+        if (parseDescription) {
+            description = parseDescription(tokens);
+        }
+        if (name === '') {
+            throw new Error('Template tag name cannot be empty.');
+        }
+        return new template_tag_value_node_1.TemplateTagValueNode(name, upperBound, description, defaultValue, lowerBound);
+    }
     subParse(tokens) {
         const startLine = tokens.currentTokenLine();
         const startIndex = tokens.currentTokenIndex();
@@ -76,7 +121,7 @@ class TypeParser {
                 type = this.parseConditional(tokens, type);
             }
             else {
-                tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+                tokens.skipNewLineTokensAndConsumeComments();
                 if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_UNION)) {
                     type = this.subParseUnion(tokens, type);
                 }
@@ -92,9 +137,9 @@ class TypeParser {
         const startIndex = tokens.currentTokenIndex();
         let type;
         if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES)) {
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             type = this.subParse(tokens);
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES);
             if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
                 type = this.tryParseArrayOrOffsetAccess(tokens, type);
@@ -114,13 +159,36 @@ class TypeParser {
             const identifierTypeNode = new identifier_type_node_1.IdentifierTypeNode(currentTokenValue);
             type = identifierTypeNode;
             if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_DOUBLE_COLON)) {
+                tokens.dropSavePoint();
                 if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET)) {
-                    type = this.parseGeneric(tokens, identifierTypeNode);
+                    tokens.pushSavePoint();
+                    const isHtml = this.isHtml(tokens);
+                    tokens.rollback();
+                    if (isHtml) {
+                        return this.enrichWithAttributes(tokens, type, startLine, startIndex);
+                    }
+                    const origType = type;
+                    type = this.tryParseCallable(tokens, identifierTypeNode, true);
+                    if (type === origType) {
+                        type = this.parseGeneric(tokens, identifierTypeNode);
+                        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
+                            type = this.tryParseArrayOrOffsetAccess(tokens, type);
+                        }
+                    }
+                }
+                else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES)) {
+                    type = this.tryParseCallable(tokens, identifierTypeNode, false);
                 }
                 else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
                     type = this.tryParseArrayOrOffsetAccess(tokens, type);
                 }
-                else if (['array', 'list', 'object'].includes(identifierTypeNode.name) &&
+                else if ([
+                    'array',
+                    'list',
+                    'non-empty-array',
+                    'non-empty-list',
+                    'object',
+                ].includes(identifierTypeNode.name) &&
                     tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_CURLY_BRACKET) &&
                     !tokens.isPrecededByHorizontalWhitespace()) {
                     if (identifierTypeNode.name === 'object') {
@@ -130,7 +198,7 @@ class TypeParser {
                         type = this.parseArrayShape(tokens, type, identifierTypeNode.name);
                     }
                     if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                        type = this.tryParseArrayOrOffsetAccess(tokens, type);
+                        type = this.tryParseArrayOrOffsetAccess(tokens, this.enrichWithAttributes(tokens, type, startLine, startIndex));
                     }
                 }
                 return this.enrichWithAttributes(tokens, type, startLine, startIndex);
@@ -145,7 +213,7 @@ class TypeParser {
             throw exception;
         }
         try {
-            const constExpr = this.constExprParser.parse(tokens, true);
+            const constExpr = this.constExprParser.parse(tokens);
             if (constExpr instanceof const_expr_array_node_1.ConstExprArrayNode) {
                 throw exception;
             }
@@ -159,6 +227,7 @@ class TypeParser {
     parseUnion(tokens, type) {
         const types = [type];
         while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_UNION)) {
+            tokens.skipNewLineTokensAndConsumeComments();
             types.push(this.parseAtomic(tokens));
         }
         return new union_type_node_1.UnionTypeNode(types);
@@ -166,15 +235,16 @@ class TypeParser {
     subParseUnion(tokens, type) {
         const types = [type];
         while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_UNION)) {
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             types.push(this.parseAtomic(tokens));
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
         }
         return new union_type_node_1.UnionTypeNode(types);
     }
     parseIntersection(tokens, type) {
         const types = [type];
         while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
+            tokens.skipNewLineTokensAndConsumeComments();
             types.push(this.parseAtomic(tokens));
         }
         return new intersection_type_node_1.IntersectionTypeNode(types);
@@ -182,9 +252,9 @@ class TypeParser {
     subParseIntersection(tokens, type) {
         const types = [type];
         while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             types.push(this.parseAtomic(tokens));
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
         }
         return new intersection_type_node_1.IntersectionTypeNode(types);
     }
@@ -196,13 +266,13 @@ class TypeParser {
             tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
         }
         const targetType = this.parse(tokens);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_NULLABLE);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         const ifType = this.parse(tokens);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         const elseType = this.subParse(tokens);
         return new conditional_type_node_1.ConditionalTypeNode(subjectType, targetType, ifType, elseType, negated);
     }
@@ -215,13 +285,13 @@ class TypeParser {
             tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
         }
         const targetType = this.parse(tokens);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_NULLABLE);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         const ifType = this.parse(tokens);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         const elseType = this.subParse(tokens);
         return new conditional_type_for_parameter_node_1.ConditionalTypeForParameterNode(parameterName, targetType, ifType, elseType, negated);
     }
@@ -251,24 +321,24 @@ class TypeParser {
     }
     parseGeneric(tokens, baseType) {
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         const genericTypes = [];
         const variances = [];
         const [genericType, variance] = this.parseGenericTypeArgument(tokens);
         genericTypes.push(genericType);
         variances.push(variance);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET)) {
                 break;
             }
             const [genericTypeToAddInWhileLoop, varianceToAddInWhileLoop] = this.parseGenericTypeArgument(tokens);
             genericTypes.push(genericTypeToAddInWhileLoop);
             variances.push(varianceToAddInWhileLoop);
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
         }
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
         const type = new generic_type_node_1.GenericTypeNode(baseType, genericTypes, variances);
         const startLine = baseType.getAttribute(types_1.Attribute.START_LINE);
@@ -300,26 +370,51 @@ class TypeParser {
         const type = this.parse(tokens);
         return [type, variance];
     }
-    parseCallable(tokens, identifier) {
+    parseCallable(tokens, identifier, hasTemplate) {
+        const templates = hasTemplate ? this.parseCallableTemplates(tokens) : [];
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES);
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         const parameters = [];
         if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES)) {
             parameters.push(this.parseCallableParameter(tokens));
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-                tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+                tokens.skipNewLineTokensAndConsumeComments();
                 if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES)) {
                     break;
                 }
                 parameters.push(this.parseCallableParameter(tokens));
-                tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+                tokens.skipNewLineTokensAndConsumeComments();
             }
         }
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES);
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-        const returnType = this.parseCallableReturnType(tokens);
-        return new callable_type_node_1.CallableTypeNode(identifier, parameters, returnType);
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
+        const returnType = this.enrichWithAttributes(tokens, this.parseCallableReturnType(tokens), startLine, startIndex);
+        return new callable_type_node_1.CallableTypeNode(identifier, parameters, returnType, templates);
+    }
+    parseCallableTemplates(tokens) {
+        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
+        const templates = [];
+        let isFirst = true;
+        while (isFirst || tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
+            tokens.skipNewLineTokensAndConsumeComments();
+            if (!isFirst &&
+                tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET)) {
+                break;
+            }
+            isFirst = false;
+            templates.push(this.parseCallableTemplateArgument(tokens));
+            tokens.skipNewLineTokensAndConsumeComments();
+        }
+        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
+        return templates;
+    }
+    parseCallableTemplateArgument(tokens) {
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
+        return this.enrichWithAttributes(tokens, this.parseTemplateTagValue(tokens), startLine, startIndex);
     }
     parseCallableParameter(tokens) {
         const startLine = tokens.currentTokenLine();
@@ -383,7 +478,7 @@ class TypeParser {
             throw exception;
         }
         try {
-            const constExpr = this.constExprParser.parse(tokens, true);
+            const constExpr = this.constExprParser.parse(tokens);
             if (constExpr instanceof const_expr_array_node_1.ConstExprArrayNode) {
                 throw exception;
             }
@@ -402,10 +497,10 @@ class TypeParser {
             }
         }
     }
-    tryParseCallable(tokens, identifier) {
+    tryParseCallable(tokens, identifier, hasTemplate) {
         try {
             tokens.pushSavePoint();
-            const type = this.parseCallable(tokens, identifier);
+            const type = this.parseCallable(tokens, identifier, hasTemplate);
             tokens.dropSavePoint();
             return type;
         }
@@ -451,22 +546,41 @@ class TypeParser {
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_CURLY_BRACKET);
         const items = [];
         let sealed = true;
+        let unsealedType = null;
+        let done = false;
         do {
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET)) {
                 return new array_shape_node_1.ArrayShapeNode(items, true, kind);
             }
             if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_VARIADIC)) {
                 sealed = false;
+                tokens.skipNewLineTokensAndConsumeComments();
+                if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET)) {
+                    if (kind === array_shape_node_1.ArrayShapeNodeKind.ARRAY ||
+                        kind === array_shape_node_1.ArrayShapeNodeKind.NON_EMPTY_ARRAY) {
+                        unsealedType = this.parseArrayShapeUnsealedType(tokens);
+                    }
+                    else {
+                        unsealedType = this.parseListShapeUnsealedType(tokens);
+                    }
+                    tokens.skipNewLineTokensAndConsumeComments();
+                }
                 tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA);
                 break;
             }
             items.push(this.parseArrayShapeItem(tokens));
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
-        } while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA));
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
+            if (!tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
+                done = true;
+            }
+        } while (!done);
+        tokens.skipNewLineTokensAndConsumeComments();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET);
-        return new array_shape_node_1.ArrayShapeNode(items, sealed, kind);
+        if (sealed) {
+            return new array_shape_node_1.ArrayShapeNode(items, true, kind);
+        }
+        return new array_shape_node_1.ArrayShapeNode(items, false, kind, unsealedType);
     }
     parseArrayShapeItem(tokens) {
         const startLine = tokens.currentTokenLine();
@@ -498,41 +612,66 @@ class TypeParser {
             tokens.next();
         }
         else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_SINGLE_QUOTED_STRING)) {
-            if (this.quoteAwareConstExprString) {
-                key = new quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode.SINGLE_QUOTED);
-            }
-            else {
-                key = new const_expr_string_node_1.ConstExprStringNode(tokens.currentTokenValue().replace(/(^'|'$)/g, ''));
-            }
+            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.SINGLE_QUOTED);
             tokens.next();
         }
         else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_DOUBLE_QUOTED_STRING)) {
-            if (this.quoteAwareConstExprString) {
-                key = new quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode.DOUBLE_QUOTED);
-            }
-            else {
-                key = new const_expr_string_node_1.ConstExprStringNode(tokens.currentTokenValue().replace(/(^"|"$)/g, ''));
-            }
+            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.DOUBLE_QUOTED);
             tokens.next();
         }
         else {
-            key = new identifier_type_node_1.IdentifierTypeNode(tokens.currentTokenValue());
+            const identifier = tokens.currentTokenValue();
             tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
+            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_DOUBLE_COLON)) {
+                const classConstantName = tokens.currentTokenValue();
+                tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
+                key = new const_fetch_node_1.ConstFetchNode(identifier, classConstantName);
+            }
+            else {
+                key = new identifier_type_node_1.IdentifierTypeNode(identifier);
+            }
         }
         return this.enrichWithAttributes(tokens, key, startLine, startIndex);
     }
+    parseArrayShapeUnsealedType(tokens) {
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
+        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
+        tokens.skipNewLineTokensAndConsumeComments();
+        let valueType = this.parse(tokens);
+        tokens.skipNewLineTokensAndConsumeComments();
+        let keyType = null;
+        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
+            tokens.skipNewLineTokensAndConsumeComments();
+            keyType = valueType;
+            valueType = this.parse(tokens);
+            tokens.skipNewLineTokensAndConsumeComments();
+        }
+        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
+        return this.enrichWithAttributes(tokens, new array_shape_unsealed_type_node_1.ArrayShapeUnsealedTypeNode(valueType, keyType), startLine, startIndex);
+    }
+    parseListShapeUnsealedType(tokens) {
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
+        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
+        tokens.skipNewLineTokensAndConsumeComments();
+        const valueType = this.parse(tokens);
+        tokens.skipNewLineTokensAndConsumeComments();
+        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
+        return this.enrichWithAttributes(tokens, new array_shape_unsealed_type_node_1.ArrayShapeUnsealedTypeNode(valueType, null), startLine, startIndex);
+    }
     parseObjectShape(tokens) {
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_CURLY_BRACKET);
         const items = [];
         do {
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
             if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET)) {
                 return new object_shape_node_1.ObjectShapeNode(items);
             }
             items.push(this.parseObjectShapeItem(tokens));
-            tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            tokens.skipNewLineTokensAndConsumeComments();
         } while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA));
-        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+        tokens.skipNewLineTokensAndConsumeComments();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET);
         return new object_shape_node_1.ObjectShapeNode(items);
     }
@@ -550,21 +689,11 @@ class TypeParser {
         const startIndex = tokens.currentTokenIndex();
         let key;
         if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_SINGLE_QUOTED_STRING)) {
-            if (this.quoteAwareConstExprString) {
-                key = new quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode.SINGLE_QUOTED);
-            }
-            else {
-                key = new const_expr_string_node_1.ConstExprStringNode(tokens.currentTokenValue().replace(/(^'|'$)/g, ''));
-            }
+            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.SINGLE_QUOTED);
             tokens.next();
         }
         else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_DOUBLE_QUOTED_STRING)) {
-            if (this.quoteAwareConstExprString) {
-                key = new quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode.DOUBLE_QUOTED);
-            }
-            else {
-                key = new const_expr_string_node_1.ConstExprStringNode(tokens.currentTokenValue().replace(/(^"|"$)/g, ''));
-            }
+            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.DOUBLE_QUOTED);
             tokens.next();
         }
         else {

package/dist/phpdoc-parser/parser-config.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+export declare class ParserConfig {
+    useLinesAttributes: boolean;
+    useIndexAttributes: boolean;
+    useCommentsAttributes: boolean;
+    constructor(usedAttributes?: {
+        lines?: boolean;
+        indexes?: boolean;
+        comments?: boolean;
+    });
+}

package/dist/phpdoc-parser/parser-config.js ADDED Viewed

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserConfig = void 0;
+class ParserConfig {
+    constructor(usedAttributes = {}) {
+        var _a, _b, _c;
+        this.useLinesAttributes = (_a = usedAttributes.lines) !== null && _a !== void 0 ? _a : false;
+        this.useIndexAttributes = (_b = usedAttributes.indexes) !== null && _b !== void 0 ? _b : false;
+        this.useCommentsAttributes = (_c = usedAttributes.comments) !== null && _c !== void 0 ? _c : false;
+    }
+}
+exports.ParserConfig = ParserConfig;

package/dist/phpdoc-parser/transpiler/php-doc-to-typescript-type-transpiler.js CHANGED Viewed

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PhpDocTypeNodeToTypescriptTypeNodeTranspiler = void 0;
 const typescript_1 = require("typescript");
+const const_expr_string_node_1 = require("../ast/const-expr/const-expr-string-node");
 const array_shape_node_1 = require("../ast/type/array-shape-node");
 const array_type_node_1 = require("../ast/type/array-type-node");
 const object_shape_node_1 = require("../ast/type/object-shape-node");
@@ -19,14 +20,20 @@ class PhpDocTypeNodeToTypescriptTypeNodeTranspiler {
         }
         if (sourceTypeNode instanceof array_shape_node_1.ArrayShapeNode) {
             return typescript_1.factory.createTypeLiteralNode(sourceTypeNode.items.map((item) => {
-                return typescript_1.factory.createPropertySignature(undefined, item.keyName.toString(), item.optional
+                const keyName = item.keyName instanceof const_expr_string_node_1.ConstExprStringNode
+                    ? item.keyName.value
+                    : item.keyName.toString();
+                return typescript_1.factory.createPropertySignature(undefined, keyName, item.optional
                     ? typescript_1.factory.createToken(typescript_1.SyntaxKind.QuestionToken)
                     : undefined, this.transpile(item.valueType));
             }));
         }
         if (sourceTypeNode instanceof object_shape_node_1.ObjectShapeNode) {
             return typescript_1.factory.createTypeLiteralNode(sourceTypeNode.items.map((item) => {
-                return typescript_1.factory.createPropertySignature(undefined, item.keyName.toString(), item.optional
+                const keyName = item.keyName instanceof const_expr_string_node_1.ConstExprStringNode
+                    ? item.keyName.value
+                    : item.keyName.toString();
+                return typescript_1.factory.createPropertySignature(undefined, keyName, item.optional
                     ? typescript_1.factory.createToken(typescript_1.SyntaxKind.QuestionToken)
                     : undefined, this.transpile(item.valueType));
             }));

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rightcapital/phpdoc-parser",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "TypeScript version of PHPDoc parser with support for intersection types and generics",
   "keywords": [
     "PHP",
@@ -36,9 +36,7 @@
     }
   },
   "dependencies": {
-    "@types/node": "22.19.1",
-    "lodash": "4.17.21",
-    "typescript": "5.9.3"
+    "lodash": "4.17.23"
   },
   "devDependencies": {
     "@babel/core": "7.26.9",
@@ -50,15 +48,20 @@
     "@rightcapital/eslint-config": "42.1.0",
     "@rightcapital/prettier-config": "7.2.1",
     "@types/lodash": "4.17.16",
+    "@types/node": "22.19.11",
     "beachball": "2.51.0",
     "commitizen": "4.3.1",
     "eslint": "9.13.0",
     "husky": "9.1.7",
     "inquirer": "12.4.2",
     "prettier": "3.5.3",
+    "typescript": "5.9.3",
     "vitest": "3.0.7"
   },
-  "packageManager": "pnpm@10.21.0",
+  "peerDependencies": {
+    "typescript": ">=5.8.0"
+  },
+  "packageManager": "pnpm@10.30.0",
   "engines": {
     "node": ">=16.x",
     "pnpm": ">=8.x"