fix: parse float32 in cddl2ts

Author: christian-bromann

packages/cddl2ts/src/index.ts

@@ -27,17 +27,35 @@ const b = types.builders
 const NATIVE_TYPES: Record<string, any> = {
     any: b.tsAnyKeyword(),
     number: b.tsNumberKeyword(),
+    integer: b.tsNumberKeyword(),
     int: b.tsNumberKeyword(),
-    float: b.tsNumberKeyword(),
     uint: b.tsNumberKeyword(),
+    nint: b.tsNumberKeyword(),
+    unsigned: b.tsNumberKeyword(),
+    float: b.tsNumberKeyword(),
+    float16: b.tsNumberKeyword(),
+    float32: b.tsNumberKeyword(),
+    float64: b.tsNumberKeyword(),
+    'float16-32': b.tsNumberKeyword(),
+    'float32-64': b.tsNumberKeyword(),
     bool: b.tsBooleanKeyword(),
+    false: b.tsBooleanKeyword(),
+    true: b.tsBooleanKeyword(),
+    bstr: b.tsTypeReference(b.identifier('Uint8Array')),
+    bytes: b.tsTypeReference(b.identifier('Uint8Array')),
     str: b.tsStringKeyword(),
     text: b.tsStringKeyword(),
     tstr: b.tsStringKeyword(),
     range: b.tsNumberKeyword(),
+    undefined: b.tsUndefinedKeyword(),
     nil: b.tsNullKeyword(),
     null: b.tsNullKeyword()
 }
+const RECORD_KEY_TYPES = new Set([
+    'int', 'uint', 'nint', 'integer', 'unsigned', 'number',
+    'float', 'float16', 'float32', 'float64', 'float16-32', 'float32-64',
+    'str', 'text', 'tstr'
+])
 type ObjectEntry = types.namedTypes.TSCallSignatureDeclaration | types.namedTypes.TSConstructSignatureDeclaration | types.namedTypes.TSIndexSignature | types.namedTypes.TSMethodSignature | types.namedTypes.TSPropertySignature
 type ObjectBody = ObjectEntry[]
 type TSTypeKind = types.namedTypes.TSAsExpression['typeAnnotation']
@@ -195,7 +213,7 @@ function parseAssignment (assignment: 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)) {
+            if (propType.length === 1 && RECORD_KEY_TYPES.has(prop.Name)) {
                 const value = parseUnionType(assignment)
                 const expr = b.tsTypeAliasDeclaration(id, value)
                 expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
@@ -578,7 +596,7 @@ function parseUnionType (t: PropertyType | Assignment): TSTypeKind {
             /**
              * {*text => text} which will be transformed to `Record<string, string>`
              */
-            if (prop.length === 1 && Object.keys(NATIVE_TYPES).includes((prop[0] as Property).Name)) {
+            if (prop.length === 1 && RECORD_KEY_TYPES.has((prop[0] as Property).Name)) {
                 return b.tsTypeReference(
                     b.identifier('Record'),
                     b.tsTypeParameterInstantiation([

packages/cddl2ts/tests/transform.test.ts

@@ -1,21 +1,84 @@
 import { describe, it, expect } from 'vitest'
 import { transform } from '../src/index.js'
-import type { Variable } from 'cddl'
+import type { Group, Property, Variable } from 'cddl'
+
+function variable(name: string, propertyType: Variable['PropertyType']): Variable {
+    return {
+        Type: 'variable',
+        Name: name,
+        PropertyType: propertyType,
+        Comments: [],
+        IsChoiceAddition: false
+    }
+}
+
+function property(name: string, type: Property['Type']): Property {
+    return {
+        HasCut: false,
+        Occurrence: { n: 1, m: 1 },
+        Name: name,
+        Type: type,
+        Comments: []
+    }
+}
+
+function group(name: string, properties: Group['Properties']): Group {
+    return {
+        Type: 'group',
+        Name: name,
+        IsChoiceAddition: false,
+        Properties: properties,
+        Comments: []
+    }
+}
 
 describe('literal transformation direct', () => {
     it('should transform bigint literals correctly', () => {
-        const assignment: Variable = {
-            Type: 'variable',
-            Name: 'MyBigInt',
-            PropertyType: {
-                Type: 'literal',
-                Value: 9007199254740995n
-            } as any,
-            Comments: [],
-            IsChoiceAddition: false
-        }
+        const assignment = variable('MyBigInt', {
+            Type: 'literal',
+            Value: 9007199254740995n
+        } as any)
 
         const output = transform([assignment])
         expect(output).toContain('export type MyBigInt = 9007199254740995n;')
     })
+
+    it('should transform float32 aliases correctly', () => {
+        const assignment = variable('score', 'float32')
+
+        const output = transform([assignment])
+        expect(output).toContain('export type Score = number;')
+    })
+
+    it.each([
+        ['integer-value', 'integer', 'number'],
+        ['negative-value', 'nint', 'number'],
+        ['unsigned-value', 'unsigned', 'number'],
+        ['half-float', 'float16', 'number'],
+        ['double-float', 'float64', 'number'],
+        ['float-window', 'float16-32', 'number'],
+        ['float-range', 'float32-64', 'number'],
+        ['binary-payload', 'bytes', 'Uint8Array'],
+        ['binary-blob', 'bstr', 'Uint8Array'],
+        ['missing-value', 'undefined', 'undefined']
+    ] as const)('should map %s (%s) to %s', (name, propertyType, expectedType) => {
+        const output = transform([variable(name, propertyType)])
+        expect(output).toContain(`export type ${name.split('-').map((part) => `${part[0]!.toUpperCase()}${part.slice(1)}`).join('')} = ${expectedType};`)
+    })
+
+    it('should keep bytes fields as object properties instead of record aliases', () => {
+        const output = transform([
+            group('network-get-data-result', [
+                property('bytes', {
+                    Type: 'group',
+                    Value: 'network.BytesValue',
+                    Unwrapped: false
+                } as any)
+            ])
+        ])
+
+        expect(output).toContain('export interface NetworkGetDataResult {')
+        expect(output).toContain('bytes: NetworkBytesValue;')
+        expect(output).not.toContain('export type NetworkGetDataResult = Record')
+    })
 })