cddl2ts 0.4.4 → 0.5.0

package/README.md

@@ -58,4 +58,3 @@ console.log(ts)
 ---
 
 If you are interested in this project, please feel free to contribute ideas or code patches. Have a look at our [contributing guidelines](https://github.com/webdriverio/cddl/blob/master/CONTRIBUTING.md) to get started.
-

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import type { Assignment } from 'cddl';
+import { type Assignment } from 'cddl';
 export interface TransformOptions {
     useUnknown?: boolean;
 }

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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAWH,KAAK,UAAU,EAMlB,MAAM,MAAM,CAAA;AAuBb,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,7 +1,7 @@
 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 { isCDDLArray, isGroup, isNamedGroupReference, isLiteralWithValue, isNativeTypeWithOperator, isUnNamedProperty, isPropertyReference, isRange, isVariable, pascalCase } from 'cddl';
 import { pkg } from './constants.js';
 const b = types.builders;
 const NATIVE_TYPES = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl2ts",
-  "version": "0.4.4",
+  "version": "0.5.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",
@@ -32,7 +32,7 @@
     "camelcase": "^9.0.0",
     "recast": "^0.23.11",
     "yargs": "^18.0.0",
-    "cddl": "0.14.9"
+    "cddl": "0.15.0"
   },
   "scripts": {
     "release": "release-it --config .release-it.ts --VV",

package/src/index.ts

@@ -2,8 +2,6 @@ import camelcase from 'camelcase'
 import { parse, print, types } from 'recast'
 import typescriptParser from 'recast/parsers/typescript.js'
 
-import type { Assignment, PropertyType, PropertyReference, Property, Array, Operator } from 'cddl'
-
 import {
     isCDDLArray,
     isGroup,
@@ -14,8 +12,14 @@ import {
     isPropertyReference,
     isRange,
     isVariable,
-    pascalCase
-} from './utils.js'
+    pascalCase,
+    type Assignment,
+    type PropertyType,
+    type PropertyReference,
+    type Property,
+    type Array,
+    type Operator
+} from 'cddl'
 
 import { pkg } from './constants.js'
 

package/tests/transform_edge_cases.test.ts

@@ -0,0 +1,272 @@
+import { describe, expect, it } from 'vitest'
+
+import type {
+    Array as CDDLArray,
+    Comment,
+    Group,
+    Operator,
+    Property,
+    PropertyReference,
+    Variable
+} from 'cddl'
+
+import { transform } from '../src/index.js'
+
+const COMMENTS: Comment[] = []
+
+function comment (content: string): Comment {
+    return {
+        Type: 'comment',
+        Content: content,
+        Leading: false
+    }
+}
+
+function groupRef (value: string, operator?: Operator): PropertyReference {
+    return {
+        Type: 'group',
+        Value: value,
+        Unwrapped: false,
+        Operator: operator
+    }
+}
+
+function literal (value: unknown): PropertyReference {
+    return {
+        Type: 'literal',
+        Value: value as any,
+        Unwrapped: false
+    } as PropertyReference
+}
+
+function rangeRef (): PropertyReference {
+    return {
+        Type: 'range',
+        Value: {
+            Min: 0,
+            Max: 10,
+            Inclusive: true
+        },
+        Unwrapped: false
+    }
+}
+
+function property (
+    name: string,
+    type: Property['Type'],
+    overrides: Partial<Property> = {}
+): Property {
+    return {
+        HasCut: false,
+        Occurrence: { n: 1, m: 1 },
+        Name: name,
+        Type: type,
+        Comments: COMMENTS,
+        ...overrides
+    }
+}
+
+function unnamedProperty (
+    type: Property['Type'],
+    overrides: Partial<Property> = {}
+): Property {
+    return property('', type, overrides)
+}
+
+function group (
+    name: string,
+    properties: Group['Properties'],
+    comments: Comment[] = COMMENTS
+): Group {
+    return {
+        Type: 'group',
+        Name: name,
+        IsChoiceAddition: false,
+        Properties: properties,
+        Comments: comments
+    }
+}
+
+function array (
+    name: string,
+    values: CDDLArray['Values'],
+    comments: Comment[] = COMMENTS
+): CDDLArray {
+    return {
+        Type: 'array',
+        Name: name,
+        Values: values,
+        Comments: comments
+    }
+}
+
+function variable (
+    name: string,
+    propertyType: Variable['PropertyType'],
+    comments: Comment[] = COMMENTS
+): Variable {
+    return {
+        Type: 'variable',
+        Name: name,
+        PropertyType: propertyType,
+        IsChoiceAddition: false,
+        Comments: comments
+    }
+}
+
+describe('transform edge cases', () => {
+    it('should map any to unknown when configured', () => {
+        const output = transform([
+            variable('maybe-value', 'any')
+        ], { useUnknown: true })
+
+        expect(output).toContain('export type MaybeValue = unknown;')
+    })
+
+    it('should generate intersections for choices with static props and mixins', () => {
+        const output = transform([
+            group('combined', [
+                [
+                    unnamedProperty(groupRef('option-a')),
+                    unnamedProperty(groupRef('option-b'))
+                ],
+                property('enabled', 'bool'),
+                unnamedProperty([groupRef('mixin-a'), groupRef('mixin-b')])
+            ])
+        ])
+
+        expect(output).toContain('export type Combined =')
+        expect(output).toContain('enabled: boolean')
+        expect(output).toContain('OptionA | OptionB')
+        expect(output).toContain('MixinA | MixinB')
+    })
+
+    it('should resolve deeply wrapped group mixins into intersections', () => {
+        const output = transform([
+            group('wrapped-mixins', [
+                unnamedProperty(group('', [
+                    [
+                        unnamedProperty(groupRef('choice-a')),
+                        unnamedProperty(groupRef('choice-b'))
+                    ],
+                    unnamedProperty([
+                        unnamedProperty(groupRef('wrapped-a')) as any,
+                        unnamedProperty(groupRef('wrapped-b')) as any
+                    ] as any),
+                    unnamedProperty([
+                        [
+                            unnamedProperty(groupRef('nested-a')) as any,
+                            unnamedProperty(groupRef('nested-b')) as any
+                        ]
+                    ] as any),
+                    unnamedProperty([unnamedProperty(groupRef('scalar-ref')) as any] as any),
+                    unnamedProperty(group('', [
+                        property('flag', 'bool')
+                    ]))
+                ])),
+                property('name', 'tstr')
+            ])
+        ])
+
+        expect(output).toContain('export type WrappedMixins =')
+        expect(output).toContain('ChoiceA | ChoiceB')
+        expect(output).toContain('WrappedA | WrappedB')
+        expect(output).toContain('NestedA | NestedB')
+        expect(output).toContain('ScalarRef')
+        expect(output).toContain('flag: boolean')
+        expect(output).toContain('name: string')
+    })
+
+    it('should resolve tuples, records, arrays, literals and special references', () => {
+        const output = transform([
+            variable('tuple-type', group('', [
+                unnamedProperty('int'),
+                unnamedProperty('tstr')
+            ]) as any),
+            variable('choice-type', group('', [
+                [unnamedProperty('int'), unnamedProperty('tstr')],
+                property('flag', 'bool')
+            ]) as any),
+            variable('record-type', group('', [
+                property('text', ['tstr'])
+            ]) as any),
+            variable('array-type', array('', [
+                unnamedProperty(['int', groupRef('custom-value')])
+            ]) as any),
+            variable('null-type', { Type: 'group', Value: 'null', Unwrapped: false }),
+            variable('range-type', rangeRef()),
+            variable('pointer-type', {
+                Type: groupRef('pointer-value'),
+                Operator: { Type: 'default', Value: literal('mouse') }
+            }),
+            variable('bool-literal', literal(true)),
+            variable('null-literal', literal(null))
+        ])
+
+        expect(output).toContain('export type TupleType = [number, string];')
+        expect(output).toContain('export type ChoiceType = [number, string] | {')
+        expect(output).toContain('export type RecordType = Record<string, string>;')
+        expect(output).toContain('export type ArrayType = (number | CustomValue)[];')
+        expect(output).toContain('export type NullType = null;')
+        expect(output).toContain('export type RangeType = number;')
+        expect(output).toContain('export type PointerType = PointerValue;')
+        expect(output).toContain('export type BoolLiteral = true;')
+        expect(output).toContain('export type NullLiteral = null;')
+    })
+
+    it('should include optional properties and default tags in object docs', () => {
+        const output = transform([
+            group('defaults', [
+                property('count', 'int', {
+                    Operator: { Type: 'default', Value: literal(7) },
+                    Comments: [comment('count docs')]
+                }),
+                property('status', groupRef('status-value', {
+                    Type: 'default',
+                    Value: literal('ready')
+                }), {
+                    Comments: [comment('status docs')]
+                }),
+                property('enabled', 'bool', {
+                    Occurrence: { n: 0, m: 1 }
+                })
+            ])
+        ])
+
+        expect(output).toContain('* count docs')
+        expect(output).toContain(`* @default 7`)
+        expect(output).toContain('* status docs')
+        expect(output).toContain(`* @default 'ready'`)
+        expect(output).toContain('enabled?: boolean')
+    })
+
+    it('should throw clear errors for unsupported inputs', () => {
+        expect(() => transform([
+            variable('unknown-native', 'nope')
+        ])).toThrow('Unknown native type: "nope')
+
+        expect(() => transform([
+            variable('bad-literal', literal({ nope: true }))
+        ])).toThrow('Unsupported literal type')
+
+        expect(() => transform([
+            variable('bad-group', { Type: 'group', Value: false, Unwrapped: false } as any)
+        ])).toThrow('Unknown group type')
+
+        expect(() => transform([
+            variable('bad-union', { Type: 'mystery', Value: 'x', Unwrapped: false } as any)
+        ])).toThrow('Unknown union type')
+
+        expect(() => transform([
+            group('bad-default', [
+                property('foo', 'int', {
+                    Operator: { Type: 'default', Value: groupRef('no-literal') }
+                })
+            ])
+        ])).toThrow(`Can't parse operator default value`)
+
+        expect(() => transform([
+            { Type: 'mystery' } as any
+        ])).toThrow('Unknown assignment type')
+    })
+})

package/build/utils.d.ts

@@ -1,23 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,37 +0,0 @@
-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/src/utils.ts

@@ -1,61 +0,0 @@
-import {
-    Assignment,
-    PropertyReference,
-    Property,
-    Array,
-    NativeTypeWithOperator,
-    Group,
-    Variable
-} from 'cddl'
-import camelcase from 'camelcase'
-
-export function pascalCase(name: string) {
-    return camelcase(name, { pascalCase: true })
-}
-
-export function isVariable(assignment: Assignment): assignment is Variable {
-    return assignment.Type === 'variable'
-}
-
-export function isGroup(t: any): t is Group {
-    return t && t.Type === 'group'
-}
-
-export function isCDDLArray(t: any): t is Array {
-    return t && t.Type === 'array'
-}
-
-export function isProperty(t: any): t is Property {
-    return t && typeof t.Name === 'string' && typeof t.HasCut === 'boolean'
-}
-
-export function isUnNamedProperty(t: any): t is Property & { Name: '' } {
-    return isProperty(t) && t.Name === ''
-}
-
-export function isNamedGroupReference(t: any): t is PropertyReference & { Value: string } {
-    return isGroup(t) && isPropertyReference(t) && typeof t.Value === 'string'
-}
-
-export function isPropertyReference(t: any): t is PropertyReference {
-    return t && 'Value' in t
-}
-
-export function isNativeTypeWithOperator(t: any): t is NativeTypeWithOperator {
-    return t && typeof t.Type === 'object' && 'Operator' in t
-}
-
-export function isRange(t: any): boolean {
-    return t && typeof t.Type === 'object' && (t.Type as any).Type === 'range'
-}
-
-export function isLiteralWithValue(t: any): t is {
-    Type: 'literal'
-    Value: unknown
-} {
-    return t && t.Type === 'literal' && 'Value' in t
-}
-
-export function hasTypeProperty(t: any): t is { Type: string } {
-    return t && typeof t.Type === 'string'
-}