cddl2ts 0.2.2 → 0.3.0

package/build/cli.d.ts

@@ -1,2 +1,2 @@
-export default function cli(args?: string[]): Promise<undefined>;
+export default function cli(argv?: string[]): Promise<undefined>;
 //# sourceMappingURL=cli.d.ts.map

package/build/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAmBA,wBAA8B,GAAG,CAAE,IAAI,WAAwB,sBAmB9D"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AASA,wBAA8B,GAAG,CAAE,IAAI,WAAwB,sBAgC9D"}

package/build/cli.js

@@ -1,33 +1,34 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import yargs from 'yargs';
 import { parse } from 'cddl';
 import { transform } from './index.js';
 import { pkg } from './constants.js';
-const HELP = `
-${pkg.name}
-${pkg.description}
-
-Usage:
-runme2ts ./path/to/spec.cddl &> ./path/to/interface.ts
-
-v${pkg.version}
-Copyright ${(new Date()).getFullYear()} ${pkg.author}
-`;
-export default async function cli(args = process.argv.slice(2)) {
-    if (args.includes('--help') || args.length === 0) {
-        console.log(HELP);
+export default async function cli(argv = process.argv.slice(2)) {
+    const parser = yargs(argv)
+        .usage(`${pkg.name}\n${pkg.description}\n\nUsage:\nrunme2ts ./path/to/spec.cddl &> ./path/to/interface.ts`)
+        .epilog(`v${pkg.version}\nCopyright ${(new Date()).getFullYear()} ${pkg.author}`)
+        .version(pkg.version)
+        .option('u', {
+        alias: 'unknown-as-any',
+        type: 'boolean',
+        description: 'Use unknown instead of any',
+        default: false
+    })
+        .help('help')
+        .alias('h', 'help')
+        .alias('v', 'version');
+    const args = await parser.argv;
+    if (args._.length === 0) {
+        parser.showHelp();
         return process.exit(0);
     }
-    if (args.includes('--version') || args.includes('-v')) {
-        console.log(pkg.version);
-        return process.exit(0);
-    }
-    const absoluteFilePath = path.resolve(process.cwd(), args[0]);
+    const absoluteFilePath = path.resolve(process.cwd(), args._[0]);
     const hasAccess = await fs.access(absoluteFilePath).then(() => true, () => false);
     if (!hasAccess) {
         console.error(`Couldn't find or access source CDDL file at "${absoluteFilePath}"`);
         return process.exit(1);
     }
     const ast = parse(absoluteFilePath);
-    console.log(transform(ast));
+    console.log(transform(ast, { useUnknown: args.u }));
 }

package/build/index.d.ts

@@ -1,3 +1,6 @@
 import type { Assignment } from 'cddl';
-export declare function transform(assignments: Assignment[]): string;
+export interface TransformOptions {
+    useUnknown?: boolean;
+}
+export declare function transform(assignments: Assignment[], options?: TransformOptions): string;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAmG,MAAM,MAAM,CAAA;AAsBvI,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,UAkBnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAA8D,MAAM,MAAM,CAAA;AAoClG,MAAM,WAAW,gBAAgB;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,UAwB/E"}

package/build/index.js

@@ -1,11 +1,13 @@
 import camelcase from 'camelcase';
 import { parse, print, types } from 'recast';
 import typescriptParser from 'recast/parsers/typescript.js';
+import { isCDDLArray, isGroup, isNamedGroupReference, isLiteralWithValue, isNativeTypeWithOperator, isUnNamedProperty, isPropertyReference, isRange, isVariable, pascalCase } from './utils.js';
 import { pkg } from './constants.js';
 const b = types.builders;
 const NATIVE_TYPES = {
     any: b.tsAnyKeyword(),
     number: b.tsNumberKeyword(),
+    int: b.tsNumberKeyword(),
     float: b.tsNumberKeyword(),
     uint: b.tsNumberKeyword(),
     bool: b.tsBooleanKeyword(),
@@ -16,14 +18,20 @@ const NATIVE_TYPES = {
     nil: b.tsNullKeyword(),
     null: b.tsNullKeyword()
 };
-export function transform(assignments) {
+export function transform(assignments, options) {
+    if (options?.useUnknown) {
+        NATIVE_TYPES.any = b.tsUnknownKeyword();
+    }
+    else {
+        NATIVE_TYPES.any = b.tsAnyKeyword();
+    }
     let ast = parse(`// compiled with https://www.npmjs.com/package/cddl2ts v${pkg.version}`, {
         parser: typescriptParser,
         sourceFileName: 'cddl2Ts.ts',
         sourceRoot: process.cwd()
     });
     for (const assignment of assignments) {
-        const statement = parseAssignment(ast, assignment);
+        const statement = parseAssignment(assignment);
         if (!statement) {
             continue;
         }
@@ -31,72 +39,376 @@ export function transform(assignments) {
     }
     return print(ast).code;
 }
-function parseAssignment(ast, assignment) {
-    if (assignment.Type === 'variable') {
+function parseAssignment(assignment) {
+    if (isVariable(assignment)) {
         const propType = Array.isArray(assignment.PropertyType)
             ? assignment.PropertyType
             : [assignment.PropertyType];
-        const id = b.identifier(camelcase(assignment.Name, { pascalCase: true }));
+        const id = b.identifier(pascalCase(assignment.Name));
         let typeParameters;
         // @ts-expect-error e.g. "js-int = -9007199254740991..9007199254740991"
         if (propType.length === 1 && propType[0].Type === 'range') {
             typeParameters = b.tsNumberKeyword();
         }
         else {
-            typeParameters = b.tsUnionType(propType.map(parsePropertyType));
+            typeParameters = b.tsUnionType(propType.map(parseUnionType));
         }
         const expr = b.tsTypeAliasDeclaration(id, typeParameters);
         expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
         return b.exportDeclaration(false, expr);
     }
-    if (assignment.Type === 'group') {
-        const id = b.identifier(camelcase(assignment.Name, { pascalCase: true }));
+    if (isGroup(assignment)) {
+        const id = b.identifier(pascalCase(assignment.Name));
+        /**
+         * Check if we have choices in the group (arrays of Properties)
+         */
+        const properties = assignment.Properties;
+        const hasChoices = properties.some(p => Array.isArray(p));
+        if (hasChoices) {
+            // Flatten static properties and collect choices
+            const staticProps = [];
+            const intersections = [];
+            for (let i = 0; i < properties.length; i++) {
+                const prop = properties[i];
+                if (Array.isArray(prop)) {
+                    // It's a choice (Union)
+                    // prop is Property[] where each Property is an option
+                    // CDDL parser appends the last choice element as a subsequent property
+                    // so we need to grab it and merge it into the union
+                    const choiceOptions = [...prop];
+                    const nextProp = properties[i + 1];
+                    if (nextProp && !Array.isArray(nextProp)) {
+                        choiceOptions.push(nextProp);
+                        i++; // Skip next property
+                    }
+                    const options = choiceOptions.map(p => {
+                        // If p is a group reference (Name ''), it's a TypeReference
+                        // e.g. SessionAutodetectProxyConfiguration // SessionDirectProxyConfiguration
+                        // The parser sometimes wraps it in an array, sometimes not (if inside a choice)
+                        const typeVal = Array.isArray(p.Type) ? p.Type[0] : p.Type;
+                        if (isUnNamedProperty(p)) {
+                            // Handle un-named properties (bare types) in choices.
+                            // Native types / literals
+                            if (isNamedGroupReference(typeVal)) {
+                                return b.tsTypeReference(b.identifier(pascalCase(typeVal.Value || typeVal.Type)));
+                            }
+                            return parseUnionType(typeVal);
+                        }
+                        // Otherwise it is an object literal with this property
+                        return b.tsTypeLiteral(parseObjectType([p]));
+                    });
+                    intersections.push(b.tsUnionType(options));
+                }
+                else {
+                    staticProps.push(prop);
+                }
+            }
+            if (staticProps.length > 0) {
+                // Check if we have mixins in static props
+                const mixins = staticProps.filter(isUnNamedProperty);
+                const ownProps = staticProps.filter(p => !isUnNamedProperty(p));
+                if (ownProps.length > 0) {
+                    intersections.unshift(b.tsTypeLiteral(parseObjectType(ownProps)));
+                }
+                for (const mixin of mixins) {
+                    if (Array.isArray(mixin.Type) && mixin.Type.length > 1) {
+                        const options = mixin.Type.map(parseUnionType);
+                        intersections.push(b.tsUnionType(options));
+                    }
+                    else {
+                        const typeVal = Array.isArray(mixin.Type) ? mixin.Type[0] : mixin.Type;
+                        if (isNamedGroupReference(typeVal)) {
+                            intersections.push(b.tsTypeReference(b.identifier(pascalCase(typeVal.Value))));
+                        }
+                    }
+                }
+            }
+            // If only one intersection element, return it directly
+            // If multiple, return Intersection
+            let value;
+            if (intersections.length === 0) {
+                value = b.tsAnyKeyword(); // Should not happen for valid CDDL?
+            }
+            else if (intersections.length === 1) {
+                value = intersections[0];
+            }
+            else {
+                value = b.tsIntersectionType(intersections);
+            }
+            const expr = b.tsTypeAliasDeclaration(id, value);
+            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
+            return b.exportDeclaration(false, expr);
+        }
+        const props = properties;
         /**
          * transform CDDL groups like `Extensible = (*text => any)`
          */
-        if (assignment.Properties.length === 1 && assignment.Properties[0].Type.length === 1 && Object.keys(NATIVE_TYPES).includes((assignment.Properties[0].Name))) {
-            const value = parseUnionType(assignment);
+        if (props.length === 1) {
+            const prop = props[0];
+            const propType = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
+            if (propType.length === 1 && Object.keys(NATIVE_TYPES).includes(prop.Name)) {
+                const value = parseUnionType(assignment);
+                const expr = b.tsTypeAliasDeclaration(id, value);
+                expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
+                return b.exportDeclaration(false, expr);
+            }
+        }
+        // Check if extended interfaces are likely unions or conflicting types
+        // In CDDL, including a group (Name '') that is defined elsewhere as a choice (union)
+        // is valid, but TypeScript interfaces cannot extend unions.
+        // We can't easily know if the referenced group is a union without a symbol table or 2-pass.
+        // However, if we simply use type intersection for ALL group inclusions, it is always safe.
+        // (Interface extending Interface is same as Type = Interface & Interface)
+        // Let's refactor to use Type Alias with Intersection if there are any mixins.
+        const mixins = props.filter(isUnNamedProperty);
+        if (mixins.length > 0) {
+            // It has mixins (extensions). Use type alias with intersection to be safe against unions.
+            // Type = (Mixin1 & Mixin2 & { OwnProps })
+            const intersections = [];
+            for (const mixin of mixins) {
+                // If mixin is a group choice (e.g. `(A // B)`), the parser returns a Group object
+                // with Properties containing the choices. We need to extract them.
+                if (Array.isArray(mixin.Type) && mixin.Type.length > 1) {
+                    // Check if it's a choice of types
+                    const unionOptions = [];
+                    for (const t of mixin.Type) {
+                        let refName;
+                        if (typeof t === 'string')
+                            refName = t;
+                        else if (isNamedGroupReference(t))
+                            refName = t.Value;
+                        else
+                            refName = t.Value || t.Type;
+                        if (refName)
+                            unionOptions.push(b.tsTypeReference(b.identifier(pascalCase(refName))));
+                    }
+                    if (unionOptions.length > 0) {
+                        intersections.push(b.tsParenthesizedType(b.tsUnionType(unionOptions)));
+                        continue;
+                    }
+                }
+                if (isGroup(mixin.Type) && Array.isArray(mixin.Type.Properties)) {
+                    const group = mixin.Type;
+                    const choices = [];
+                    for (const prop of group.Properties) {
+                        // Choices are wrapped in arrays in the properties
+                        const options = Array.isArray(prop) ? prop : [prop];
+                        if (options.length > 1) { // It's a choice within the mixin group
+                            const unionOptions = [];
+                            for (const option of options) {
+                                let refName;
+                                const type = option.Type;
+                                if (typeof type === 'string')
+                                    refName = type;
+                                else if (isNamedGroupReference(type))
+                                    refName = type.Value;
+                                else if (Array.isArray(type) && type[0]) {
+                                    const first = type[0];
+                                    if (isNamedGroupReference(first))
+                                        refName = first.Value;
+                                    else if (isUnNamedProperty(first)) {
+                                        if (isNamedGroupReference(first.Type))
+                                            refName = first.Type.Value;
+                                        else if (isGroup(first.Type) && first.Type.Properties && first.Type.Properties.length === 1) {
+                                            // Handle case where group reference is wrapped deeply
+                                            const subProp = first.Type.Properties[0];
+                                            if (isNamedGroupReference(subProp.Type))
+                                                refName = subProp.Type.Value;
+                                        }
+                                    }
+                                    if (!refName)
+                                        refName = first.Value || first.Type;
+                                }
+                                if (refName)
+                                    unionOptions.push(b.tsTypeReference(b.identifier(pascalCase(refName))));
+                            }
+                            if (unionOptions.length > 0) {
+                                choices.push(b.tsParenthesizedType(b.tsUnionType(unionOptions)));
+                                continue;
+                            }
+                        }
+                        for (const option of options) {
+                            let refName;
+                            const type = option.Type;
+                            if (typeof type === 'string') {
+                                refName = type;
+                            }
+                            else if (Array.isArray(type)) {
+                                if (type.length > 1) {
+                                    // console.log('DEBUG: Found array length > 1', JSON.stringify(type, null, 2))
+                                    const unionChoices = [];
+                                    for (const t of type) {
+                                        let name;
+                                        if (typeof t === 'string')
+                                            name = t;
+                                        else if (isNamedGroupReference(t))
+                                            name = t.Value;
+                                        else if (isUnNamedProperty(t)) {
+                                            if (isNamedGroupReference(t.Type))
+                                                name = t.Type.Value;
+                                            else if (isGroup(t.Type) && t.Type.Properties && t.Type.Properties.length === 1) {
+                                                const subProp = t.Type.Properties[0];
+                                                if (isNamedGroupReference(subProp.Type))
+                                                    name = subProp.Type.Value;
+                                            }
+                                        }
+                                        if (!name)
+                                            name = t.Value || t.Type;
+                                        if (name)
+                                            unionChoices.push(b.tsTypeReference(b.identifier(pascalCase(name))));
+                                    }
+                                    if (unionChoices.length > 0) {
+                                        choices.push(b.tsParenthesizedType(b.tsUnionType(unionChoices)));
+                                        continue;
+                                    }
+                                }
+                                else if (type.length === 1 && Array.isArray(type[0])) {
+                                    // Handle nested union e.g. [ [ A, B ] ] which seems common in some parsers for choices
+                                    const nested = type[0];
+                                    if (nested.length > 1) {
+                                        const unionChoices = [];
+                                        for (const t of nested) {
+                                            let name;
+                                            if (typeof t === 'string')
+                                                name = t;
+                                            else if (isNamedGroupReference(t))
+                                                name = t.Value;
+                                            else if (isUnNamedProperty(t)) {
+                                                if (isNamedGroupReference(t.Type))
+                                                    name = t.Type.Value;
+                                                else if (isGroup(t.Type) && t.Type.Properties && t.Type.Properties.length === 1) {
+                                                    const subProp = t.Type.Properties[0];
+                                                    if (isNamedGroupReference(subProp.Type))
+                                                        name = subProp.Type.Value;
+                                                }
+                                                else {
+                                                    // Fallback for wrapped primitive?
+                                                    name = t.Type.Value || t.Type.Type;
+                                                }
+                                            }
+                                            if (!name)
+                                                name = t.Value || t.Type;
+                                            if (name)
+                                                unionChoices.push(b.tsTypeReference(b.identifier(pascalCase(name))));
+                                        }
+                                        if (unionChoices.length > 0) {
+                                            choices.push(b.tsParenthesizedType(b.tsUnionType(unionChoices)));
+                                            continue;
+                                        }
+                                    }
+                                }
+                                const first = type[0];
+                                if (first) {
+                                    if (isNamedGroupReference(first)) {
+                                        refName = first.Value;
+                                    }
+                                    else if (!isGroup(first)) {
+                                        if (isUnNamedProperty(first)) {
+                                            if (isNamedGroupReference(first.Type)) {
+                                                refName = first.Type.Value;
+                                            }
+                                            else {
+                                                refName = first.Type.Value || first.Type.Type;
+                                            }
+                                        }
+                                        else {
+                                            refName = first.Value || first.Type;
+                                        }
+                                    }
+                                    else {
+                                        refName = first.Value || first.Type;
+                                    }
+                                }
+                            }
+                            else if (type && typeof type === 'object') {
+                                if (isGroup(type) && Array.isArray(type.Properties)) {
+                                    choices.push(b.tsTypeLiteral(parseObjectType(type.Properties)));
+                                    continue;
+                                }
+                                refName = isNamedGroupReference(type)
+                                    ? type.Value || type.Type
+                                    : type.Value || type.Type;
+                            }
+                            // If we found a refName, push it. Note that if this was a choice we handled above, we skip this
+                            if (refName) {
+                                choices.push(b.tsTypeReference(b.identifier(pascalCase(refName))));
+                            }
+                        }
+                    }
+                    if (choices.length > 0) {
+                        // Unions inside intersections must be parenthesized to avoid ambiguity
+                        // e.g. (A | B) & C vs A | (B & C)
+                        const union = b.tsUnionType(choices);
+                        intersections.push(b.tsParenthesizedType(union));
+                        continue;
+                    }
+                }
+                const propType = mixin.Type;
+                if (typeof propType === 'string' && NATIVE_TYPES[propType]) {
+                    intersections.push(NATIVE_TYPES[propType]);
+                    continue;
+                }
+                const groupRef = propType[0];
+                // Handle nested inline groups if any (though usually flat here if name is empty?)
+                const value = (groupRef?.Value || groupRef?.Type);
+                if (value) {
+                    intersections.push(b.tsTypeReference(b.identifier(pascalCase(value))));
+                }
+            }
+            const ownProps = props.filter(p => !isUnNamedProperty(p));
+            if (ownProps.length > 0) {
+                intersections.push(b.tsTypeLiteral(parseObjectType(ownProps)));
+            }
+            let value;
+            if (intersections.length === 1) {
+                value = intersections[0];
+            }
+            else {
+                value = b.tsIntersectionType(intersections);
+            }
             const expr = b.tsTypeAliasDeclaration(id, value);
             expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
             return b.exportDeclaration(false, expr);
         }
-        const objectType = parseObjectType(assignment.Properties);
-        const extendInterfaces = assignment.Properties
-            .filter((prop) => prop.Name === '')
-            .map((prop) => b.tsExpressionWithTypeArguments(b.identifier(camelcase(prop.Type[0].Value, { pascalCase: true }))));
+        // Fallback to interface if no mixins (pure object)
+        const objectType = parseObjectType(props);
         const expr = b.tsInterfaceDeclaration(id, b.tsInterfaceBody(objectType));
-        expr.extends = extendInterfaces;
         expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
         return b.exportDeclaration(false, expr);
     }
-    if (assignment.Type === 'array') {
-        const id = b.identifier(camelcase(assignment.Name, { pascalCase: true }));
-        const firstType = assignment.Values[0].Type;
+    if (isCDDLArray(assignment)) {
+        const id = b.identifier(pascalCase(assignment.Name));
+        const assignmentValues = assignment.Values[0];
+        if (Array.isArray(assignmentValues)) {
+            // It's a choice/union in the array definition
+            // e.g. Foo = [ (A | B) ]
+            // assignment.Values[0] is Property[] (the choices)
+            // We need to parse each choice.
+            const obj = assignmentValues.map((prop) => {
+                const t = Array.isArray(prop.Type) ? prop.Type[0] : prop.Type;
+                return parseUnionType(t);
+            });
+            const value = b.tsArrayType(b.tsParenthesizedType(b.tsUnionType(obj)));
+            const expr = b.tsTypeAliasDeclaration(id, value);
+            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
+            return b.exportDeclaration(false, expr);
+        }
+        // Standard array
+        const firstType = assignmentValues.Type;
         const obj = Array.isArray(firstType)
             ? firstType.map(parseUnionType)
-            : firstType.Values
-                ? firstType.Values.map((val) => parseUnionType(val.Type[0]))
-                // ToDo(Christian): transpile this case correctly
-                : [];
-        const value = b.tsArrayType(b.tsParenthesizedType(b.tsUnionType(obj)));
+            : isCDDLArray(firstType)
+                ? firstType.Values.map((val) => parseUnionType(Array.isArray(val.Type) ? val.Type[0] : val.Type))
+                : [parseUnionType(firstType)];
+        const value = b.tsArrayType(obj.length === 1
+            ? obj[0]
+            : b.tsParenthesizedType(b.tsUnionType(obj)));
         const expr = b.tsTypeAliasDeclaration(id, value);
         expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
         return b.exportDeclaration(false, expr);
     }
     throw new Error(`Unknown assignment type "${assignment.Type}"`);
 }
-function parsePropertyType(propType) {
-    if (typeof propType === 'string') {
-        return b.tsStringKeyword();
-    }
-    if (propType.Type === 'group') {
-        return b.tsTypeReference(b.identifier(camelcase(propType.Value.toString(), { pascalCase: true })));
-    }
-    if (propType.Type === 'literal') {
-        return b.tsLiteralType(b.stringLiteral(propType.Value.toString()));
-    }
-    throw new Error(`Couldn't parse property type ${JSON.stringify(propType, null, 4)}`);
-}
 function parseObjectType(props) {
     const propItems = [];
     for (const prop of props) {
@@ -111,7 +423,7 @@ function parseObjectType(props) {
          * }
          * are ignored and later added as interface extensions
          */
-        if (prop.Name === '') {
+        if (isUnNamedProperty(prop)) {
             continue;
         }
         const id = b.identifier(camelcase(prop.Name));
@@ -147,19 +459,55 @@ function parseUnionType(t) {
         }
         return NATIVE_TYPES[t];
     }
-    else if (NATIVE_TYPES[t.Type]) {
+    else if (t.Type && typeof t.Type === 'string' && NATIVE_TYPES[t.Type]) {
         return NATIVE_TYPES[t.Type];
     }
-    else if (t.Value === 'null') {
+    else if (isNativeTypeWithOperator(t) && NATIVE_TYPES[t.Type.Type]) {
+        return NATIVE_TYPES[t.Type.Type];
+    }
+    else if (isPropertyReference(t) && t.Value === 'null') {
         return b.tsNullKeyword();
     }
-    else if (t.Type === 'group') {
-        const value = t.Value;
+    else if (isGroup(t)) {
         /**
          * check if we have special groups
          */
-        if (!value && t.Properties) {
+        if (isGroup(t) && !isNamedGroupReference(t) && t.Properties) {
             const prop = t.Properties;
+            /**
+             * Check if we have choices in the group (arrays of Properties)
+             */
+            if (prop.some(p => Array.isArray(p))) {
+                const options = [];
+                for (const choice of prop) {
+                    const subProps = Array.isArray(choice) ? choice : [choice];
+                    if (subProps.length === 1 && isUnNamedProperty(subProps[0])) {
+                        const first = subProps[0];
+                        const subType = Array.isArray(first.Type) ? first.Type[0] : first.Type;
+                        options.push(parseUnionType(subType));
+                        continue;
+                    }
+                    if (subProps.every(isUnNamedProperty)) {
+                        const tupleItems = subProps.map((p) => {
+                            const subType = Array.isArray(p.Type) ? p.Type[0] : p.Type;
+                            return parseUnionType(subType);
+                        });
+                        options.push(b.tsTupleType(tupleItems));
+                        continue;
+                    }
+                    options.push(b.tsTypeLiteral(parseObjectType(subProps)));
+                }
+                return b.tsUnionType(options);
+            }
+            if (prop.every(isUnNamedProperty)) {
+                const items = prop.map(p => {
+                    const t = Array.isArray(p.Type) ? p.Type[0] : p.Type;
+                    return parseUnionType(t);
+                });
+                if (items.length === 1)
+                    return items[0];
+                return b.tsTupleType(items);
+            }
             /**
              * {*text => text} which will be transformed to `Record<string, string>`
              */
@@ -174,33 +522,48 @@ function parseUnionType(t) {
              */
             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 (isNamedGroupReference(t)) {
+            return b.tsTypeReference(b.identifier(pascalCase(t.Value)));
+        }
+        throw new Error(`Unknown group type: ${JSON.stringify(t)}`);
     }
-    else if (t.Type === 'literal' && typeof t.Value === 'number') {
-        return b.tsLiteralType(b.numericLiteral(t.Value));
+    else if (isLiteralWithValue(t)) {
+        if (typeof t.Value === 'string')
+            return b.tsLiteralType(b.stringLiteral(t.Value));
+        if (typeof t.Value === 'number')
+            return b.tsLiteralType(b.numericLiteral(t.Value));
+        if (typeof t.Value === 'boolean')
+            return b.tsLiteralType(b.booleanLiteral(t.Value));
+        if (typeof t.Value === 'bigint')
+            return b.tsLiteralType(b.bigIntLiteral(t.Value.toString()));
+        if (t.Value === null)
+            return b.tsNullKeyword();
+        throw new Error(`Unsupported literal type: ${JSON.stringify(t)}`);
     }
-    else if (t.Type === 'array') {
+    else if (isCDDLArray(t)) {
         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 })));
+            if (typeof val === 'string' && NATIVE_TYPES[val]) {
+                return NATIVE_TYPES[val];
+            }
+            return b.tsTypeReference(b.identifier(pascalCase(val.Value)));
         });
-        return b.tsArrayType(typedTypes.length > 1
-            ? b.tsParenthesizedType(b.tsUnionType(typedTypes))
-            : b.tsUnionType(typedTypes));
+        if (typedTypes.length > 1) {
+            return b.tsArrayType(b.tsParenthesizedType(b.tsUnionType(typedTypes)));
+        }
+        if (!typedTypes[0]) {
+            console.log('typedTypes[0] is missing!', types, typedTypes);
+        }
+        return b.tsArrayType(typedTypes[0]);
     }
-    else if (typeof t.Type === 'object' && t.Type.Type === 'range') {
+    else if (isRange(t)) {
         return b.tsNumberKeyword();
     }
-    else if (typeof t.Type === 'object' && t.Type.Type === 'group') {
+    else if (isNativeTypeWithOperator(t) && isNamedGroupReference(t.Type)) {
         /**
          * e.g. ?pointerType: input.PointerType .default "mouse"
          */
-        const referenceValue = camelcase(t.Type.Value, { pascalCase: true });
+        const referenceValue = pascalCase(t.Type.Value);
         return b.tsTypeReference(b.identifier(referenceValue));
     }
     throw new Error(`Unknown union type: ${JSON.stringify(t)}`);

package/build/utils.d.ts

@@ -0,0 +1,23 @@
+import { Assignment, PropertyReference, Property, Array, NativeTypeWithOperator, Group, Variable } from 'cddl';
+export declare function pascalCase(name: string): string;
+export declare function isVariable(assignment: Assignment): assignment is Variable;
+export declare function isGroup(t: any): t is Group;
+export declare function isCDDLArray(t: any): t is Array;
+export declare function isProperty(t: any): t is Property;
+export declare function isUnNamedProperty(t: any): t is Property & {
+    Name: '';
+};
+export declare function isNamedGroupReference(t: any): t is PropertyReference & {
+    Value: string;
+};
+export declare function isPropertyReference(t: any): t is PropertyReference;
+export declare function isNativeTypeWithOperator(t: any): t is NativeTypeWithOperator;
+export declare function isRange(t: any): boolean;
+export declare function isLiteralWithValue(t: any): t is {
+    Type: 'literal';
+    Value: unknown;
+};
+export declare function hasTypeProperty(t: any): t is {
+    Type: string;
+};
+//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,KAAK,EACL,sBAAsB,EACtB,KAAK,EACL,QAAQ,EACX,MAAM,MAAM,CAAA;AAGb,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,UAEtC;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,IAAI,QAAQ,CAEzE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,KAAK,CAE1C;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,KAAK,CAE9C;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,QAAQ,CAEhD;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,QAAQ,GAAG;IAAE,IAAI,EAAE,EAAE,CAAA;CAAE,CAEtE;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,iBAAiB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAExF;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,iBAAiB,CAElE;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,sBAAsB,CAE5E;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,GAAG,OAAO,CAEvC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI;IAC7C,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;CACjB,CAEA;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAE7D"}

package/build/utils.js

@@ -0,0 +1,37 @@
+import camelcase from 'camelcase';
+export function pascalCase(name) {
+    return camelcase(name, { pascalCase: true });
+}
+export function isVariable(assignment) {
+    return assignment.Type === 'variable';
+}
+export function isGroup(t) {
+    return t && t.Type === 'group';
+}
+export function isCDDLArray(t) {
+    return t && t.Type === 'array';
+}
+export function isProperty(t) {
+    return t && typeof t.Name === 'string' && typeof t.HasCut === 'boolean';
+}
+export function isUnNamedProperty(t) {
+    return isProperty(t) && t.Name === '';
+}
+export function isNamedGroupReference(t) {
+    return isGroup(t) && isPropertyReference(t) && typeof t.Value === 'string';
+}
+export function isPropertyReference(t) {
+    return t && 'Value' in t;
+}
+export function isNativeTypeWithOperator(t) {
+    return t && typeof t.Type === 'object' && 'Operator' in t;
+}
+export function isRange(t) {
+    return t && typeof t.Type === 'object' && t.Type.Type === 'range';
+}
+export function isLiteralWithValue(t) {
+    return t && t.Type === 'literal' && 'Value' in t;
+}
+export function hasTypeProperty(t) {
+    return t && typeof t.Type === 'string';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl2ts",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A Node.js package that can generate a TypeScript definition based on a CDDL file",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -12,6 +12,10 @@
   "keywords": [
     "cddl"
   ],
+  "engines": {
+    "node": ">=20.0.0",
+    "npm": ">=9.0.0"
+  },
   "bugs": {
     "url": "https://github.com/christian-bromann/cddl2ts/issues"
   },
@@ -30,23 +34,27 @@
     "release:patch": "npm run release -- patch",
     "release:minor": "npm run release -- minor",
     "release:major": "npm run release -- major",
-    "test": "vitest",
-    "watch": "tsc --watch"
+    "generate:local": "npm run compile && node ./bin/cddl2ts.js ./examples/webdriver/local.cddl --unknown-as-any > ./examples/webdriver/local.ts && tsc -p ./examples/webdriver/tsconfig.json",
+    "generate:remote": "npm run compile && node ./bin/cddl2ts.js ./examples/webdriver/remote.cddl --unknown-as-any > ./examples/webdriver/remote.ts && tsc -p ./examples/webdriver/tsconfig.json",
+    "generate:examples": "npm run generate:local && npm run generate:remote",
+    "test": "vitest run",
+    "watch": "tsc --watch",
+    "checks:all": "npm run compile && npm run test && npm run generate:examples"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.8",
-    "@types/node": "^20.9.0",
-    "@vitest/coverage-v8": "^0.34.6",
+    "@types/yargs": "^17.0.35",
+    "@types/node": "^24.12.0",
+    "@vitest/coverage-v8": "^4.1.0",
     "npm-run-all": "^4.1.5",
-    "release-it": "^16.2.1",
-    "typescript": "^5.2.2",
-    "vitest": "^0.34.6"
+    "release-it": "^19.2.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
   },
   "dependencies": {
-    "@babel/parser": "^7.23.3",
-    "camelcase": "^8.0.0",
-    "cddl": "^0.8.5",
-    "recast": "^0.23.4",
-    "yargs": "^17.7.2"
+    "@babel/parser": "^7.29.0",
+    "camelcase": "^9.0.0",
+    "cddl": "^0.13.0",
+    "recast": "^0.23.11",
+    "yargs": "^18.0.0"
   }
 }