cddl2py 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WebdriverIO Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,136 @@
+# CDDL to Python
+
+> Generate Python type definitions from CDDL as `TypedDict` classes or Pydantic models.
+
+`cddl2py` converts a parsed CDDL schema into Python source code. By default it emits
+`TypedDict`-based definitions that work well for static typing. With the `--pydantic`
+flag, it emits `BaseModel` classes instead.
+
+## Install
+
+Use the CLI:
+
+```sh
+npm install cddl2py
+```
+
+Use the programmatic API:
+
+```sh
+npm install cddl cddl2py
+```
+
+## What It Generates
+
+`cddl2py` currently maps common CDDL constructs into Python-friendly types, including:
+
+- named CDDL assignments to Python aliases or classes
+- groups to `TypedDict` classes
+- optional group fields to `NotRequired[...]`
+- arrays to `list[...]`
+- unions to `Union[...]`
+- literals to `Literal[...]`
+- an optional Pydantic mode that emits `BaseModel` classes and `Field(default=...)`
+
+It also normalizes names for Python code by turning type names into `PascalCase` and
+field names into `snake_case`.
+
+## CLI
+
+The CLI reads a CDDL file and writes generated Python code to stdout, so the normal
+workflow is to redirect the output into a `.py` file.
+
+Generate `TypedDict` output:
+
+```sh
+npx cddl2py ./path/to/schema.cddl > ./types.py
+```
+
+Generate Pydantic models:
+
+```sh
+npx cddl2py --pydantic ./path/to/schema.cddl > ./models.py
+```
+
+Show help:
+
+```sh
+npx cddl2py --help
+```
+
+## Programmatic API
+
+The package exports a single `transform()` function. It accepts the parsed CDDL AST
+and returns the generated Python source as a string.
+
+```js
+import { parse } from 'cddl'
+import { transform } from 'cddl2py'
+
+const ast = parse('./schema.cddl')
+const python = transform(ast)
+
+console.log(python)
+```
+
+To generate Pydantic models instead:
+
+```js
+import { parse } from 'cddl'
+import { transform } from 'cddl2py'
+
+const ast = parse('./schema.cddl')
+const python = transform(ast, { pydantic: true })
+
+console.log(python)
+```
+
+## Example
+
+Input CDDL:
+
+```cddl
+person = {
+  name: tstr,
+  age: uint,
+  ?nickname: tstr,
+}
+```
+
+Generated Python (`transform(ast)`):
+
+```python
+from __future__ import annotations
+
+from typing_extensions import NotRequired, TypedDict
+
+class Person(TypedDict):
+    name: str
+    age: int
+    nickname: NotRequired[str]
+```
+
+Generated Python (`transform(ast, { pydantic: true })`):
+
+```python
+from __future__ import annotations
+
+from typing import Optional
+from pydantic import BaseModel
+
+class Person(BaseModel):
+    name: str
+    age: int
+    nickname: Optional[str] = None
+```
+
+## Notes
+
+- Generated files include a header comment with the `cddl2py` version used.
+- Pydantic output imports from `pydantic`, so your Python environment should have it installed if you use `--pydantic`.
+- The CLI validates that the input file exists before attempting to parse it.
+
+---
+
+If you want to contribute fixes or improvements, see the repository
+[contributing guide](https://github.com/webdriverio/cddl/blob/main/CONTRIBUTING.md).

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,UAAU,EAGlB,MAAM,MAAM,CAAA;AAKb,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAA;CACrB;AASD,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAkBxF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,UAAU,EAGlB,MAAM,MAAM,CAAA;AAKb,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAA;CACrB;AAgBD,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAuBxF"}

package/build/index.js

@@ -7,13 +7,18 @@ export function transform(assignments, options) {
         typingImports: new Set(),
         typingExtensionsImports: new Set(),
         pydanticImports: new Set(),
+        definedTypeNames: new Set(),
+        assignmentsByName: new Map(assignments.map((assignment) => [pascalCase(assignment.Name), assignment])),
+        aliasUnionTypesByName: new Map(),
     };
     const blocks = [];
-    for (const assignment of assignments) {
+    const orderedAssignments = orderAssignments(assignments);
+    for (const assignment of orderedAssignments) {
         const block = generateAssignment(assignment, ctx);
         if (block) {
             blocks.push(block);
         }
+        ctx.definedTypeNames.add(pascalCase(assignment.Name));
     }
     return renderOutput(ctx, blocks);
 }
@@ -63,11 +68,12 @@ function generateVariable(v, ctx) {
     if (propTypes.length === 1 && isRange(propTypes[0])) {
         return `${comments}${name} = int`;
     }
-    const types = propTypes.map(t => resolveType(t, ctx));
+    const types = propTypes.map(t => resolveType(t, ctx, { quoteForwardReferences: true }));
     if (types.length === 1) {
         return `${comments}${name} = ${types[0]}`;
     }
     ctx.typingImports.add('Union');
+    ctx.aliasUnionTypesByName.set(name, types);
     return `${comments}${name} = Union[${types.join(', ')}]`;
 }
 // ---------------------------------------------------------------------------
@@ -105,8 +111,14 @@ function generateGroup(group, ctx) {
         }
         else {
             const typeVal = Array.isArray(mixin.Type) ? mixin.Type[0] : mixin.Type;
-            if (isNamedGroupReference(typeVal)) {
-                simpleMixinBases.push(pascalCase(typeVal.Value));
+            const mixinTarget = resolveMixinTarget(typeVal, ctx);
+            if (mixinTarget) {
+                if (mixinTarget.kind === 'union') {
+                    unionMixinGroups.push(mixinTarget.types);
+                }
+                else {
+                    simpleMixinBases.push(mixinTarget.type);
+                }
             }
             else if (isGroup(typeVal) && !isNamedGroupReference(typeVal) && typeVal.Properties) {
                 const inlineGroup = typeVal;
@@ -186,6 +198,7 @@ function generateGroupWithChoices(name, properties, ctx) {
     }
     else {
         ctx.typingImports.add('Union');
+        ctx.aliasUnionTypesByName.set(name, unionTypes);
         blocks.push(`${name} = Union[${unionTypes.join(', ')}]`);
     }
     return blocks.join('\n\n');
@@ -229,6 +242,7 @@ function generateGroupWithUnionMixins(name, simpleBases, unionGroups, ownProps,
         return blocks.join('\n\n');
     }
     ctx.typingImports.add('Union');
+    ctx.aliasUnionTypesByName.set(name, variantNames);
     blocks.push(`${name} = Union[${variantNames.join(', ')}]`);
     return blocks.join('\n\n');
 }
@@ -247,7 +261,7 @@ function generateArrayAssignment(arr, ctx) {
     if (Array.isArray(firstVal)) {
         const options = firstVal.map(p => {
             const t = Array.isArray(p.Type) ? p.Type[0] : p.Type;
-            return resolveType(t, ctx);
+            return resolveType(t, ctx, { quoteForwardReferences: true });
         });
         if (options.length === 1) {
             return `${comments}${name} = list[${options[0]}]`;
@@ -261,14 +275,14 @@ function generateArrayAssignment(arr, ctx) {
         const innerArr = types[0];
         const innerVal = innerArr.Values[0];
         const innerTypes = Array.isArray(innerVal.Type) ? innerVal.Type : [innerVal.Type];
-        const typeStrs = innerTypes.map(v => resolveType(v, ctx));
+        const typeStrs = innerTypes.map(v => resolveType(v, ctx, { quoteForwardReferences: true }));
         if (typeStrs.length === 1) {
             return `${comments}${name} = list[${typeStrs[0]}]`;
         }
         ctx.typingImports.add('Union');
         return `${comments}${name} = list[Union[${typeStrs.join(', ')}]]`;
     }
-    const typeStrs = types.map(t => resolveType(t, ctx));
+    const typeStrs = types.map(t => resolveType(t, ctx, { quoteForwardReferences: true }));
     if (typeStrs.length === 1) {
         return `${comments}${name} = list[${typeStrs[0]}]`;
     }
@@ -283,8 +297,9 @@ function generateClass(name, bases, props, ctx) {
     let classDecl;
     if (ctx.pydantic) {
         ctx.pydanticImports.add('BaseModel');
-        if (bases.length > 0) {
-            classDecl = `class ${name}(${bases.join(', ')}):`;
+        const pydanticBases = bases.filter((base) => isModelCompatibleBase(base, ctx));
+        if (pydanticBases.length > 0) {
+            classDecl = `class ${name}(${pydanticBases.join(', ')}):`;
         }
         else {
             classDecl = `class ${name}(BaseModel):`;
@@ -292,8 +307,9 @@ function generateClass(name, bases, props, ctx) {
     }
     else {
         ctx.typingExtensionsImports.add('TypedDict');
-        if (bases.length > 0) {
-            classDecl = `class ${name}(${bases.join(', ')}):`;
+        const typedDictBases = bases.filter((base) => isModelCompatibleBase(base, ctx));
+        if (typedDictBases.length > 0) {
+            classDecl = `class ${name}(${typedDictBases.join(', ')}):`;
         }
         else {
             classDecl = `class ${name}(TypedDict):`;
@@ -332,7 +348,7 @@ function generateField(prop, ctx) {
         typeStr = `Union[${types.join(', ')}]`;
     }
     const inlineComment = prop.Comments
-        .filter(c => !c.Leading)
+        .filter((c) => Boolean(c) && !c.Leading)
         .map(c => c.Content.trim())
         .join('; ');
     const commentSuffix = inlineComment ? `  # ${inlineComment}` : '';
@@ -372,7 +388,7 @@ function generateField(prop, ctx) {
 // ---------------------------------------------------------------------------
 // Type resolution
 // ---------------------------------------------------------------------------
-function resolveType(t, ctx) {
+function resolveType(t, ctx, options = {}) {
     if (typeof t === 'string') {
         const mapped = NATIVE_TYPE_MAP[t];
         if (mapped) {
@@ -402,42 +418,42 @@ function resolveType(t, ctx) {
     }
     if (isGroup(t)) {
         if (isNamedGroupReference(t)) {
-            return pascalCase(t.Value);
+            return formatTypeReference(pascalCase(t.Value), ctx, options);
         }
         const group = t;
         if (group.Properties) {
             const props = group.Properties;
             if (props.some(p => Array.isArray(p))) {
-                const options = [];
+                const choiceTypes = [];
                 for (const choice of props) {
                     const subProps = Array.isArray(choice) ? choice : [choice];
                     if (subProps.length === 1 && isUnNamedProperty(subProps[0])) {
                         const subType = Array.isArray(subProps[0].Type) ? subProps[0].Type[0] : subProps[0].Type;
-                        options.push(resolveType(subType, ctx));
+                        choiceTypes.push(resolveType(subType, ctx, options));
                         continue;
                     }
                     if (subProps.every(isUnNamedProperty)) {
                         const tupleItems = subProps.map(p => {
                             const subType = Array.isArray(p.Type) ? p.Type[0] : p.Type;
-                            return resolveType(subType, ctx);
+                            return resolveType(subType, ctx, options);
                         });
                         ctx.typingImports.add('Tuple');
-                        options.push(`Tuple[${tupleItems.join(', ')}]`);
+                        choiceTypes.push(`Tuple[${tupleItems.join(', ')}]`);
                         continue;
                     }
                 }
-                if (options.length > 1) {
+                if (choiceTypes.length > 1) {
                     ctx.typingImports.add('Union');
-                    return `Union[${options.join(', ')}]`;
+                    return `Union[${choiceTypes.join(', ')}]`;
                 }
-                if (options.length === 1) {
-                    return options[0];
+                if (choiceTypes.length === 1) {
+                    return choiceTypes[0];
                 }
             }
             if (props.every(isUnNamedProperty)) {
                 const items = props.map(p => {
                     const subType = Array.isArray(p.Type) ? p.Type[0] : p.Type;
-                    return resolveType(subType, ctx);
+                    return resolveType(subType, ctx, options);
                 });
                 if (items.length === 1) {
                     return items[0];
@@ -450,7 +466,7 @@ function resolveType(t, ctx) {
                 if (keyType === 'Any') {
                     ctx.typingImports.add('Any');
                 }
-                const valType = resolveType(props[0].Type[0], ctx);
+                const valType = resolveType(props[0].Type[0], ctx, options);
                 return `dict[${keyType}, ${valType}]`;
             }
             ctx.typingImports.add('Any');
@@ -485,7 +501,7 @@ function resolveType(t, ctx) {
         }
         const firstVal = arrValues[0];
         const innerTypes = Array.isArray(firstVal.Type) ? firstVal.Type : [firstVal.Type];
-        const typeStrs = innerTypes.map(v => resolveType(v, ctx));
+        const typeStrs = innerTypes.map(v => resolveType(v, ctx, options));
         if (typeStrs.length === 1) {
             return `list[${typeStrs[0]}]`;
         }
@@ -499,12 +515,12 @@ function resolveType(t, ctx) {
         return 'int';
     }
     if (isNativeTypeWithOperator(t) && isNamedGroupReference(t.Type)) {
-        return pascalCase(t.Type.Value);
+        return formatTypeReference(pascalCase(t.Type.Value), ctx, options);
     }
     if (isPropertyReference(t)) {
         const ref = t;
         if (ref.Type === 'group_array' && typeof ref.Value === 'string') {
-            return `list[${pascalCase(ref.Value)}]`;
+            return `list[${formatTypeReference(pascalCase(ref.Value), ctx, options)}]`;
         }
         if (ref.Type === 'tag') {
             const tag = ref.Value;
@@ -515,7 +531,7 @@ function resolveType(t, ctx) {
                 }
                 return mapped;
             }
-            return pascalCase(tag.TypePart);
+            return formatTypeReference(pascalCase(tag.TypePart), ctx, options);
         }
     }
     throw new Error(`Unknown type: ${JSON.stringify(t)}`);
@@ -523,13 +539,19 @@ function resolveType(t, ctx) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function formatLeadingComments(comments) {
-    const leading = comments.filter(c => c.Leading);
+function formatLeadingComments(comments = []) {
+    const leading = comments.filter((c) => c !== null && c !== undefined && c.Leading);
     if (leading.length === 0) {
         return '';
     }
     return leading.map(c => `# ${c.Content}`).join('\n') + '\n';
 }
+function formatTypeReference(typeName, ctx, options) {
+    if (!options.quoteForwardReferences || ctx.definedTypeNames.has(typeName)) {
+        return typeName;
+    }
+    return `"${typeName}"`;
+}
 function formatDefaultValue(operator) {
     if (operator.Type !== 'default') {
         return '';
@@ -552,3 +574,197 @@ function formatDefaultValue(operator) {
     }
     return '';
 }
+function orderAssignments(assignments) {
+    const assignmentsByName = new Map(assignments.map((assignment) => [pascalCase(assignment.Name), assignment]));
+    const ordered = [];
+    const visited = new Set();
+    const visiting = new Set();
+    function visit(assignment) {
+        const name = pascalCase(assignment.Name);
+        if (visited.has(name) || visiting.has(name)) {
+            return;
+        }
+        visiting.add(name);
+        for (const dependencyName of getHardDependencies(assignment, assignmentsByName)) {
+            const dependency = assignmentsByName.get(dependencyName);
+            if (dependency) {
+                visit(dependency);
+            }
+        }
+        visiting.delete(name);
+        visited.add(name);
+        ordered.push(assignment);
+    }
+    for (const assignment of assignments) {
+        visit(assignment);
+    }
+    return ordered;
+}
+function getHardDependencies(assignment, assignmentsByName) {
+    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) {
+            if (!isUnNamedProperty(property)) {
+                continue;
+            }
+            for (const dependency of getMixinDependencies(property.Type, assignmentsByName)) {
+                deps.add(dependency);
+            }
+        }
+    }
+    return [...deps];
+}
+function getMixinDependencies(type, assignmentsByName) {
+    const deps = new Set();
+    const values = Array.isArray(type) ? type : [type];
+    for (const value of values) {
+        if (isNamedGroupReference(value)) {
+            for (const dependency of getNamedMixinDependencies(pascalCase(value.Value), assignmentsByName)) {
+                deps.add(dependency);
+            }
+            continue;
+        }
+        if (isNativeTypeWithOperator(value) && isNamedGroupReference(value.Type)) {
+            for (const dependency of getNamedMixinDependencies(pascalCase(value.Type.Value), assignmentsByName)) {
+                deps.add(dependency);
+            }
+            continue;
+        }
+        if (isGroup(value) && !isNamedGroupReference(value) && value.Properties) {
+            for (const property of value.Properties) {
+                if (Array.isArray(property)) {
+                    for (const choice of property) {
+                        if (isUnNamedProperty(choice)) {
+                            for (const dependency of getMixinDependencies(choice.Type, assignmentsByName)) {
+                                deps.add(dependency);
+                            }
+                        }
+                    }
+                    continue;
+                }
+                if (!isUnNamedProperty(property)) {
+                    continue;
+                }
+                for (const dependency of getMixinDependencies(property.Type, assignmentsByName)) {
+                    deps.add(dependency);
+                }
+            }
+        }
+    }
+    return [...deps];
+}
+function getNamedMixinDependencies(name, assignmentsByName) {
+    const assignment = assignmentsByName.get(name);
+    if (!assignment || !isVariable(assignment)) {
+        return [name];
+    }
+    const propertyTypes = Array.isArray(assignment.PropertyType) ? assignment.PropertyType : [assignment.PropertyType];
+    const deps = new Set();
+    for (const propertyType of propertyTypes) {
+        const referencedName = getReferencedMixinName(propertyType);
+        if (referencedName) {
+            for (const dependency of getNamedMixinDependencies(referencedName, assignmentsByName)) {
+                deps.add(dependency);
+            }
+            continue;
+        }
+    }
+    return deps.size > 0 ? [...deps] : [name];
+}
+function getReferencedMixinName(propertyType) {
+    if (isNamedGroupReference(propertyType)) {
+        return pascalCase(propertyType.Value);
+    }
+    if (isNativeTypeWithOperator(propertyType) && isNamedGroupReference(propertyType.Type)) {
+        return pascalCase(propertyType.Type.Value);
+    }
+    return undefined;
+}
+function resolveMixinTarget(propertyType, ctx) {
+    const name = getReferencedMixinName(propertyType);
+    if (!name) {
+        return null;
+    }
+    const unionTypes = ctx.aliasUnionTypesByName.get(name);
+    if (unionTypes && unionTypes.length > 1) {
+        return { kind: 'union', types: expandMixinUnionTypes(unionTypes, ctx) };
+    }
+    const assignment = ctx.assignmentsByName.get(name);
+    if (!assignment || !isVariable(assignment)) {
+        return { kind: 'single', type: name };
+    }
+    const propertyTypes = Array.isArray(assignment.PropertyType) ? assignment.PropertyType : [assignment.PropertyType];
+    if (propertyTypes.length > 1) {
+        return { kind: 'union', types: expandMixinUnionTypes(propertyTypes.map((type) => resolveType(type, ctx)), ctx) };
+    }
+    const referencedName = getReferencedMixinName(propertyTypes[0]);
+    if (referencedName) {
+        return { kind: 'single', type: referencedName };
+    }
+    return { kind: 'single', type: name };
+}
+function expandMixinUnionTypes(types, ctx, seen = new Set()) {
+    const expanded = [];
+    for (const type of types) {
+        if (seen.has(type)) {
+            expanded.push(type);
+            continue;
+        }
+        const nested = ctx.aliasUnionTypesByName.get(type);
+        if (nested && nested.length > 1) {
+            seen.add(type);
+            expanded.push(...expandMixinUnionTypes(nested, ctx, seen));
+            seen.delete(type);
+            continue;
+        }
+        expanded.push(type);
+    }
+    return [...new Set(expanded)];
+}
+function isModelCompatibleBase(base, ctx, seen = new Set()) {
+    if (base.startsWith('_')) {
+        return true;
+    }
+    if (seen.has(base)) {
+        return false;
+    }
+    const assignment = ctx.assignmentsByName.get(base);
+    if (!assignment) {
+        return false;
+    }
+    if (isGroup(assignment)) {
+        return isConcreteGroupBase(assignment);
+    }
+    if (isCDDLArray(assignment)) {
+        return false;
+    }
+    if (!isVariable(assignment)) {
+        return false;
+    }
+    const propertyTypes = Array.isArray(assignment.PropertyType) ? assignment.PropertyType : [assignment.PropertyType];
+    if (propertyTypes.length !== 1) {
+        return false;
+    }
+    const referencedName = getReferencedMixinName(propertyTypes[0]);
+    if (!referencedName) {
+        return false;
+    }
+    seen.add(base);
+    const isCompatible = isModelCompatibleBase(referencedName, ctx, seen);
+    seen.delete(base);
+    return isCompatible;
+}
+function isConcreteGroupBase(group) {
+    if (group.Properties.some((property) => Array.isArray(property))) {
+        return false;
+    }
+    const properties = group.Properties;
+    if (properties.length === 1 && Object.keys(NATIVE_TYPE_MAP).includes(properties[0].Name)) {
+        return false;
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl2py",
-  "version": "0.0.0",
+  "version": "0.1.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",
@@ -18,22 +18,26 @@
   "bugs": {
     "url": "https://github.com/webdriverio/cddl/issues"
   },
+  "files": [
+    "build",
+    "bin"
+  ],
   "type": "module",
   "exports": "./build/index.js",
   "types": "./build/index.d.ts",
   "bin": {
     "cddl2py": "./bin/cddl2py.js"
   },
-  "scripts": {
-    "release": "release-it --config .release-it.ts --VV",
-    "release:ci": "pnpm release --ci --npm.skipChecks"
-  },
   "devDependencies": {
     "@types/yargs": "^17.0.35",
     "@types/node": "^25.5.0"
   },
   "dependencies": {
-    "cddl": "workspace:*",
-    "yargs": "^18.0.0"
+    "yargs": "^18.0.0",
+    "cddl": "0.19.0"
+  },
+  "scripts": {
+    "release": "release-it --config .release-it.ts --VV",
+    "release:ci": "pnpm release --ci --npm.skipChecks"
   }
-}
+}

package/.release-it.ts

@@ -1,11 +0,0 @@
-import baseConfig from '../../.release-it.base';
-import type { Config } from 'release-it';
-
-const config: Config = {
-  ...baseConfig('cddl2py'),
-};
-
-console.log("Release-it config for cddl2py loaded", config);
-
-export default config;
-