cddl 0.15.0 → 0.17.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Christian Bromann
+Copyright (c) 2026 WebdriverIO Project
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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;AAoBjB,MAAM,CAAC,OAAO,OAAO,MAAM;;IAEvB,CAAC,EAAE,KAAK,CAAC;IAET,QAAQ,EAAE,KAAK,CAAa;IAC5B,SAAS,EAAE,KAAK,CAAa;IAC7B,cAAc,EAAE,KAAK,CAAa;gBAErB,QAAQ,EAAE,MAAM;IAS7B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,gBAAgB;IA2CxB,OAAO,CAAC,oBAAoB;IAue5B,OAAO,CAAC,wBAAwB;IAahC;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAqKzB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,kBAAkB;IAuD1B,OAAO,CAAC,gBAAgB;IA4DxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB,KAAK;IAaL,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;IAC7B,cAAc,EAAE,KAAK,CAAa;gBAErB,QAAQ,EAAE,MAAM;IAS7B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,gBAAgB;IA8CxB,OAAO,CAAC,oBAAoB;IAue5B,OAAO,CAAC,wBAAwB;IAahC;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAqKzB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,kBAAkB;IA8E1B,OAAO,CAAC,gBAAgB;IA4DxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB,KAAK;IAaL,OAAO,CAAC,WAAW;CAKtB"}

package/build/parser.js

@@ -43,7 +43,10 @@ export default class Parser {
     parseAssignments() {
         const comments = [];
         while (this.curToken.Type === Tokens.COMMENT) {
-            comments.push(this.parseComment());
+            const comment = this.parseComment();
+            if (comment) {
+                comments.push(comment);
+            }
         }
         /**
          * expect group identifier, e.g.
@@ -588,7 +591,7 @@ export default class Parser {
                         Unwrapped: isUnwrapped
                     };
                 }
-                else if (this.curToken.Literal === Tokens.LBRACE) {
+                else if (this.curToken.Literal === Tokens.LBRACE || this.curToken.Literal === Tokens.LBRACK) {
                     const val = this.parseAssignmentValue();
                     if (Array.isArray(val)) {
                         throw new Error('Unexpected array in property type parsing');
@@ -739,6 +742,21 @@ export default class Parser {
             this.nextToken(); // eat Property if not already consumed (e.g. by Group parsing)
         }
         propertyTypes.push(prop);
+        /**
+         * ignore comments between type choice members, e.g.
+         * ```
+         * Foo = int ; comment
+         *     / text
+         * ```
+         * or
+         * ```
+         * Foo = int / ; comment
+         *     text
+         * ```
+         */
+        while (this.curToken.Type === Tokens.COMMENT && this.peekToken.Type === Tokens.SLASH) {
+            this.parseComment();
+        }
         /**
          * ensure we don't go into the next choice, e.g.:
          * ```
@@ -754,6 +772,9 @@ export default class Parser {
          */
         while (this.curToken.Type === Tokens.SLASH) {
             this.nextToken(); // eat `/`
+            while ([Tokens.COMMENT].includes(this.curToken.Type)) {
+                this.parseComment();
+            }
             propertyTypes.push(this.parsePropertyType());
             if (!this.isOperator() && this.curToken.Type !== Tokens.SLASH) {
                 /**
@@ -762,6 +783,9 @@ export default class Parser {
                  */
                 this.nextToken();
             }
+            while ([Tokens.COMMENT].includes(this.curToken.Type) && this.peekToken.Type === Tokens.SLASH) {
+                this.parseComment();
+            }
             /**
              * ensure we don't go into the next choice, e.g.:
              * ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Concise data definition language (RFC 8610) implementation and JSON validator in Node.js",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -21,6 +21,10 @@
   "bin": {
     "cddl": "./bin/cddl.js"
   },
+  "files": [
+    "build",
+    "bin"
+  ],
   "devDependencies": {
     "@types/node": "^25.5.0",
     "@types/yargs": "^17.0.35"

package/.release-it.ts

@@ -1,10 +0,0 @@
-import baseConfig from '../../.release-it.base';
-import type { Config } from 'release-it';
-
-const config: Config = {
-  ...baseConfig('cddl'),
-};
-
-console.log("Release-it config for cddl loaded", config);
-
-export default config;

package/docs/README.md

@@ -1,47 +0,0 @@
-# CDDL AST Parser Documentation
-
-This documentation describes the Abstract Syntax Tree (AST) generated by the CDDL (Concise Data Definition Language) parser in this project. The CDDL format is defined in the [RFC 8610 specification](https://datatracker.ietf.org/doc/rfc8610/).
-
-## Overview
-
-The parser transforms CDDL files into an Abstract Syntax Tree (AST) representation that can be further processed to generate other formats like TypeScript type definitions. This documentation explains the structure of the AST and its components.
-
-## Documentation Structure
-
-- [AST Structure](./ast-structure.md) - Overview of the AST structure
-- [Basic Types](./basic-types.md) - Core types in the AST
-- [Groups](./groups.md) - Group definitions
-- [Arrays](./arrays.md) - Array definitions
-- [Variables](./variables.md) - Variable assignments
-- [Properties](./properties.md) - Property definitions
-- [Comments](./comments.md) - Comment handling
-- [Ranges](./ranges.md) - Range representations
-- [Operators](./operators.md) - Available operators
-- [References](./references.md) - Property reference types
-
-## Example Usage
-
-```typescript
-import Parser from '../src/parser.js'
-
-// Create a new parser instance with the path to a CDDL file
-const parser = new Parser('./example.cddl')
-
-// Parse the file and get the AST
-const ast = parser.parse()
-
-// Now you can work with the AST to generate other formats
-console.log(JSON.stringify(ast, null, 2))
-```
-
-## AST Format
-
-The AST generated by the parser consists of a series of Assignment nodes, which can be one of:
-
-- Group definitions
-- Array definitions
-- Variable assignments
-
-Each of these contains properties and references that form a tree structure representing the CDDL document.
-
-See the individual documentation files for detailed information on each component of the AST.

package/docs/arrays.md

@@ -1,356 +0,0 @@
-# Arrays
-
-Arrays are a core component of CDDL that define ordered collections of elements. This document explains how arrays are represented in the AST.
-
-## Array Definition
-
-In the AST, an array is represented by the following structure:
-
-```typescript
-export type Array = {
-    Type: 'array'
-    Name: string
-    Values: (Property|Property[])[]
-    Comments: Comment[]
-}
-```
-
-Where:
-- `Type`: Always set to 'array' to identify this node as an array
-- `Name`: The name of the array
-- `Values`: An array of properties or property choice arrays that define the elements of the array
-- `Comments`: An array of comments associated with the array
-
-## Array Elements
-
-The elements of an array are defined by the `Values` field, which contains property definitions. Each property can represent:
-
-1. A named element:
-   ```cddl
-   [field1: int, field2: text]
-   ```
-
-2. An unnamed element:
-   ```cddl
-   [int, text]
-   ```
-
-3. A repeated element with occurrence indicators:
-   ```cddl
-   [* int]
-   ```
-
-4. A choice between multiple elements:
-   ```cddl
-   [(int // text)]
-   ```
-
-## Named Array Example
-
-```cddl
-basic-header = [
-    field1: int,
-    field2: text
-]
-```
-
-AST representation:
-
-```json
-{
-  "Type": "array",
-  "Name": "basic-header",
-  "Values": [
-    {
-      "HasCut": true,
-      "Occurrence": { "n": 1, "m": 1 },
-      "Name": "field1",
-      "Type": ["int"],
-      "Comments": []
-    },
-    {
-      "HasCut": true,
-      "Occurrence": { "n": 1, "m": 1 },
-      "Name": "field2",
-      "Type": ["text"],
-      "Comments": []
-    }
-  ],
-  "Comments": []
-}
-```
-
-## Array with Occurrence Indicators
-
-CDDL allows specifying how many times an element can occur using occurrence indicators. The AST represents this using the `Occurrence` field in the Property object.
-
-```cddl
-unlimited-people = [* person]
-at-least-one-person = [+ person]
-zero-or-one-person = [? person]
-one-or-two-people = [1*2 person]
-zero-or-two-people = [0*2 person]
-two-or-infinity-people = [2* person]
-```
-
-AST representation for "unlimited-people":
-
-```json
-{
-  "Type": "array",
-  "Name": "unlimited-people",
-  "Values": [
-    {
-      "HasCut": false,
-      "Occurrence": { "n": 0, "m": Infinity },
-      "Name": "",
-      "Type": [
-        {
-          "Type": "group",
-          "Value": "person",
-          "Unwrapped": false
-        }
-      ],
-      "Comments": []
-    }
-  ],
-  "Comments": []
-}
-```
-
-AST representation for "one-or-two-people":
-
-```json
-{
-  "Type": "array",
-  "Name": "one-or-two-people",
-  "Values": [
-    {
-      "HasCut": false,
-      "Occurrence": { "n": 1, "m": 2 },
-      "Name": "",
-      "Type": [
-        {
-          "Type": "group",
-          "Value": "person",
-          "Unwrapped": false
-        }
-      ],
-      "Comments": []
-    }
-  ],
-  "Comments": []
-}
-```
-
-## Unwrapped Arrays
-
-CDDL allows for unwrapping arrays to include their elements directly in another array. This is represented in the AST with the `Unwrapped` flag set to `true` in the type reference.
-
-```cddl
-basic-header = [
-    field1: int,
-    field2: text
-]
-
-advanced-header = [
-    ~basic-header,
-    field3: bytes,
-    field4: ~time
-]
-```
-
-AST representation for "advanced-header":
-
-```json
-{
-  "Type": "array",
-  "Name": "advanced-header",
-  "Values": [
-    {
-      "HasCut": false,
-      "Occurrence": { "n": 1, "m": 1 },
-      "Name": "",
-      "Type": [
-        {
-          "Type": "group",
-          "Value": "basic-header",
-          "Unwrapped": true
-        }
-      ],
-      "Comments": []
-    },
-    {
-      "HasCut": true,
-      "Occurrence": { "n": 1, "m": 1 },
-      "Name": "field3",
-      "Type": ["bytes"],
-      "Comments": []
-    },
-    {
-      "HasCut": true,
-      "Occurrence": { "n": 1, "m": 1 },
-      "Name": "field4",
-      "Type": [
-        {
-          "Type": "group",
-          "Value": "time",
-          "Unwrapped": true
-        }
-      ],
-      "Comments": []
-    }
-  ],
-  "Comments": []
-}
-```
-
-## Nested Arrays
-
-Arrays can be nested to represent more complex structures:
-
-```cddl
-script.MappingRemoteValue = [
-    * [
-        script.RemoteValue / text,
-        script.RemoteValue
-    ]
-]
-```
-
-AST representation:
-
-```json
-{
-  "Type": "array",
-  "Name": "script.MappingRemoteValue",
-  "Values": [
-    {
-      "HasCut": false,
-      "Occurrence": { "n": 0, "m": Infinity },
-      "Name": "",
-      "Type": {
-        "Type": "array",
-        "Name": "",
-        "Values": [
-          {
-            "HasCut": false,
-            "Occurrence": { "n": 1, "m": 1 },
-            "Name": "",
-            "Type": [
-              {
-                "Type": "group",
-                "Value": "script.RemoteValue",
-                "Unwrapped": false
-              },
-              "text"
-            ],
-            "Comments": []
-          },
-          {
-            "HasCut": false,
-            "Occurrence": { "n": 1, "m": 1 },
-            "Name": "",
-            "Type": [
-              {
-                "Type": "group",
-                "Value": "script.RemoteValue",
-                "Unwrapped": false
-              }
-            ],
-            "Comments": []
-          }
-        ],
-        "Comments": []
-      },
-      "Comments": []
-    }
-  ],
-  "Comments": []
-}
-```
-
-## Array Element Choices
-
-CDDL allows for choices between different types of elements in an array. In the AST, this is represented by an array of types in the `Type` field of a property.
-
-```cddl
-points = [* (int / float)]
-```
-
-AST representation:
-
-```json
-{
-  "Type": "array",
-  "Name": "points",
-  "Values": [
-    {
-      "HasCut": false,
-      "Occurrence": { "n": 0, "m": Infinity },
-      "Name": "",
-      "Type": [
-        "int",
-        "float"
-      ],
-      "Comments": []
-    }
-  ],
-  "Comments": []
-}
-```
-
-## Using Arrays as Types
-
-Arrays can also be used as types in property definitions:
-
-```cddl
-located-samples = {
-  sample-point: int,
-  samples: [+ float]
-}
-```
-
-AST representation:
-
-```json
-{
-  "Type": "group",
-  "Name": "located-samples",
-  "IsChoiceAddition": false,
-  "Properties": [
-    {
-      "HasCut": false,
-      "Occurrence": { "n": 1, "m": 1 },
-      "Name": "sample-point",
-      "Type": ["int"],
-      "Comments": []
-    },
-    {
-      "HasCut": false,
-      "Occurrence": { "n": 1, "m": 1 },
-      "Name": "samples",
-      "Type": [
-        {
-          "Type": "array",
-          "Name": "",
-          "Values": [
-            {
-              "HasCut": false,
-              "Occurrence": { "n": 1, "m": Infinity },
-              "Name": "",
-              "Type": "float",
-              "Comments": []
-            }
-          ],
-          "Comments": []
-        }
-      ],
-      "Comments": []
-    }
-  ],
-  "Comments": []
-}
-```
-
-By understanding these different array representations in the AST, you can properly interpret and process CDDL array definitions for further transformation or analysis.

package/docs/ast-structure.md

@@ -1,166 +0,0 @@
-# AST Structure
-
-The CDDL parser generates an Abstract Syntax Tree (AST) that represents the structure and semantics of a CDDL document. This document provides an overview of the AST structure.
-
-## Root Structure
-
-The root of the AST is an array of `Assignment` nodes, which can be one of:
-
-- `Group` - Defines a group of properties
-- `Array` - Defines an array of values
-- `Variable` - Defines a variable assignment
-
-```typescript
-// The type hierarchy of the AST root
-export type Assignment = Group | Array | Variable
-```
-
-## Core Components
-
-The AST is composed of several core types that represent different CDDL constructs:
-
-### Assignments
-
-Assignments are the top-level nodes in the AST. They represent named definitions in CDDL.
-
-```typescript
-// Example AST for a group assignment:
-{
-  "Type": "group",
-  "Name": "person",
-  "IsChoiceAddition": false,
-  "Properties": [
-    // Properties...
-  ],
-  "Comments": []
-}
-```
-
-### Properties
-
-Properties define members of groups or elements of arrays.
-
-```typescript
-export type Property = {
-    HasCut: boolean               // Whether the property has a "cut" marker (/)
-    Occurrence: Occurrence        // How many times the property can occur
-    Name: PropertyName            // The name of the property (string)
-    Type: PropertyType | PropertyType[] // The type(s) of the property
-    Comments: Comment[]           // Comments attached to the property
-    Operator?: Operator           // Optional operator modifying the property
-}
-```
-
-### Types
-
-Types define the allowed values for properties and variables. They can be:
-
-- Primitive types (int, uint, tstr, etc.)
-- References to groups or other types
-- Literals (specific values)
-- Complex types (like ranges, choices, etc.)
-
-```typescript
-export type PropertyType = Assignment | Array | PropertyReference | string | NativeTypeWithOperator
-```
-
-## Relationships Between Components
-
-The AST forms a tree structure where:
-
-1. The root consists of assignments
-2. Assignments contain properties or type definitions
-3. Properties reference types
-4. Types can reference other assignments
-
-This hierarchical structure allows the AST to represent complex CDDL documents with nested definitions, references, and type relationships.
-
-## Example AST
-
-Here's a simplified example of an AST for a basic CDDL definition:
-
-```cddl
-person = {
-  name: tstr,
-  age: uint,
-  addresses: [* address],
-}
-
-address = {
-  street: tstr,
-  city: tstr,
-}
-```
-
-Would generate an AST like:
-
-```json
-[
-  {
-    "Type": "group",
-    "Name": "person",
-    "IsChoiceAddition": false,
-    "Properties": [
-      {
-        "HasCut": true,
-        "Occurrence": { "n": 1, "m": 1 },
-        "Name": "name",
-        "Type": ["tstr"],
-        "Comments": []
-      },
-      {
-        "HasCut": true,
-        "Occurrence": { "n": 1, "m": 1 },
-        "Name": "age",
-        "Type": ["uint"],
-        "Comments": []
-      },
-      {
-        "HasCut": true,
-        "Occurrence": { "n": 1, "m": 1 },
-        "Name": "addresses",
-        "Type": [{
-          "Type": "array",
-          "Values": [{
-            "HasCut": false,
-            "Occurrence": { "n": 0, "m": Infinity },
-            "Name": "",
-            "Type": [{
-              "Type": "group",
-              "Value": "address",
-              "Unwrapped": false
-            }],
-            "Comments": []
-          }]
-        }],
-        "Comments": []
-      }
-    ],
-    "Comments": []
-  },
-  {
-    "Type": "group",
-    "Name": "address",
-    "IsChoiceAddition": false,
-    "Properties": [
-      {
-        "HasCut": true,
-        "Occurrence": { "n": 1, "m": 1 },
-        "Name": "street",
-        "Type": ["tstr"],
-        "Comments": []
-      },
-      {
-        "HasCut": true,
-        "Occurrence": { "n": 1, "m": 1 },
-        "Name": "city",
-        "Type": ["tstr"],
-        "Comments": []
-      }
-    ],
-    "Comments": []
-  }
-]
-```
-
-See the other documentation files for details on each component of the AST.