cddl 0.5.0 → 0.7.0

package/.editorconfig

@@ -0,0 +1,18 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+
+indent_style = space
+indent_size = 4
+
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[{.travis.yml,**/*.json,.github/**/*.yml}]
+indent_size = 2

package/README.md

@@ -20,7 +20,25 @@ $ npm install cddl
 
 ## Using this package
 
-Currently, you can use this package to parse a CDDL file into an [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) (AST). For example, given the following CDDL file:
+This package exposes a CLI as well as a programmatic interface for parsing and transforming CDDL.
+
+### CLI
+
+The `cddl` CLI offers a `validate` command that helps identify invalid CDDL formats, e.g.:
+
+```sh
+npx cddl validate ./path/to/interface.cddl
+✅ Valid CDDL file!
+```
+
+### Programmatic Interface
+
+You can also use this package to parse a CDDL file into:
+
+- an [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) (AST).
+- or a [TypeScript](https://www.typescriptlang.org/) definition
+
+For example, given the following CDDL file:
 
 ```cddl
 person = {
@@ -29,7 +47,7 @@ person = {
 }
 ```
 
-You can use this package to parse the file into an abstract syntax tree (AST):
+By default the package parses the content into an AST:
 
 ```js
 import { parse } from 'cddl'
@@ -49,6 +67,35 @@ console.log(ast)
  */
 ```
 
+You can apply a target specifier to transform the AST into a different language or format (currently supported: `ts` for TypeScript). Note that this is highly experimental and work in progress.
+
+```js
+import { parse } from 'cddl'
+
+/**
+ * spec.cddl:
+ *
+ * session.CapabilityRequest = {
+ *   ?acceptInsecureCerts: bool,
+ *   ?browserName: text,
+ *   ?browserVersion: text,
+ *   ?platformName: text,
+ * };
+ */
+const ts = parse('./spec.cddl', { target: 'ts' })
+console.log(ts)
+/**
+ * outputs:
+ *
+ * interface SessionCapabilityRequest {
+ *   acceptInsecureCerts?: boolean,
+ *   browserName?: string,
+ *   browserVersion?: string,
+ *   platformName?: string,
+ * }
+ */
+```
+
 ---
 
 If you are interested in this project, please feel free to contribute ideas or code patches. Have a look at our [contributing](https://github.com/christian-bromann/cddl/blob/master/LICENSE) guidelines](https://github.com/christian-bromann/cddl/blob/master/LICENSE) to get started.

package/build/ast.d.ts

@@ -13,6 +13,7 @@ export type Group = {
     Name: string;
     IsChoiceAddition: boolean;
     Properties: (Property | Property[])[];
+    Comments: Comment[];
 };
 /**
  * an array definition
@@ -26,6 +27,7 @@ export type Array = {
     Type: 'array';
     Name: string;
     Values: (Property | Property[])[];
+    Comments: Comment[];
 };
 /**
  * a tag definition
@@ -48,6 +50,8 @@ export type Variable = {
     Name: string;
     IsChoiceAddition: boolean;
     PropertyType: PropertyType | PropertyType[];
+    Operator?: Operator;
+    Comments: Comment[];
 };
 /**
  * a comment statement
@@ -58,6 +62,7 @@ export type Variable = {
 export type Comment = {
     Type: 'comment';
     Content: string;
+    Leading: boolean;
 };
 export type Occurrence = {
     n: number;
@@ -68,7 +73,8 @@ export type Property = {
     Occurrence: Occurrence;
     Name: PropertyName;
     Type: PropertyType | PropertyType[];
-    Comment: string;
+    Comments: Comment[];
+    Operator?: Operator;
 };
 export declare enum Type {
     /**
@@ -91,7 +97,12 @@ export declare enum Type {
     BSTR = "bstr",
     BYTES = "bytes",
     TSTR = "tstr",
-    TEXT = "text"
+    TEXT = "text",
+    /**
+     * null types
+     */
+    NIL = "nil",
+    NULL = "null"
 }
 /**
  * can be a number, e.g. "foo = 0..10"
@@ -115,13 +126,23 @@ export type Range = {
     Max: RangePropertyReference;
     Inclusive: boolean;
 };
-export type PropertyReferenceType = 'literal' | 'group' | 'group_array' | 'range' | 'tag';
+export type OperatorType = 'default' | 'size' | 'regexp' | 'bits' | 'and' | 'within' | 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge';
+export interface Operator {
+    Type: OperatorType;
+    Value: PropertyType;
+}
+export type PropertyReferenceType = 'literal' | 'group' | 'group_array' | 'array' | 'range' | 'tag';
 export type PropertyReference = {
     Type: PropertyReferenceType;
     Value: string | number | boolean | Group | Array | Range | Tag;
     Unwrapped: boolean;
+    Operator?: Operator;
 };
-export type Assignment = Group | Array | Variable | Comment;
-export type PropertyType = Assignment | Array | PropertyReference | string;
+export interface NativeTypeWithOperator {
+    Type: Type | PropertyReference;
+    Operator?: Operator;
+}
+export type Assignment = Group | Array | Variable;
+export type PropertyType = Assignment | Array | PropertyReference | string | NativeTypeWithOperator;
 export type PropertyName = string;
 //# sourceMappingURL=ast.d.ts.map

package/build/ast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,EAAE,OAAO,CAAC;IAC1B,UAAU,EAAE,CAAC,QAAQ,GAAC,QAAQ,EAAE,CAAC,EAAE,CAAC;CACvC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,KAAK,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,CAAC,QAAQ,GAAC,QAAQ,EAAE,CAAC,EAAE,CAAC;CACnC,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,GAAG,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CACpB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IACnB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;IAC1B,YAAY,EAAE,YAAY,GAAG,YAAY,EAAE,CAAC;CAC/C,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,YAAY,GAAG,YAAY,EAAE,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,oBAAY,IAAI;IACZ;;OAEG;IAEH,IAAI,SAAS;IAEb;;OAEG;IAEH,GAAG,QAAQ;IAEX,IAAI,SAAS;IAEb,IAAI,SAAS;IAEb,KAAK,UAAU;IAEf,OAAO,YAAY;IAEnB,OAAO,YAAY;IAEnB,OAAO,YAAY;IAEnB;;OAEG;IAEH,IAAI,SAAS;IAEb,KAAK,UAAU;IAEf,IAAI,SAAS;IAEb,IAAI,SAAS;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,CAAA;AAEpD,MAAM,MAAM,KAAK,GAAG;IAChB,GAAG,EAAE,sBAAsB,CAAC;IAC5B,GAAG,EAAE,sBAAsB,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,GAAG,OAAO,GAAG,KAAK,CAAA;AACzF,MAAM,MAAM,iBAAiB,GAAG;IAC5B,IAAI,EAAE,qBAAqB,CAAC;IAC5B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,GAAG,CAAC;IAC/D,SAAS,EAAE,OAAO,CAAC;CACtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,KAAK,GAAG,iBAAiB,GAAG,MAAM,CAAA;AAC1E,MAAM,MAAM,YAAY,GAAG,MAAM,CAAA"}
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"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"}

package/build/ast.js

@@ -33,4 +33,9 @@ export var Type;
     Type["TSTR"] = "tstr";
     // Text string (major type 3)
     Type["TEXT"] = "text";
+    /**
+     * null types
+     */
+    Type["NIL"] = "nil";
+    Type["NULL"] = "null";
 })(Type || (Type = {}));

package/build/index.d.ts

@@ -3,7 +3,7 @@ import Parser from './parser.js';
 import { ParseTargets } from './constants.js';
 import type { ParseOptions } from './types.js';
 declare const _default: {
-    parse: (filePath: string, opts: ParseOptions) => string | import("./ast.js").Assignment[];
+    parse: (filePath: string, opts?: ParseOptions) => string | import("./ast.js").Assignment[];
 };
 export default _default;
 export { Lexer, Parser, ParseTargets };

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,MAAM,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;;sBAGxB,MAAM,QAAQ,YAAY;;AADhD,wBAcC;AAED,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,MAAM,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;;sBAGxB,MAAM,SAAQ,YAAY;;AADhD,wBAcC;AAED,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,CAAA"}

package/build/index.js

@@ -3,7 +3,7 @@ import Parser from './parser.js';
 import { transform as transformTS } from './transform/ts.js';
 import { ParseTargets } from './constants.js';
 export default {
-    parse: (filePath, opts) => {
+    parse: (filePath, opts = { target: ParseTargets.AST }) => {
         const parser = new Parser(filePath);
         const ast = parser.parse();
         if (opts.target === ParseTargets.AST) {

package/build/parser.d.ts

@@ -19,6 +19,8 @@ export default class Parser {
     private openSegment;
     private parsePropertyName;
     private parsePropertyType;
+    private parseOperator;
+    private isOperator;
     private parsePropertyTypes;
     private parseOccurrences;
     /**

package/build/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,OAAO,EAAE,KAAK,EAAU,MAAM,aAAa,CAAC;AAG5C,OAAO,EAE2C,UAAU,EAE3D,MAAM,UAAU,CAAA;AAKjB,MAAM,CAAC,OAAO,OAAO,MAAM;;IAEvB,CAAC,EAAE,KAAK,CAAC;IAET,QAAQ,EAAE,KAAK,CAAa;IAC5B,SAAS,EAAE,KAAK,CAAa;gBAEhB,QAAQ,EAAE,MAAM;IAQ7B,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,oBAAoB;IAyU5B,OAAO,CAAC,wBAAwB;IAahC;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IA8GzB,OAAO,CAAC,kBAAkB;IAwC1B,OAAO,CAAC,gBAAgB;IA4DxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAUpB,KAAK;IAuBL,OAAO,CAAC,WAAW;CAKtB"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,OAAO,EAAE,KAAK,EAAU,MAAM,aAAa,CAAC;AAG5C,OAAO,EAE2C,UAAU,EAE3D,MAAM,UAAU,CAAA;AAoBjB,MAAM,CAAC,OAAO,OAAO,MAAM;;IAEvB,CAAC,EAAE,KAAK,CAAC;IAET,QAAQ,EAAE,KAAK,CAAa;IAC5B,SAAS,EAAE,KAAK,CAAa;gBAEhB,QAAQ,EAAE,MAAM;IAQ7B,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,gBAAgB;IA2CxB,OAAO,CAAC,oBAAoB;IA6Y5B,OAAO,CAAC,wBAAwB;IAahC;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IA6HzB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,kBAAkB;IAiD1B,OAAO,CAAC,gBAAgB;IA4DxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB,KAAK;IAaL,OAAO,CAAC,WAAW;CAKtB"}

package/build/parser.js

@@ -6,6 +6,21 @@ import { parseNumberValue } from './utils.js';
 import { Type } from './ast.js';
 const NIL_TOKEN = { Type: Tokens.ILLEGAL, Literal: '' };
 const DEFAULT_OCCURRENCE = { n: 1, m: 1 }; // exactly one time
+const OPERATORS = ['default', 'size', 'regexp', 'bits', 'and', 'within', 'eq', 'ne', 'lt', 'le', 'gt', 'ge'];
+const OPERATORS_EXPECTING_VALUES = {
+    default: undefined,
+    size: ['literal', 'range'],
+    regexp: ['literal'],
+    bits: ['group'],
+    and: ['group'],
+    within: ['group'],
+    eq: ['group'],
+    ne: ['group'],
+    lt: ['group'],
+    le: ['group'],
+    gt: ['group'],
+    ge: ['group'],
+};
 export default class Parser {
     #filePath;
     l;
@@ -23,6 +38,10 @@ export default class Parser {
         return true;
     }
     parseAssignments() {
+        const comments = [];
+        while (this.curToken.Type === Tokens.COMMENT) {
+            comments.push(this.parseComment());
+        }
         /**
          * expect group identifier, e.g.
          * groupName =
@@ -45,7 +64,14 @@ export default class Parser {
             this.nextToken(); // eat `/`
         }
         this.nextToken(); // eat `=`
-        return this.parseAssignmentValue(groupName, isChoiceAddition);
+        const assignmentValue = this.parseAssignmentValue(groupName, isChoiceAddition);
+        // @ts-expect-error curToken can be changed by now but TS doesn't understand this
+        while (this.curToken.Type === Tokens.COMMENT) {
+            const comment = this.parseComment();
+            comment && comments.push(comment);
+        }
+        assignmentValue.Comments = comments;
+        return assignmentValue;
     }
     parseAssignmentValue(groupName, isChoiceAddition = false) {
         let isChoice = false;
@@ -64,7 +90,8 @@ export default class Parser {
                     Type: 'variable',
                     Name: groupName,
                     IsChoiceAddition: isChoiceAddition,
-                    PropertyType: this.parsePropertyTypes()
+                    PropertyType: this.parsePropertyTypes(),
+                    Comments: []
                 };
                 return variable;
             }
@@ -101,18 +128,46 @@ export default class Parser {
                     Type: 'variable',
                     Name: groupName,
                     IsChoiceAddition: isChoiceAddition,
-                    PropertyType: propertyType
+                    PropertyType: propertyType,
+                    Comments: []
                 };
+                if (this.isOperator()) {
+                    variable.Operator = this.parseOperator();
+                }
                 return variable;
             }
             return propertyType;
         }
+        /**
+         * parse operator assignments, e.g. `ip4 = (float .ge 0.0) .default 1.0`
+         */
+        if (closingTokens.length === 1 && this.peekToken.Type === Tokens.DOT) {
+            const prop = {
+                Type: this.parsePropertyType(),
+                Operator: this.parseOperator()
+            };
+            this.nextToken(); // eat closing token
+            if (groupName) {
+                const variable = {
+                    Type: 'variable',
+                    Name: groupName,
+                    IsChoiceAddition: isChoiceAddition,
+                    PropertyType: prop,
+                    Operator: this.parseOperator(),
+                    Comments: []
+                };
+                return variable;
+            }
+            return [prop];
+        }
         while (!closingTokens.includes(this.curToken.Type)) {
             const propertyType = [];
+            const comments = [];
             let isUnwrapped = false;
             let hasCut = false;
             let propertyName = '';
-            let comment = '';
+            const leadingComment = this.parseComment(true);
+            leadingComment && comments.push(leadingComment);
             const occurrence = this.parseOccurrences();
             /**
              * check if variable name is unwrapped
@@ -145,7 +200,7 @@ export default class Parser {
                     Occurrence: occurrence,
                     Name: '',
                     Type: innerGroup,
-                    Comment: ''
+                    Comments: []
                 });
                 continue;
             }
@@ -163,6 +218,7 @@ export default class Parser {
             if (this.curToken.Type === Tokens.COMMA || closingTokens.includes(this.curToken.Type)) {
                 const tokenType = this.curToken.Type;
                 let parsedComments = false;
+                let comment;
                 /**
                  * check if line has a comment
                  */
@@ -182,7 +238,7 @@ export default class Parser {
                                 Value: propertyName,
                                 Unwrapped: isUnwrapped
                             }],
-                    Comment: comment
+                    Comments: comment ? [comment] : []
                 });
                 if (this.curToken.Literal === Tokens.COMMA || this.curToken.Literal === closingTokens[0]) {
                     if (this.curToken.Literal === Tokens.COMMA) {
@@ -224,11 +280,11 @@ export default class Parser {
                     Occurrence: occurrence,
                     Name: '',
                     Type: {
-                        Type: "group",
+                        Type: 'group',
                         Value: propertyName,
                         Unwrapped: isUnwrapped
                     },
-                    Comment: comment
+                    Comments: comments
                 };
                 if (isChoice) {
                     /**
@@ -258,6 +314,7 @@ export default class Parser {
              * parse property value
              */
             const props = this.parseAssignmentValue();
+            const operator = this.isOperator() ? this.parseOperator() : undefined;
             if (Array.isArray(props)) {
                 /**
                  * property has multiple types (e.g. `float / tstr / int`)
@@ -278,13 +335,15 @@ export default class Parser {
                 flipIsChoice = true;
                 this.nextToken(); // eat ,
             }
-            comment = this.parseComment();
+            const trailingComment = this.parseComment();
+            trailingComment && comments.push(trailingComment);
             const prop = {
                 HasCut: hasCut,
                 Occurrence: occurrence,
                 Name: propertyName,
                 Type: propertyType,
-                Comment: comment
+                Comments: comments,
+                ...(operator ? { Operator: operator } : {})
             };
             if (isChoice) {
                 valuesOrProperties[valuesOrProperties.length - 1].push(prop);
@@ -323,9 +382,35 @@ export default class Parser {
             return {
                 Type: 'array',
                 Name: groupName || '',
-                Values: valuesOrProperties
+                Values: valuesOrProperties,
+                Comments: []
             };
         }
+        /**
+         * simplify wrapped types, e.g. from
+         * {
+         *     "Type": "group",
+         *     "Name": "",
+         *     "Properties": [
+         *         {
+         *             "HasCut": false,
+         *             "Occurrence": {
+         *                 "n": 1,
+         *                 "m": 1
+         *             },
+         *             "Name": "",
+         *             "Type": "bool",
+         *             "Comment": ""
+         *         }
+         *     ],
+         *     "IsChoiceAddition": false
+         * }
+         * back to:
+         * bool
+         */
+        if (!groupName && valuesOrProperties.length === 1 && PREDEFINED_IDENTIFIER.includes(valuesOrProperties[0].Type)) {
+            return valuesOrProperties[0].Type;
+        }
         /**
          * otherwise a group
          */
@@ -333,7 +418,8 @@ export default class Parser {
             Type: 'group',
             Name: groupName || '',
             Properties: valuesOrProperties,
-            IsChoiceAddition: isChoiceAddition
+            IsChoiceAddition: isChoiceAddition,
+            Comments: []
         };
     }
     isPropertyValueSeparator() {
@@ -382,8 +468,9 @@ export default class Parser {
         throw this.parserError(`Expected property name, received ${this.curToken.Type}(${this.curToken.Literal}), ${this.peekToken.Type}(${this.peekToken.Literal})`);
     }
     parsePropertyType() {
-        let type;
+        let type = undefined;
         let isUnwrapped = false;
+        let isGroupedRange = false;
         /**
          * check if variable name is unwrapped
          */
@@ -404,6 +491,8 @@ export default class Parser {
             case Type.BYTES:
             case Type.TSTR:
             case Type.TEXT:
+            case Type.NIL:
+            case Type.NULL:
                 type = this.curToken.Literal;
                 break;
             default: {
@@ -451,6 +540,15 @@ export default class Parser {
                         Unwrapped: isUnwrapped
                     };
                 }
+                else if (this.curToken.Literal === Tokens.LPAREN && this.peekToken.Type === Tokens.NUMBER) {
+                    this.nextToken();
+                    type = {
+                        Type: 'literal',
+                        Value: parseNumberValue(this.curToken),
+                        Unwrapped: isUnwrapped
+                    };
+                    isGroupedRange = true;
+                }
                 else {
                     throw this.parserError(`Invalid property type "${this.curToken.Literal}"`);
                 }
@@ -484,13 +582,42 @@ export default class Parser {
                 },
                 Unwrapped: isUnwrapped
             };
+            if (isGroupedRange) {
+                this.nextToken(); // eat ")"
+            }
         }
         return type;
     }
+    parseOperator() {
+        const type = this.peekToken.Literal;
+        if (this.curToken.Literal !== Tokens.DOT || !OPERATORS.includes(this.peekToken.Literal)) {
+            throw new Error(`Operator ".${type}", expects a ${OPERATORS_EXPECTING_VALUES[type].join(' or ')} property, but found ${this.peekToken.Literal}!`);
+        }
+        this.nextToken(); // eat "."
+        this.nextToken(); // eat operator type
+        const value = this.parsePropertyType();
+        this.nextToken(); // eat operator value
+        return {
+            Type: type,
+            Value: value
+        };
+    }
+    isOperator() {
+        return this.curToken.Literal === Tokens.DOT && OPERATORS.includes(this.peekToken.Literal);
+    }
     parsePropertyTypes() {
         const propertyTypes = [];
-        propertyTypes.push(this.parsePropertyType());
-        this.nextToken(); // eat `/`
+        let prop = this.parsePropertyType();
+        if (this.isOperator()) {
+            prop = {
+                Type: prop,
+                Operator: this.parseOperator()
+            };
+        }
+        else {
+            this.nextToken(); // eat `/`
+        }
+        propertyTypes.push(prop);
         /**
          * ensure we don't go into the next choice, e.g.:
          * ```
@@ -576,26 +703,20 @@ export default class Parser {
     /**
      * check if line has a comment
      */
-    parseComment() {
-        let comment = '';
-        if (this.curToken.Type === Tokens.COMMENT) {
-            comment = this.curToken.Literal.slice(2);
-            this.nextToken();
+    parseComment(isLeading) {
+        if (this.curToken.Type !== Tokens.COMMENT) {
+            return;
         }
-        return comment;
+        const comment = this.curToken.Literal.replace(/^;(\s*)/, '');
+        this.nextToken();
+        if (comment.trim().length === 0) {
+            return;
+        }
+        return { Type: 'comment', Content: comment, Leading: Boolean(isLeading) };
     }
     parse() {
         const definition = [];
         while (this.curToken.Type !== Tokens.EOF) {
-            if (this.curToken.Type === Tokens.COMMENT) {
-                const comment = {
-                    Type: 'comment',
-                    Content: this.curToken.Literal.slice(1).trim()
-                };
-                definition.push(comment);
-                this.nextToken();
-                continue;
-            }
             const group = this.parseAssignments();
             if (group) {
                 definition.push(group);

package/build/transform/ts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ts.d.ts","sourceRoot":"","sources":["../../src/transform/ts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAA6C,MAAM,QAAQ,CAAA;AAanF,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,UAoBnD"}
+{"version":3,"file":"ts.d.ts","sourceRoot":"","sources":["../../src/transform/ts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAmG,MAAM,QAAQ,CAAA;AAmBzI,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,UAkBnD"}

package/build/transform/ts.js

@@ -4,14 +4,17 @@ import typescriptParser from 'recast/parsers/typescript.js';
 // @ts-ignore
 import pkg from '../../package.json' assert { type: 'json' };
 const b = types.builders;
-const comments = [];
 const NATIVE_TYPES = {
-    number: 'number',
-    uint: 'Uint32Array',
-    bool: 'boolean',
-    str: 'string',
-    text: 'string',
-    tstr: 'string'
+    number: b.tsNumberKeyword(),
+    float: b.tsNumberKeyword(),
+    uint: b.tsNumberKeyword(),
+    bool: b.tsBooleanKeyword(),
+    str: b.tsStringKeyword(),
+    text: b.tsStringKeyword(),
+    tstr: b.tsStringKeyword(),
+    range: b.tsNumberKeyword(),
+    nil: b.tsNullKeyword(),
+    null: b.tsNullKeyword()
 };
 export function transform(assignments) {
     let ast = parse(`// compiled with https://www.npmjs.com/package/cddl v${pkg.version}`, {
@@ -26,14 +29,9 @@ export function transform(assignments) {
         }
         ast.program.body.push(statement);
     }
-    ast.program.comments = comments.map((c) => b.commentLine(c, false, false));
     return print(ast).code;
 }
 function parseAssignment(ast, assignment) {
-    if (assignment.Type === 'comment') {
-        comments.push(assignment.Content);
-        return;
-    }
     if (assignment.Type === 'variable') {
         const propType = Array.isArray(assignment.PropertyType)
             ? assignment.PropertyType
@@ -48,13 +46,18 @@ function parseAssignment(ast, assignment) {
             typeParameters = b.tsUnionType(propType.map(parsePropertyType));
         }
         const expr = b.tsTypeAliasDeclaration(id, typeParameters);
-        expr.comments = comments.map((c) => b.commentLine(c, true));
+        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
         return expr;
     }
     if (assignment.Type === 'group') {
         const id = b.identifier(camelcase(assignment.Name, { pascalCase: true }));
         const objectType = parseObjectType(assignment.Properties);
-        const expr = b.interfaceDeclaration(id, objectType, []);
+        const extendInterfaces = assignment.Properties
+            .filter((prop) => prop.Name === '')
+            .map((prop) => b.tsExpressionWithTypeArguments(b.identifier(camelcase(prop.Type[0].Value, { pascalCase: true }))));
+        const expr = b.tsInterfaceDeclaration(id, b.tsInterfaceBody(objectType));
+        expr.extends = extendInterfaces;
+        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
         return expr;
     }
 }
@@ -63,7 +66,7 @@ function parsePropertyType(propType) {
         return b.tsStringKeyword();
     }
     if (propType.Type === 'group') {
-        return b.tsTypeReference(b.identifier(propType.Value.toString()));
+        return b.tsTypeReference(b.identifier(camelcase(propType.Value.toString(), { pascalCase: true })));
     }
     if (propType.Type === 'literal') {
         return b.tsLiteralType(b.stringLiteral(propType.Value.toString()));
@@ -74,40 +77,109 @@ function parseObjectType(props) {
     const propItems = [];
     for (const prop of props) {
         /**
-         * ToDo(Christian): support Extensible
+         * Empty groups like
+         * {
+         *   HasCut: false,
+         *   Occurrence: { n: 1, m: 1 },
+         *   Name: '',
+         *   Type: [ { Type: 'group', Value: 'Extensible', Unwrapped: false } ],
+         *   Comment: ''
+         * }
+         * are ignored and later added as interface extensions
          */
         if (prop.Name === '') {
-            propItems[propItems.length - 1].comments = [b.commentLine(`Missing: ${JSON.stringify(prop)}`)];
             continue;
         }
         const id = b.identifier(camelcase(prop.Name));
         const cddlType = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
-        const typeParameters = b.unionTypeAnnotation(cddlType.map((t) => {
-            if (typeof t === 'string') {
-                if (!NATIVE_TYPES[t]) {
-                    throw new Error(`Unknown native type: "${t}`);
-                }
-                return b.typeParameter(NATIVE_TYPES[t]);
-            }
-            else if (t.Value === 'null') {
-                return b.nullTypeAnnotation();
-            }
-            else if (t.Type === 'group') {
-                const value = t.Value;
-                return b.typeParameter(
-                /**
-                 * transform native CDDL types into TypeScript types
-                 */
-                NATIVE_TYPES[value] ? value : camelcase(value.toString(), { pascalCase: true }));
-            }
-            else if (t.Type === 'literal' && typeof t.Value === 'string') {
-                return b.stringLiteralTypeAnnotation(t.Value, t.Value);
+        const comments = prop.Comments.map((c) => ` ${c.Content}`);
+        if (prop.Operator && prop.Operator.Type === 'default') {
+            const defaultValue = parseDefaultValue(prop.Operator);
+            defaultValue && comments.length && comments.push(''); // add empty line if we have previous comments
+            defaultValue && comments.push(` @default ${defaultValue}`);
+        }
+        const type = cddlType.map((t) => {
+            const unionType = parseUnionType(t);
+            if (unionType) {
+                const defaultValue = parseDefaultValue(t.Operator);
+                defaultValue && comments.length && comments.push(''); // add empty line if we have previous comments
+                defaultValue && comments.push(` @default ${defaultValue}`);
+                return unionType;
             }
             throw new Error(`Couldn't parse property ${JSON.stringify(t)}`);
-        }));
+        });
+        const typeAnnotation = b.tsTypeAnnotation(b.tsUnionType(type));
         const isOptional = prop.Occurrence.n === 0;
-        propItems.push(b.objectTypeProperty(id, typeParameters, isOptional));
+        const propSignature = b.tsPropertySignature(id, typeAnnotation, isOptional);
+        propSignature.comments = comments.length ? [b.commentBlock(`*\n *${comments.join('\n *')}\n `)] : [];
+        propItems.push(propSignature);
+    }
+    return propItems;
+}
+function parseUnionType(t) {
+    if (typeof t === 'string') {
+        if (!NATIVE_TYPES[t]) {
+            throw new Error(`Unknown native type: "${t}`);
+        }
+        return NATIVE_TYPES[t];
+    }
+    else if (NATIVE_TYPES[t.Type]) {
+        return NATIVE_TYPES[t.Type];
+    }
+    else if (t.Value === 'null') {
+        return b.tsNullKeyword();
+    }
+    else if (t.Type === 'group') {
+        const value = t.Value;
+        /**
+         * check if we have
+         * ?attributes: {*text => text},
+         */
+        if (!value && t.Properties) {
+            return b.tsTypeLiteral(parseObjectType(t.Properties));
+        }
+        return b.tsTypeReference(b.identifier(camelcase(value.toString(), { pascalCase: true })));
+    }
+    else if (t.Type === 'literal' && typeof t.Value === 'string') {
+        return b.tsLiteralType(b.stringLiteral(t.Value));
+    }
+    else if (t.Type === 'literal' && typeof t.Value === 'number') {
+        return b.tsLiteralType(b.numericLiteral(t.Value));
+    }
+    else if (t.Type === 'array') {
+        const types = t.Values[0].Type;
+        const typedTypes = (Array.isArray(types) ? types : [types]).map((val) => {
+            return typeof val === 'string' && NATIVE_TYPES[val]
+                ? NATIVE_TYPES[val]
+                : b.tsTypeReference(b.identifier(camelcase(val.Value, { pascalCase: true })));
+        });
+        return b.tsArrayType(typedTypes.length > 1
+            ? b.tsParenthesizedType(b.tsUnionType(typedTypes))
+            : b.tsUnionType(typedTypes));
+    }
+    else if (typeof t.Type === 'object' && t.Type.Type === 'range') {
+        return b.tsNumberKeyword();
+    }
+    else if (typeof t.Type === 'object' && t.Type.Type === 'group') {
+        /**
+         * e.g. ?pointerType: input.PointerType .default "mouse"
+         */
+        const referenceValue = camelcase(t.Type.Value, { pascalCase: true });
+        return b.tsTypeReference(b.identifier(referenceValue));
+    }
+}
+function parseDefaultValue(operator) {
+    if (!operator || operator.Type !== 'default') {
+        return;
+    }
+    const operatorValue = operator.Value;
+    if (operator.Value === 'null') {
+        return operator.Value;
+    }
+    if (operatorValue.Type !== 'literal') {
+        throw new Error(`Can't parse operator default value of ${JSON.stringify(operator)}`);
     }
-    const obj = b.objectTypeAnnotation(propItems);
-    return obj;
+    return typeof operatorValue.Value === 'string'
+        ? `'${operatorValue.Value}'`
+        : operatorValue.Value;
 }

package/examples/webdriver/remote.cddl

@@ -227,7 +227,7 @@ ScriptCommand = (
   script.CallFunction //
   script.Disown //
   script.Evaluate //
-  script.GetRealms
+  script.GetRealms //
   script.RemovePreloadScriptCommand
 )
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Concise data definition language (RFC 8610) implementation and JSON validator in Node.js",
   "author": "Christian Bromann <christian@saucelabs.com>",
   "license": "MIT",