cddl2ts 0.7.0 → 0.7.2

package/build/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAWH,KAAK,UAAU,EAMlB,MAAM,MAAM,CAAA;AAyCb,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

@@ -7,17 +7,35 @@ const b = types.builders;
 const NATIVE_TYPES = {
     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'
+]);
 export function transform(assignments, options) {
     if (options?.useUnknown) {
         NATIVE_TYPES.any = b.tsUnknownKeyword();
@@ -39,6 +57,21 @@ export function transform(assignments, options) {
     }
     return print(ast).code;
 }
+function getAssignmentComments(assignment) {
+    return assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
+}
+function exportWithComments(declaration) {
+    const expr = b.exportDeclaration(false, declaration);
+    expr.comments = declaration.comments;
+    declaration.comments = [];
+    return expr;
+}
+function isExtensibleRecordProperty(prop) {
+    return !isUnNamedProperty(prop) &&
+        prop.Occurrence.m === Infinity &&
+        !prop.HasCut &&
+        RECORD_KEY_TYPES.has(prop.Name);
+}
 function parseAssignment(assignment) {
     if (isVariable(assignment)) {
         const propType = Array.isArray(assignment.PropertyType)
@@ -54,8 +87,8 @@ function parseAssignment(assignment) {
             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);
+        expr.comments = getAssignmentComments(assignment);
+        return exportWithComments(expr);
     }
     if (isGroup(assignment)) {
         const id = b.identifier(pascalCase(assignment.Name));
@@ -136,8 +169,8 @@ function parseAssignment(assignment) {
                 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);
+            expr.comments = getAssignmentComments(assignment);
+            return exportWithComments(expr);
         }
         const props = properties;
         /**
@@ -146,11 +179,11 @@ function parseAssignment(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));
-                return b.exportDeclaration(false, expr);
+                expr.comments = getAssignmentComments(assignment);
+                return exportWithComments(expr);
             }
         }
         // Check if extended interfaces are likely unions or conflicting types
@@ -367,14 +400,14 @@ function parseAssignment(assignment) {
                 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);
+            expr.comments = getAssignmentComments(assignment);
+            return exportWithComments(expr);
         }
         // Fallback to interface if no mixins (pure object)
         const objectType = parseObjectType(props);
         const expr = b.tsInterfaceDeclaration(id, b.tsInterfaceBody(objectType));
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-        return b.exportDeclaration(false, expr);
+        expr.comments = getAssignmentComments(assignment);
+        return exportWithComments(expr);
     }
     if (isCDDLArray(assignment)) {
         const id = b.identifier(pascalCase(assignment.Name));
@@ -390,8 +423,8 @@ function parseAssignment(assignment) {
             });
             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);
+            expr.comments = getAssignmentComments(assignment);
+            return exportWithComments(expr);
         }
         // Standard array
         const firstType = assignmentValues.Type;
@@ -404,8 +437,8 @@ function parseAssignment(assignment) {
             ? 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);
+        expr.comments = getAssignmentComments(assignment);
+        return exportWithComments(expr);
     }
     throw new Error(`Unknown assignment type "${assignment.Type}"`);
 }
@@ -426,9 +459,22 @@ function parseObjectType(props) {
         if (isUnNamedProperty(prop)) {
             continue;
         }
-        const id = b.identifier(camelcase(prop.Name));
         const cddlType = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
         const comments = prop.Comments.map((c) => ` ${c.Content}`);
+        if (isExtensibleRecordProperty(prop)) {
+            const keyIdentifier = b.identifier('key');
+            keyIdentifier.typeAnnotation = b.tsTypeAnnotation(NATIVE_TYPES[prop.Name]);
+            const indexSignature = b.tsIndexSignature([keyIdentifier], b.tsTypeAnnotation(b.tsUnionType([
+                ...cddlType.map((t) => parseUnionType(t)),
+                b.tsUndefinedKeyword()
+            ])));
+            indexSignature.comments = comments.length
+                ? [b.commentBlock(`*\n *${comments.join('\n *')}\n `)]
+                : [];
+            propItems.push(indexSignature);
+            continue;
+        }
+        const id = b.identifier(camelcase(prop.Name));
         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
@@ -511,7 +557,7 @@ function parseUnionType(t) {
             /**
              * {*text => text} which will be transformed to `Record<string, string>`
              */
-            if (prop.length === 1 && Object.keys(NATIVE_TYPES).includes(prop[0].Name)) {
+            if (prop.length === 1 && RECORD_KEY_TYPES.has(prop[0].Name)) {
                 return b.tsTypeReference(b.identifier('Record'), b.tsTypeParameterInstantiation([
                     NATIVE_TYPES[prop[0].Name],
                     parseUnionType(prop[0].Type[0])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl2ts",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "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.19.0"
+    "cddl": "0.19.2"
   },
   "scripts": {
     "release": "release-it --config .release-it.ts --VV",

package/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']
@@ -72,6 +90,27 @@ export function transform (assignments: Assignment[], options?: TransformOptions
     return print(ast).code
 }
 
+function getAssignmentComments (assignment: Assignment) {
+    return assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
+}
+
+function exportWithComments (
+    declaration: types.namedTypes.TSTypeAliasDeclaration
+        | types.namedTypes.TSInterfaceDeclaration
+) {
+    const expr = b.exportDeclaration(false, declaration)
+    expr.comments = declaration.comments
+    declaration.comments = []
+    return expr
+}
+
+function isExtensibleRecordProperty (prop: Property) {
+    return !isUnNamedProperty(prop) &&
+        prop.Occurrence.m === Infinity &&
+        !prop.HasCut &&
+        RECORD_KEY_TYPES.has(prop.Name)
+}
+
 function parseAssignment (assignment: Assignment) {
     if (isVariable(assignment)) {
         const propType = Array.isArray(assignment.PropertyType)
@@ -89,8 +128,8 @@ function parseAssignment (assignment: Assignment) {
         }
 
         const expr = b.tsTypeAliasDeclaration(id, typeParameters)
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-        return b.exportDeclaration(false, expr)
+        expr.comments = getAssignmentComments(assignment)
+        return exportWithComments(expr)
     }
 
     if (isGroup(assignment)) {
@@ -183,8 +222,8 @@ function parseAssignment (assignment: Assignment) {
             }
 
             const expr = b.tsTypeAliasDeclaration(id, value)
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-            return b.exportDeclaration(false, expr)
+            expr.comments = getAssignmentComments(assignment)
+            return exportWithComments(expr)
         }
 
         const props = properties as Property[]
@@ -195,11 +234,11 @@ 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))
-                return b.exportDeclaration(false, expr)
+                expr.comments = getAssignmentComments(assignment)
+                return exportWithComments(expr)
             }
         }
 
@@ -413,16 +452,16 @@ function parseAssignment (assignment: Assignment) {
             }
 
             const expr = b.tsTypeAliasDeclaration(id, value)
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-            return b.exportDeclaration(false, expr)
+            expr.comments = getAssignmentComments(assignment)
+            return exportWithComments(expr)
         }
 
         // Fallback to interface if no mixins (pure object)
         const objectType = parseObjectType(props)
 
         const expr = b.tsInterfaceDeclaration(id, b.tsInterfaceBody(objectType))
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-        return b.exportDeclaration(false, expr)
+        expr.comments = getAssignmentComments(assignment)
+        return exportWithComments(expr)
     }
 
     if (isCDDLArray(assignment)) {
@@ -441,8 +480,8 @@ function parseAssignment (assignment: Assignment) {
             })
             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)
+            expr.comments = getAssignmentComments(assignment)
+            return exportWithComments(expr)
         }
 
         // Standard array
@@ -459,8 +498,8 @@ function parseAssignment (assignment: Assignment) {
                 : 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)
+        expr.comments = getAssignmentComments(assignment)
+        return exportWithComments(expr)
     }
 
     throw new Error(`Unknown assignment type "${(assignment as any).Type}"`)
@@ -484,10 +523,31 @@ function parseObjectType (props: Property[]): ObjectBody {
             continue
         }
 
-        const id = b.identifier(camelcase(prop.Name))
         const cddlType: PropertyType[] = Array.isArray(prop.Type) ? prop.Type : [prop.Type]
         const comments: string[] = prop.Comments.map((c) => ` ${c.Content}`)
 
+        if (isExtensibleRecordProperty(prop)) {
+            const keyIdentifier = b.identifier('key')
+            keyIdentifier.typeAnnotation = b.tsTypeAnnotation(NATIVE_TYPES[prop.Name])
+
+            const indexSignature = b.tsIndexSignature(
+                [keyIdentifier],
+                b.tsTypeAnnotation(
+                    b.tsUnionType([
+                        ...cddlType.map((t) => parseUnionType(t)),
+                        b.tsUndefinedKeyword()
+                    ])
+                )
+            )
+            indexSignature.comments = comments.length
+                ? [b.commentBlock(`*\n *${comments.join('\n *')}\n `)]
+                : []
+            propItems.push(indexSignature)
+            continue
+        }
+
+        const id = b.identifier(camelcase(prop.Name))
+
         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
@@ -578,7 +638,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([

package/tests/__snapshots__/extensible_metadata.test.ts.snap

@@ -0,0 +1,16 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`extensible metadata > should render extensible metadata as an interface with an index signature 1`] = `
+"export type MetadataScalar = null | boolean | number | number | string;
+
+export interface MessageMetadata {
+  provider?: string;
+  model?: string;
+  modelType?: string;
+  runId?: string;
+  threadId?: string;
+  systemFingerprint?: string;
+  serviceTier?: string;
+  [key: string]: MetadataScalar | undefined;
+}"
+`;

package/tests/__snapshots__/group_choice.test.ts.snap

@@ -12,52 +12,52 @@ export type DirectProxyConfiguration = Extensible & {
   proxyType: "direct";
 };
 
-export // 1. Simple Group Choice
-type ManualProxyConfiguration = Extensible & {
+// 1. Simple Group Choice
+export type ManualProxyConfiguration = Extensible & {
   proxyType: "manual";
 };
 
-export // 2. Nested Group Choice
-type SimpleGroupChoice = Int | string;
+// 2. Nested Group Choice
+export type SimpleGroupChoice = Int | string;
 
-export // 3. Group Choice with Multiple Items (Sequence) - interpreted as tuple
-type NestedGroupChoice = (Int | Tstr);
+// 3. Group Choice with Multiple Items (Sequence) - interpreted as tuple
+export type NestedGroupChoice = (Int | Tstr);
 
-export // 4. Map Group Choice - interpreted as map (interface) union
-type SequenceGroupChoice = [number, string] | number;
+// 4. Map Group Choice - interpreted as map (interface) union
+export type SequenceGroupChoice = [number, string] | number;
 
-export // 5. Type Choice inside Group - should be value union
-type MapGroupChoice = {
+// 5. Type Choice inside Group - should be value union
+export type MapGroupChoice = {
   a: 1;
 } | {
   b: 2;
 };
 
-export // 6. Array with Group Choice - should be array of union?
-type TypeChoiceInsideGroup = number | string;
+// 6. Array with Group Choice - should be array of union?
+export type TypeChoiceInsideGroup = number | string;
 
-export // 7. Map with nested group (bare and parens) - should be object like
-type ArrayGroupChoice = Int | string[];
+// 7. Map with nested group (bare and parens) - should be object like
+export type ArrayGroupChoice = Int | string[];
 
 export type MapWithBareGroup = number;
 
-export // 8. Group wrapped in map with multiple properties
-type MapWithParensGroup = number;
+// 8. Group wrapped in map with multiple properties
+export type MapWithParensGroup = number;
 
-export // 9. Property type choice without operators
-type MapGroupWrap = ;
+// 9. Property type choice without operators
+export type MapGroupWrap = ;
 
-export // 10. Nested choice with group reference
-interface PropChoiceNoOp {
+// 10. Nested choice with group reference
+export interface PropChoiceNoOp {
   a: number | number;
   b: string;
 }
 
-export // 11. Complex type (group) followed by property without comma
-type NestedChoiceRef = number | string;
+// 11. Complex type (group) followed by property without comma
+export type NestedChoiceRef = number | string;
 
-export // 12. Multi-item group choice (verifies isChoice persistence)
-interface MapNoComma {
+// 12. Multi-item group choice (verifies isChoice persistence)
+export interface MapNoComma {
   a: number;
   b: string;
 }

package/tests/__snapshots__/mod.test.ts.snap

@@ -95,8 +95,8 @@ export interface SomeGroup {
 export type ScriptListLocalValue = ScriptLocalValue[];
 export type ScriptMappingLocalValue = (ScriptLocalValue | ScriptLocalValue)[];
 
-export // some comments here
-type Extensible = Record<string, any>;",
+// some comments here
+export type Extensible = Record<string, any>;",
   ],
 ]
 `;

package/tests/__snapshots__/webdriver_remote.test.ts.snap

@@ -388,9 +388,9 @@ export interface BrowsingContextPrintParameters {
   shrinkToFit?: boolean;
 }
 
-export // Minimum size is 1pt x 1pt. Conversion follows from
+// Minimum size is 1pt x 1pt. Conversion follows from
 // https://www.w3.org/TR/css3-values/#absolute-lengths
-interface BrowsingContextPrintMarginParameters {
+export interface BrowsingContextPrintMarginParameters {
   /**
    * @default 1
    */

package/tests/extensible_metadata.test.ts

@@ -0,0 +1,49 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const cddlFile = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'extensible_metadata.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('extensible metadata', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should render extensible metadata as an interface with an index signature', async () => {
+        await cli([cddlFile])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+
+        expect(output).toContain('export interface MessageMetadata {')
+        expect(output).toContain('provider?: string;')
+        expect(output).toContain('modelType?: string;')
+        expect(output).toContain('[key: string]: MetadataScalar | undefined;')
+        expect(output).not.toContain('text?: MetadataScalar;')
+        expect(output).toMatchSnapshot()
+    })
+})

package/tests/named_group_choice.test.ts

@@ -39,8 +39,8 @@ describe('named group choice', () => {
 
         const output = vi.mocked(console.log).mock.calls.flat().join('\n')
 
-        // The export keyword is separated from the type definition by comments
-        expect(output).toMatch(/export\s+(\/\/.*\n)+\s*type Choice = OptionA \| OptionB/)
+        // Leading comments should render before the exported declaration.
+        expect(output).toMatch(/(\/\/.*\n)+export type Choice = OptionA \| OptionB/)
         expect(output).toContain('export interface OptionA {')
         expect(output).toContain('export interface OptionB {')
     })

package/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')
+    })
 })

package/tests/transform_edge_cases.test.ts

@@ -14,11 +14,11 @@ import { transform } from '../src/index.js'
 
 const COMMENTS: Comment[] = []
 
-function comment (content: string): Comment {
+function comment (content: string, leading = false): Comment {
     return {
         Type: 'comment',
         Content: content,
-        Leading: false
+        Leading: leading
     }
 }
 
@@ -240,6 +240,40 @@ describe('transform edge cases', () => {
         expect(output).toContain('enabled?: boolean')
     })
 
+    it('should place leading comments before exported declarations', () => {
+        const output = transform([
+            variable('metadata-scalar', ['null', 'bool', 'int', 'float', 'text'], [
+                comment('Flat scalar value used by concise metadata bags.', true)
+            ])
+        ])
+
+        expect(output).toContain(`// Flat scalar value used by concise metadata bags.\nexport type MetadataScalar = null | boolean | number | number | string;`)
+        expect(output).not.toContain('export // Flat scalar value used by concise metadata bags.')
+    })
+
+    it('should emit extensible object properties as index signatures', () => {
+        const output = transform([
+            variable('metadata-scalar', ['null', 'bool', 'int', 'float', 'text']),
+            group('message-metadata', [
+                property('provider', 'text', {
+                    Occurrence: { n: 0, m: 1 }
+                }),
+                property('model', 'text', {
+                    Occurrence: { n: 0, m: 1 }
+                }),
+                property('text', groupRef('metadata-scalar'), {
+                    Occurrence: { n: 0, m: Infinity }
+                })
+            ])
+        ])
+
+        expect(output).toContain('export interface MessageMetadata {')
+        expect(output).toContain('provider?: string;')
+        expect(output).toContain('model?: string;')
+        expect(output).toContain('[key: string]: MetadataScalar | undefined;')
+        expect(output).not.toContain('text?: MetadataScalar;')
+    })
+
     it('should throw clear errors for unsupported inputs', () => {
         expect(() => transform([
             variable('unknown-native', 'nope')