cddl2ts 0.8.0 → 0.9.1

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;AAwCb,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,CAAA;AAIzC,MAAM,WAAW,gBAAgB;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,CAAA;CACxB;AAED,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,UA8B/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAYH,KAAK,UAAU,EAOlB,MAAM,MAAM,CAAA;AAwCb,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,CAAA;AAIzC,MAAM,WAAW,gBAAgB;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,CAAA;CACxB;AAED,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,UA8B/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 'cddl';
+import { getRegexpPattern, isCDDLArray, isGroup, isNamedGroupReference, isLiteralWithValue, isNativeTypeWithOperator, isUnNamedProperty, isPropertyReference, isRange, isVariable, pascalCase } from 'cddl';
 import { pkg } from './constants.js';
 const b = types.builders;
 const NATIVE_TYPES = {
@@ -524,6 +524,48 @@ function parseObjectType(props, options) {
     }
     return propItems;
 }
+function parseTemplateLiteralType(template) {
+    const ast = parse(`type __CDDLTemplate = ${template};`, {
+        parser: typescriptParser,
+        sourceFileName: 'cddl2Ts.ts',
+        sourceRoot: process.cwd()
+    });
+    return ast.program.body[0].typeAnnotation;
+}
+function escapeTemplateLiteralSegment(segment) {
+    return segment
+        .replace(/\\/g, '\\\\')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${');
+}
+function regexpPatternToTemplateLiteral(pattern) {
+    const normalized = pattern.startsWith('^') && pattern.endsWith('$')
+        ? pattern.slice(1, -1)
+        : pattern;
+    if (!normalized.includes('.+')) {
+        return;
+    }
+    const wildcardOnlyPattern = normalized.replace(/(\.\+)+/g, '');
+    if (wildcardOnlyPattern.includes('(') || wildcardOnlyPattern.includes('[') || wildcardOnlyPattern.includes('\\')) {
+        return;
+    }
+    const segments = normalized.split(/(?:\.\+)+/g);
+    if (segments.length <= 1) {
+        return;
+    }
+    return `\`${segments.map(escapeTemplateLiteralSegment).join('${string}')}\``;
+}
+function parseNativeTypeWithOperator(t) {
+    if (typeof t.Type !== 'string') {
+        return;
+    }
+    const regexpPattern = getRegexpPattern(t);
+    const templateLiteral = regexpPattern && regexpPatternToTemplateLiteral(regexpPattern);
+    if (templateLiteral) {
+        return parseTemplateLiteralType(templateLiteral);
+    }
+    return NATIVE_TYPES[t.Type];
+}
 function parseUnionType(t, options) {
     if (typeof t === 'string') {
         if (!NATIVE_TYPES[t]) {
@@ -531,6 +573,13 @@ function parseUnionType(t, options) {
         }
         return NATIVE_TYPES[t];
     }
+    else if (isNativeTypeWithOperator(t) && typeof t.Type === 'string') {
+        const nativeType = parseNativeTypeWithOperator(t);
+        if (!nativeType) {
+            throw new Error(`Unknown native type with operator: ${JSON.stringify(t)}`);
+        }
+        return nativeType;
+    }
     else if (t.Type && typeof t.Type === 'string' && NATIVE_TYPES[t.Type]) {
         return NATIVE_TYPES[t.Type];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl2ts",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "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.2"
+    "cddl": "0.20.1"
   },
   "scripts": {
     "release": "release-it --config .release-it.ts --VV",

package/src/index.ts

@@ -3,6 +3,7 @@ import { parse, print, types } from 'recast'
 import typescriptParser from 'recast/parsers/typescript.js'
 
 import {
+    getRegexpPattern,
     isCDDLArray,
     isGroup,
     isNamedGroupReference,
@@ -14,6 +15,7 @@ import {
     isVariable,
     pascalCase,
     type Assignment,
+    type NativeTypeWithOperator,
     type PropertyType,
     type PropertyReference,
     type Property,
@@ -610,12 +612,70 @@ function parseObjectType (props: Property[], options: TransformSettings): Object
     return propItems
 }
 
+function parseTemplateLiteralType (template: string): TSTypeKind {
+    const ast = parse(`type __CDDLTemplate = ${template};`, {
+        parser: typescriptParser,
+        sourceFileName: 'cddl2Ts.ts',
+        sourceRoot: process.cwd()
+    }) satisfies types.namedTypes.File
+    return (ast.program.body[0] as types.namedTypes.TSTypeAliasDeclaration).typeAnnotation
+}
+
+function escapeTemplateLiteralSegment (segment: string): string {
+    return segment
+        .replace(/\\/g, '\\\\')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${')
+}
+
+function regexpPatternToTemplateLiteral (pattern: string): string | undefined {
+    const normalized = pattern.startsWith('^') && pattern.endsWith('$')
+        ? pattern.slice(1, -1)
+        : pattern
+
+    if (!normalized.includes('.+')) {
+        return
+    }
+
+    const wildcardOnlyPattern = normalized.replace(/(\.\+)+/g, '')
+    if (wildcardOnlyPattern.includes('(') || wildcardOnlyPattern.includes('[') || wildcardOnlyPattern.includes('\\')) {
+        return
+    }
+
+    const segments = normalized.split(/(?:\.\+)+/g)
+    if (segments.length <= 1) {
+        return
+    }
+
+    return `\`${segments.map(escapeTemplateLiteralSegment).join('${string}')}\``
+}
+
+function parseNativeTypeWithOperator (t: NativeTypeWithOperator): TSTypeKind | undefined {
+    if (typeof t.Type !== 'string') {
+        return
+    }
+
+    const regexpPattern = getRegexpPattern(t)
+    const templateLiteral = regexpPattern && regexpPatternToTemplateLiteral(regexpPattern)
+    if (templateLiteral) {
+        return parseTemplateLiteralType(templateLiteral)
+    }
+
+    return NATIVE_TYPES[t.Type]
+}
+
 function parseUnionType (t: PropertyType | Assignment, options: TransformSettings): TSTypeKind {
     if (typeof t === 'string') {
         if (!NATIVE_TYPES[t]) {
             throw new Error(`Unknown native type: "${t}`)
         }
         return NATIVE_TYPES[t]
+    } else if (isNativeTypeWithOperator(t) && typeof t.Type === 'string') {
+        const nativeType = parseNativeTypeWithOperator(t)
+        if (!nativeType) {
+            throw new Error(`Unknown native type with operator: ${JSON.stringify(t)}`)
+        }
+        return nativeType
     } else if ((t as any).Type && typeof (t as any).Type === 'string' && NATIVE_TYPES[(t as any).Type]) {
         return NATIVE_TYPES[(t as any).Type]
     } else if (isNativeTypeWithOperator(t) && NATIVE_TYPES[(t.Type as any).Type]) {

package/tests/transform_edge_cases.test.ts

@@ -123,6 +123,62 @@ describe('transform edge cases', () => {
         expect(output).toContain('export type MaybeValue = unknown;')
     })
 
+    it('should map simple wildcard regexp strings to template literal types', () => {
+        const output = transform([
+            variable('channel', {
+                Type: 'tstr',
+                Operator: {
+                    Type: 'regexp',
+                    Value: literal('custom:.+')
+                }
+            } as any),
+            group('event-envelope', [
+                property('channel', {
+                    Type: 'tstr',
+                    Operator: {
+                        Type: 'regexp',
+                        Value: literal('custom:.+')
+                    }
+                } as any)
+            ]),
+            variable('email-address', {
+                Type: 'tstr',
+                Operator: {
+                    Type: 'regexp',
+                    Value: literal('[^@]+@[^@]+')
+                }
+            } as any),
+            variable('prefixed-name', {
+                Type: 'tstr',
+                Operator: {
+                    Type: 'regexp',
+                    Value: literal('foo_.+')
+                }
+            } as any),
+            variable('wrapped-name', {
+                Type: 'tstr',
+                Operator: {
+                    Type: 'regexp',
+                    Value: literal('some_.+_name')
+                }
+            } as any),
+            variable('double-wildcard', {
+                Type: 'tstr',
+                Operator: {
+                    Type: 'regexp',
+                    Value: literal('some_.+_middle_.+')
+                }
+            } as any)
+        ])
+
+        expect(output).toContain('export type Channel = `custom:${string}`;')
+        expect(output).toContain('channel: `custom:${string}`;')
+        expect(output).toContain('export type EmailAddress = string;')
+        expect(output).toContain('export type PrefixedName = `foo_${string}`;')
+        expect(output).toContain('export type WrappedName = `some_${string}_name`;')
+        expect(output).toContain('export type DoubleWildcard = `some_${string}_middle_${string}`;')
+    })
+
     it('should keep camelCase fields by default', () => {
         const output = transform([
             group('session-capability-request', [