cddl2py 0.2.1 → 0.3.0

package/build/index.js

@@ -416,30 +416,6 @@ function getExtraItemsType(props, ctx) {
     ctx.typingImports.add('Union');
     return `Union[${uniqueTypes.join(', ')}]`;
 }
-function stringifyPythonLiteral(value) {
-    return JSON.stringify(value);
-}
-function getTemplateAnnotatedPattern(regexpPattern) {
-    const wildcard = '.+';
-    if (!regexpPattern.includes(wildcard) || /[\\()[\]{}|?*^$]/.test(regexpPattern.replaceAll(wildcard, ''))) {
-        return;
-    }
-    const segments = regexpPattern.split(wildcard);
-    const parts = [];
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        if (segment.length > 0) {
-            parts.push(stringifyPythonLiteral(segment));
-        }
-        if (i < segments.length - 1) {
-            parts.push('str');
-        }
-    }
-    if (parts.length === 0 || !parts.includes('str')) {
-        return;
-    }
-    return `Annotated[str, ${parts.join(' + ')}]`;
-}
 function resolveNativeTypeWithOperator(t, ctx) {
     if (typeof t.Type !== 'string') {
         return;
@@ -455,19 +431,12 @@ function resolveNativeTypeWithOperator(t, ctx) {
         }
         return mapped;
     }
-    const templateAnnotatedPattern = getTemplateAnnotatedPattern(regexpPattern);
-    if (!templateAnnotatedPattern) {
-        if (mapped === 'Any') {
-            ctx.typingImports.add('Any');
-        }
-        return mapped;
-    }
     ctx.typingImports.add('Annotated');
     if (ctx.pydantic) {
         ctx.pydanticImports.add('StringConstraints');
         return `Annotated[${mapped}, StringConstraints(pattern=${JSON.stringify(regexpPattern)})]`;
     }
-    return templateAnnotatedPattern;
+    return `Annotated[${mapped}, ${JSON.stringify(regexpPattern)}]`;
 }
 // ---------------------------------------------------------------------------
 // Type resolution
@@ -504,7 +473,8 @@ function resolveType(t, ctx, options = {}) {
         }
         return mapped;
     }
-    if (isPropertyReference(t) && t.Value === 'null') {
+    if (isPropertyReference(t) && t.Value === 'null' && !isLiteralWithValue(t)) {
+        // a bare `null` reference is the null type; a quoted "null" is a string literal
         return 'None';
     }
     if (isGroup(t)) {
@@ -692,13 +662,47 @@ function orderAssignments(assignments) {
     return ordered;
 }
 function getHardDependencies(assignment, assignmentsByName) {
+    if (isVariable(assignment)) {
+        const propTypes = Array.isArray(assignment.PropertyType)
+            ? assignment.PropertyType
+            : [assignment.PropertyType];
+        const deps = new Set();
+        for (const t of propTypes) {
+            for (const ref of getTypeReferences(t)) {
+                if (assignmentsByName.has(ref)) {
+                    deps.add(ref);
+                }
+            }
+        }
+        return [...deps];
+    }
+    if (isCDDLArray(assignment)) {
+        const arr = assignment;
+        const deps = new Set();
+        for (const val of arr.Values) {
+            const properties = Array.isArray(val) ? val : [val];
+            for (const prop of properties) {
+                const types = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
+                for (const t of types) {
+                    for (const ref of getTypeReferences(t)) {
+                        if (assignmentsByName.has(ref)) {
+                            deps.add(ref);
+                        }
+                    }
+                }
+            }
+        }
+        return [...deps];
+    }
     if (!isGroup(assignment)) {
         return [];
     }
     const deps = new Set();
-    for (const propertyOrChoice of assignment.Properties) {
-        const properties = Array.isArray(propertyOrChoice) ? propertyOrChoice : [propertyOrChoice];
-        for (const property of properties) {
+    const properties = assignment.Properties;
+    const hasChoices = properties.some(p => Array.isArray(p));
+    for (const propertyOrChoice of properties) {
+        const props = Array.isArray(propertyOrChoice) ? propertyOrChoice : [propertyOrChoice];
+        for (const property of props) {
             if (!isUnNamedProperty(property)) {
                 continue;
             }
@@ -707,8 +711,89 @@ function getHardDependencies(assignment, assignmentsByName) {
             }
         }
     }
+    if (!hasChoices) {
+        const props = properties;
+        if (props.length === 1 && Object.keys(NATIVE_TYPE_MAP).includes(props[0].Name)) {
+            const propType = Array.isArray(props[0].Type) ? props[0].Type : [props[0].Type];
+            for (const t of propType) {
+                for (const ref of getTypeReferences(t)) {
+                    if (assignmentsByName.has(ref)) {
+                        deps.add(ref);
+                    }
+                }
+            }
+        }
+        for (const prop of props) {
+            if (isExtensibleRecordProperty(prop)) {
+                const cddlTypes = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
+                for (const t of cddlTypes) {
+                    for (const ref of getTypeReferences(t)) {
+                        if (assignmentsByName.has(ref)) {
+                            deps.add(ref);
+                        }
+                    }
+                }
+            }
+        }
+    }
     return [...deps];
 }
+function getTypeReferences(t) {
+    if (typeof t === 'string') {
+        return [];
+    }
+    if (isNamedGroupReference(t)) {
+        return [pascalCase(t.Value)];
+    }
+    if (isPropertyReference(t)) {
+        const ref = t;
+        if ((ref.Type === 'group' || ref.Type === 'group_array') && typeof ref.Value === 'string') {
+            return [pascalCase(ref.Value)];
+        }
+        if (ref.Type === 'tag') {
+            const tag = ref.Value;
+            if (!NATIVE_TYPE_MAP[tag.TypePart]) {
+                return [pascalCase(tag.TypePart)];
+            }
+        }
+        return [];
+    }
+    if (isNativeTypeWithOperator(t)) {
+        if (isNamedGroupReference(t.Type)) {
+            return [pascalCase(t.Type.Value)];
+        }
+        return [];
+    }
+    if (isGroup(t) && !isNamedGroupReference(t) && t.Properties) {
+        const refs = [];
+        const group = t;
+        for (const prop of group.Properties) {
+            const subProps = Array.isArray(prop) ? prop : [prop];
+            for (const p of subProps) {
+                const types = Array.isArray(p.Type) ? p.Type : [p.Type];
+                for (const subType of types) {
+                    refs.push(...getTypeReferences(subType));
+                }
+            }
+        }
+        return refs;
+    }
+    if (isCDDLArray(t)) {
+        const refs = [];
+        const arr = t;
+        for (const val of arr.Values) {
+            const subProps = Array.isArray(val) ? val : [val];
+            for (const prop of subProps) {
+                const types = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
+                for (const subType of types) {
+                    refs.push(...getTypeReferences(subType));
+                }
+            }
+        }
+        return refs;
+    }
+    return [];
+}
 function getMixinDependencies(type, assignmentsByName) {
     const deps = new Set();
     const values = Array.isArray(type) ? type : [type];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl2py",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A Node.js package that can generate Python type definitions (with optional Pydantic support) based on a CDDL file",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -30,11 +30,11 @@
   },
   "devDependencies": {
     "@types/yargs": "^17.0.35",
-    "@types/node": "^25.5.0"
+    "@types/node": "^26.0.1"
   },
   "dependencies": {
     "yargs": "^18.0.0",
-    "cddl": "0.20.1"
+    "cddl": "0.21.0"
   },
   "scripts": {
     "release": "release-it --config .release-it.ts --VV",