@xdbml/parse 0.3.0 → 0.3.2

package/dist/parser.d.ts

@@ -216,9 +216,20 @@ export declare class Parser {
      * otherwise the first thing is the bare type.
      */
     private parseArrayType;
+    /** array/set sugar: fold a following comma-list of union-eligible members
+     *  (`[T1, T2, ...]`) into a UnionType. Applies only when the element is a
+     *  scalar/named type with no per-member settings; `null` is allowed as a
+     *  later member. Object shapes use `oneOf`, positional layouts use a tuple. */
+    private maybeFoldUnionSugar;
+    /** A type usable as a `union` member (and thus foldable from array sugar).
+     *  `null` is only ever a later member (parsed via parseUnionMember), never
+     *  the first standalone element type, so it is not listed here. */
+    private isUnionMemberType;
     /** True if the token looks like the start of a TypeExpression. */
     private tokenStartsType;
     private parseTupleElements;
+    /** Lookahead for a tuple position marker `[ <number> ]` (vs. a settings block). */
+    private positionMarkerAhead;
     private parseMapType;
     private parseSetType;
     /**

package/dist/parser.js

@@ -1020,8 +1020,11 @@ export class Parser {
             && this.tokenStartsType(second)) {
             elementName = this.advance().text;
         }
-        const elementType = this.parseTypeExpression();
+        const elemStart = this.peek().start;
+        let elementType = this.parseTypeExpression();
         const elementSettings = this.maybeSettingsBlock();
+        // Sugar: `array [T1, T2, ...]` == `array [union [T1, T2, ...]]` (see helper).
+        elementType = this.maybeFoldUnionSugar(elementType, elemStart, elementSettings.length === 0);
         this.expect(TokenKind.RBracket, "Expected ']' closing array");
         return {
             kind: 'ArrayType',
@@ -1032,6 +1035,33 @@ export class Parser {
             span: this.spanFrom(start),
         };
     }
+    /** array/set sugar: fold a following comma-list of union-eligible members
+     *  (`[T1, T2, ...]`) into a UnionType. Applies only when the element is a
+     *  scalar/named type with no per-member settings; `null` is allowed as a
+     *  later member. Object shapes use `oneOf`, positional layouts use a tuple. */
+    maybeFoldUnionSugar(elementType, elemStart, noElementSettings) {
+        if (noElementSettings
+            && this.check(TokenKind.Comma)
+            && this.isUnionMemberType(elementType)) {
+            const members = [elementType];
+            while (this.match(TokenKind.Comma)) {
+                members.push(this.parseUnionMember());
+            }
+            return {
+                kind: 'UnionType',
+                members,
+                span: this.spanFrom(elemStart),
+            };
+        }
+        return elementType;
+    }
+    /** A type usable as a `union` member (and thus foldable from array sugar).
+     *  `null` is only ever a later member (parsed via parseUnionMember), never
+     *  the first standalone element type, so it is not listed here. */
+    isUnionMemberType(t) {
+        return t.kind === 'ScalarType'
+            || t.kind === 'NamedTypeReference';
+    }
     /** True if the token looks like the start of a TypeExpression. */
     tokenStartsType(t) {
         if (t.kind === TokenKind.LBrace)
@@ -1049,7 +1079,11 @@ export class Parser {
             this.expect(TokenKind.RBracket, "Expected ']' after position");
             const nameTok = this.expect(TokenKind.Identifier, 'Expected tuple element name');
             const type = this.parseTypeExpression();
-            const settings = this.maybeSettingsBlock();
+            // Optional per-element settings. A following `[` only opens a settings
+            // block if it is NOT the next element's `[N]` position marker; otherwise
+            // maybeSettingsBlock would greedily consume it and fail on the number
+            // (grammar: tupleElement's settingsBlock is optional).
+            const settings = this.positionMarkerAhead() ? [] : this.maybeSettingsBlock();
             out.push({
                 kind: 'TupleElement',
                 position: parseInt(numTok.text, 10),
@@ -1058,11 +1092,19 @@ export class Parser {
                 settings,
                 span: this.spanFrom(start),
             });
-            if (!this.match(TokenKind.Comma))
-                break;
+            // Elements may be separated by a comma OR by whitespace/newline alone
+            // (grammar: `tupleElement (COMMA? tupleElement)+`). Consume an optional
+            // separator; the loop condition resumes on the next `[N]`.
+            this.match(TokenKind.Comma);
         }
         return out;
     }
+    /** Lookahead for a tuple position marker `[ <number> ]` (vs. a settings block). */
+    positionMarkerAhead() {
+        return this.check(TokenKind.LBracket)
+            && this.peek(1).kind === TokenKind.NumberLiteral
+            && this.peek(2).kind === TokenKind.RBracket;
+    }
     parseMapType() {
         const start = this.peek().start;
         const kwTok = this.advance();
@@ -1083,7 +1125,11 @@ export class Parser {
         const start = this.peek().start;
         this.advance(); // set
         this.expect(TokenKind.LBracket, "Expected '[' after set");
-        const elementType = this.parseTypeExpression();
+        const elemStart = this.peek().start;
+        let elementType = this.parseTypeExpression();
+        // Sugar: `set [T1, T2, ...]` == `set [union [T1, T2, ...]]` (set has no
+        // per-element settings, so the fold is always eligible).
+        elementType = this.maybeFoldUnionSugar(elementType, elemStart, true);
         this.expect(TokenKind.RBracket, "Expected ']' closing set");
         return {
             kind: 'SetType',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdbml/parse",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Parser for xDBML (eXtended Database Markup Language), a strict superset of DBML 3.13.6: tokenizer, parser, module resolver, and name resolver.",
   "license": "Apache-2.0",
   "author": "Hackolade",