cddl2py 0.0.0

package/.release-it.ts

@@ -0,0 +1,11 @@
+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;
+

package/bin/cddl2py.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import parse from '../build/cli.js'
+
+parse()

package/build/cli.d.ts

@@ -0,0 +1,2 @@
+export default function cli(argv?: string[]): Promise<undefined>;
+//# sourceMappingURL=cli.d.ts.map

package/build/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AASA,wBAA8B,GAAG,CAAE,IAAI,WAAwB,sBAgC9D"}

package/build/cli.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import yargs from 'yargs';
+import { parse } from 'cddl';
+import { transform } from './index.js';
+import { pkg } from './constants.js';
+export default async function cli(argv = process.argv.slice(2)) {
+    const parser = yargs(argv)
+        .usage(`${pkg.name}\n${pkg.description}\n\nUsage:\ncddl2py ./path/to/spec.cddl > ./path/to/types.py`)
+        .epilog(`v${pkg.version}\nCopyright ${(new Date()).getFullYear()} ${pkg.author}`)
+        .version(pkg.version)
+        .option('p', {
+        alias: 'pydantic',
+        type: 'boolean',
+        description: 'Generate Pydantic BaseModel classes instead of TypedDict',
+        default: false
+    })
+        .help('help')
+        .alias('h', 'help')
+        .alias('v', 'version');
+    const args = await parser.argv;
+    if (args._.length === 0) {
+        parser.showHelp();
+        return process.exit(0);
+    }
+    const absoluteFilePath = path.resolve(process.cwd(), args._[0]);
+    const hasAccess = await fs.access(absoluteFilePath).then(() => true, () => false);
+    if (!hasAccess) {
+        console.error(`Couldn't find or access source CDDL file at "${absoluteFilePath}"`);
+        return process.exit(1);
+    }
+    const ast = parse(absoluteFilePath);
+    console.log(transform(ast, { pydantic: args.p }));
+}

package/build/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const pkg: any;
+export declare const GENERATED_FILE_COMMENT: string;
+export declare const NATIVE_TYPE_MAP: Record<string, string>;
+export declare const PYDANTIC_NATIVE_TYPE_MAP: Record<string, string>;
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,GAAG,KAAqF,CAAA;AAErG,eAAO,MAAM,sBAAsB,QAA2E,CAAA;AAE9G,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkBlD,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAE3D,CAAA"}

package/build/constants.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises';
+import url from 'node:url';
+import path from 'node:path';
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+export const pkg = JSON.parse(await fs.readFile(path.join(__dirname, '..', 'package.json'), 'utf-8'));
+export const GENERATED_FILE_COMMENT = `# Auto-generated by cddl2py v${pkg.version}\n# Do not edit manually.\n`;
+export const NATIVE_TYPE_MAP = {
+    any: 'Any',
+    number: 'Union[int, float]',
+    int: 'int',
+    uint: 'int',
+    nint: 'int',
+    float: 'float',
+    float16: 'float',
+    float32: 'float',
+    float64: 'float',
+    bool: 'bool',
+    bstr: 'bytes',
+    bytes: 'bytes',
+    tstr: 'str',
+    text: 'str',
+    str: 'str',
+    nil: 'None',
+    null: 'None',
+};
+export const PYDANTIC_NATIVE_TYPE_MAP = {
+    ...NATIVE_TYPE_MAP,
+};

package/build/index.d.ts

@@ -0,0 +1,6 @@
+import { type Assignment } from 'cddl';
+export interface TransformOptions {
+    pydantic?: boolean;
+}
+export declare function transform(assignments: Assignment[], options?: TransformOptions): string;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +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"}

package/build/index.js

@@ -0,0 +1,554 @@
+import { isCDDLArray, isGroup, isNamedGroupReference, isLiteralWithValue, isNativeTypeWithOperator, isUnNamedProperty, isPropertyReference, isRange, isVariable, pascalCase } from 'cddl';
+import { snakeCase } from './utils.js';
+import { pkg, NATIVE_TYPE_MAP } from './constants.js';
+export function transform(assignments, options) {
+    const ctx = {
+        pydantic: options?.pydantic ?? false,
+        typingImports: new Set(),
+        typingExtensionsImports: new Set(),
+        pydanticImports: new Set(),
+    };
+    const blocks = [];
+    for (const assignment of assignments) {
+        const block = generateAssignment(assignment, ctx);
+        if (block) {
+            blocks.push(block);
+        }
+    }
+    return renderOutput(ctx, blocks);
+}
+function renderOutput(ctx, blocks) {
+    const lines = [];
+    lines.push(`# compiled with https://www.npmjs.com/package/cddl2py v${pkg.version}`);
+    lines.push('');
+    lines.push('from __future__ import annotations');
+    lines.push('');
+    if (ctx.typingImports.size > 0) {
+        lines.push(`from typing import ${[...ctx.typingImports].sort().join(', ')}`);
+    }
+    if (ctx.pydantic) {
+        if (ctx.pydanticImports.size > 0) {
+            lines.push(`from pydantic import ${[...ctx.pydanticImports].sort().join(', ')}`);
+        }
+    }
+    else if (ctx.typingExtensionsImports.size > 0) {
+        lines.push(`from typing_extensions import ${[...ctx.typingExtensionsImports].sort().join(', ')}`);
+    }
+    if (ctx.typingImports.size > 0 || ctx.pydanticImports.size > 0 || ctx.typingExtensionsImports.size > 0) {
+        lines.push('');
+    }
+    lines.push(blocks.join('\n\n'));
+    lines.push('');
+    return lines.join('\n');
+}
+function generateAssignment(assignment, ctx) {
+    if (isVariable(assignment)) {
+        return generateVariable(assignment, ctx);
+    }
+    if (isGroup(assignment)) {
+        return generateGroup(assignment, ctx);
+    }
+    if (isCDDLArray(assignment)) {
+        return generateArrayAssignment(assignment, ctx);
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Variable
+// ---------------------------------------------------------------------------
+function generateVariable(v, ctx) {
+    const name = pascalCase(v.Name);
+    const propTypes = Array.isArray(v.PropertyType) ? v.PropertyType : [v.PropertyType];
+    const comments = formatLeadingComments(v.Comments);
+    if (propTypes.length === 1 && isRange(propTypes[0])) {
+        return `${comments}${name} = int`;
+    }
+    const types = propTypes.map(t => resolveType(t, ctx));
+    if (types.length === 1) {
+        return `${comments}${name} = ${types[0]}`;
+    }
+    ctx.typingImports.add('Union');
+    return `${comments}${name} = Union[${types.join(', ')}]`;
+}
+// ---------------------------------------------------------------------------
+// Group
+// ---------------------------------------------------------------------------
+function generateGroup(group, ctx) {
+    const name = pascalCase(group.Name);
+    const properties = group.Properties;
+    const hasChoices = properties.some(p => Array.isArray(p));
+    const comments = formatLeadingComments(group.Comments);
+    if (hasChoices) {
+        return comments + generateGroupWithChoices(name, properties, ctx);
+    }
+    const props = properties;
+    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_TYPE_MAP).includes(prop.Name)) {
+            const keyType = NATIVE_TYPE_MAP[prop.Name];
+            if (keyType === 'Any') {
+                ctx.typingImports.add('Any');
+            }
+            const valType = resolveType(propType[0], ctx);
+            return `${comments}${name} = dict[${keyType}, ${valType}]`;
+        }
+    }
+    const mixins = props.filter(isUnNamedProperty);
+    const ownProps = props.filter(p => !isUnNamedProperty(p));
+    const simpleMixinBases = [];
+    const unionMixinGroups = [];
+    for (const mixin of mixins) {
+        if (Array.isArray(mixin.Type) && mixin.Type.length > 1) {
+            const unionTypes = mixin.Type.map(t => resolveType(t, ctx));
+            unionMixinGroups.push(unionTypes);
+        }
+        else {
+            const typeVal = Array.isArray(mixin.Type) ? mixin.Type[0] : mixin.Type;
+            if (isNamedGroupReference(typeVal)) {
+                simpleMixinBases.push(pascalCase(typeVal.Value));
+            }
+            else if (isGroup(typeVal) && !isNamedGroupReference(typeVal) && typeVal.Properties) {
+                const inlineGroup = typeVal;
+                const inlineProps = inlineGroup.Properties;
+                const inlineMixinBases = [];
+                for (const p of inlineProps) {
+                    if (isUnNamedProperty(p)) {
+                        const innerType = Array.isArray(p.Type) ? p.Type[0] : p.Type;
+                        if (isNamedGroupReference(innerType)) {
+                            inlineMixinBases.push(pascalCase(innerType.Value));
+                        }
+                    }
+                }
+                simpleMixinBases.push(...inlineMixinBases);
+            }
+        }
+    }
+    if (unionMixinGroups.length > 0) {
+        return comments + generateGroupWithUnionMixins(name, simpleMixinBases, unionMixinGroups, ownProps, ctx);
+    }
+    return comments + generateClass(name, simpleMixinBases, ownProps, ctx);
+}
+function generateGroupWithChoices(name, properties, ctx) {
+    const blocks = [];
+    const unionTypes = [];
+    let variantIndex = 0;
+    for (let i = 0; i < properties.length; i++) {
+        const prop = properties[i];
+        if (Array.isArray(prop)) {
+            const choiceOptions = [...prop];
+            const nextProp = properties[i + 1];
+            if (nextProp && !Array.isArray(nextProp)) {
+                choiceOptions.push(nextProp);
+                i++;
+            }
+            for (const option of choiceOptions) {
+                const typeVal = Array.isArray(option.Type) ? option.Type[0] : option.Type;
+                if (isUnNamedProperty(option)) {
+                    if (isNamedGroupReference(typeVal)) {
+                        unionTypes.push(pascalCase(typeVal.Value));
+                    }
+                    else {
+                        unionTypes.push(resolveType(typeVal, ctx));
+                    }
+                }
+                else {
+                    const variantName = `_${name}Variant${variantIndex}`;
+                    variantIndex++;
+                    blocks.push(generateClass(variantName, [], [option], ctx));
+                    unionTypes.push(variantName);
+                }
+            }
+        }
+        else if (isUnNamedProperty(prop)) {
+            const typeVal = Array.isArray(prop.Type) ? prop.Type[0] : prop.Type;
+            if (isNamedGroupReference(typeVal)) {
+                unionTypes.push(pascalCase(typeVal.Value));
+            }
+            else if (Array.isArray(prop.Type) && prop.Type.length > 1) {
+                for (const t of prop.Type) {
+                    unionTypes.push(resolveType(t, ctx));
+                }
+            }
+            else {
+                unionTypes.push(resolveType(typeVal, ctx));
+            }
+        }
+        else {
+            const variantName = `_${name}Variant${variantIndex}`;
+            variantIndex++;
+            blocks.push(generateClass(variantName, [], [prop], ctx));
+            unionTypes.push(variantName);
+        }
+    }
+    if (unionTypes.length === 1) {
+        blocks.push(`${name} = ${unionTypes[0]}`);
+    }
+    else {
+        ctx.typingImports.add('Union');
+        blocks.push(`${name} = Union[${unionTypes.join(', ')}]`);
+    }
+    return blocks.join('\n\n');
+}
+function generateGroupWithUnionMixins(name, simpleBases, unionGroups, ownProps, ctx) {
+    if (ownProps.length === 0 && simpleBases.length === 0) {
+        const allTypes = unionGroups.flat();
+        if (allTypes.length === 1) {
+            return `${name} = ${allTypes[0]}`;
+        }
+        ctx.typingImports.add('Union');
+        return `${name} = Union[${allTypes.join(', ')}]`;
+    }
+    const blocks = [];
+    const variantNames = [];
+    if (unionGroups.length === 1) {
+        const unionTypes = unionGroups[0];
+        if (ownProps.length > 0) {
+            const baseName = `_${name}Fields`;
+            blocks.push(generateClass(baseName, [], ownProps, ctx));
+            for (let i = 0; i < unionTypes.length; i++) {
+                const variantName = `_${name}Variant${i}`;
+                variantNames.push(variantName);
+                const bases = [baseName, unionTypes[i], ...simpleBases];
+                blocks.push(generateClass(variantName, bases, [], ctx));
+            }
+        }
+        else {
+            for (let i = 0; i < unionTypes.length; i++) {
+                const variantName = `_${name}Variant${i}`;
+                variantNames.push(variantName);
+                const bases = [unionTypes[i], ...simpleBases];
+                blocks.push(generateClass(variantName, bases, [], ctx));
+            }
+        }
+    }
+    else {
+        const allTypes = [...simpleBases, ...unionGroups.flat()];
+        ctx.typingImports.add('Union');
+        blocks.push(`${name} = Union[${allTypes.join(', ')}]`);
+        return blocks.join('\n\n');
+    }
+    ctx.typingImports.add('Union');
+    blocks.push(`${name} = Union[${variantNames.join(', ')}]`);
+    return blocks.join('\n\n');
+}
+// ---------------------------------------------------------------------------
+// Array
+// ---------------------------------------------------------------------------
+function generateArrayAssignment(arr, ctx) {
+    const name = pascalCase(arr.Name);
+    const comments = formatLeadingComments(arr.Comments);
+    const values = arr.Values;
+    if (values.length === 0) {
+        ctx.typingImports.add('Any');
+        return `${comments}${name} = list[Any]`;
+    }
+    const firstVal = values[0];
+    if (Array.isArray(firstVal)) {
+        const options = firstVal.map(p => {
+            const t = Array.isArray(p.Type) ? p.Type[0] : p.Type;
+            return resolveType(t, ctx);
+        });
+        if (options.length === 1) {
+            return `${comments}${name} = list[${options[0]}]`;
+        }
+        ctx.typingImports.add('Union');
+        return `${comments}${name} = list[Union[${options.join(', ')}]]`;
+    }
+    const firstType = firstVal.Type;
+    const types = Array.isArray(firstType) ? firstType : [firstType];
+    if (types.length === 1 && isCDDLArray(types[0])) {
+        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));
+        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));
+    if (typeStrs.length === 1) {
+        return `${comments}${name} = list[${typeStrs[0]}]`;
+    }
+    ctx.typingImports.add('Union');
+    return `${comments}${name} = list[Union[${typeStrs.join(', ')}]]`;
+}
+// ---------------------------------------------------------------------------
+// Class generation (TypedDict or Pydantic BaseModel)
+// ---------------------------------------------------------------------------
+function generateClass(name, bases, props, ctx) {
+    const lines = [];
+    let classDecl;
+    if (ctx.pydantic) {
+        ctx.pydanticImports.add('BaseModel');
+        if (bases.length > 0) {
+            classDecl = `class ${name}(${bases.join(', ')}):`;
+        }
+        else {
+            classDecl = `class ${name}(BaseModel):`;
+        }
+    }
+    else {
+        ctx.typingExtensionsImports.add('TypedDict');
+        if (bases.length > 0) {
+            classDecl = `class ${name}(${bases.join(', ')}):`;
+        }
+        else {
+            classDecl = `class ${name}(TypedDict):`;
+        }
+    }
+    lines.push(classDecl);
+    if (props.length === 0) {
+        lines.push('    pass');
+        return lines.join('\n');
+    }
+    for (const prop of props) {
+        const fieldLine = generateField(prop, ctx);
+        if (fieldLine) {
+            lines.push(fieldLine);
+        }
+    }
+    if (lines.length === 1) {
+        lines.push('    pass');
+    }
+    return lines.join('\n');
+}
+function generateField(prop, ctx) {
+    if (isUnNamedProperty(prop)) {
+        return null;
+    }
+    const propName = snakeCase(prop.Name);
+    const cddlTypes = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
+    const isOptional = prop.Occurrence.n === 0;
+    let typeStr;
+    const types = cddlTypes.map(t => resolveType(t, ctx));
+    if (types.length === 1) {
+        typeStr = types[0];
+    }
+    else {
+        ctx.typingImports.add('Union');
+        typeStr = `Union[${types.join(', ')}]`;
+    }
+    const inlineComment = prop.Comments
+        .filter(c => !c.Leading)
+        .map(c => c.Content.trim())
+        .join('; ');
+    const commentSuffix = inlineComment ? `  # ${inlineComment}` : '';
+    let defaultExpr = '';
+    if (prop.Operator && prop.Operator.Type === 'default') {
+        defaultExpr = formatDefaultValue(prop.Operator);
+    }
+    for (const t of cddlTypes) {
+        if (isPropertyReference(t) && t.Operator?.Type === 'default') {
+            const val = formatDefaultValue(t.Operator);
+            if (val) {
+                defaultExpr = val;
+            }
+        }
+    }
+    if (ctx.pydantic) {
+        if (isOptional) {
+            ctx.typingImports.add('Optional');
+            if (defaultExpr) {
+                ctx.pydanticImports.add('Field');
+                return `    ${propName}: Optional[${typeStr}] = Field(default=${defaultExpr})${commentSuffix}`;
+            }
+            return `    ${propName}: Optional[${typeStr}] = None${commentSuffix}`;
+        }
+        if (defaultExpr) {
+            ctx.pydanticImports.add('Field');
+            return `    ${propName}: ${typeStr} = Field(default=${defaultExpr})${commentSuffix}`;
+        }
+        return `    ${propName}: ${typeStr}${commentSuffix}`;
+    }
+    if (isOptional) {
+        ctx.typingExtensionsImports.add('NotRequired');
+        return `    ${propName}: NotRequired[${typeStr}]${commentSuffix}`;
+    }
+    return `    ${propName}: ${typeStr}${commentSuffix}`;
+}
+// ---------------------------------------------------------------------------
+// Type resolution
+// ---------------------------------------------------------------------------
+function resolveType(t, ctx) {
+    if (typeof t === 'string') {
+        const mapped = NATIVE_TYPE_MAP[t];
+        if (mapped) {
+            if (mapped === 'Any') {
+                ctx.typingImports.add('Any');
+            }
+            return mapped;
+        }
+        throw new Error(`Unknown native type: "${t}"`);
+    }
+    if (t.Type && typeof t.Type === 'string' && NATIVE_TYPE_MAP[t.Type]) {
+        const mapped = NATIVE_TYPE_MAP[t.Type];
+        if (mapped === 'Any') {
+            ctx.typingImports.add('Any');
+        }
+        return mapped;
+    }
+    if (isNativeTypeWithOperator(t) && NATIVE_TYPE_MAP[t.Type.Type]) {
+        const mapped = NATIVE_TYPE_MAP[t.Type.Type];
+        if (mapped === 'Any') {
+            ctx.typingImports.add('Any');
+        }
+        return mapped;
+    }
+    if (isPropertyReference(t) && t.Value === 'null') {
+        return 'None';
+    }
+    if (isGroup(t)) {
+        if (isNamedGroupReference(t)) {
+            return pascalCase(t.Value);
+        }
+        const group = t;
+        if (group.Properties) {
+            const props = group.Properties;
+            if (props.some(p => Array.isArray(p))) {
+                const options = [];
+                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));
+                        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);
+                        });
+                        ctx.typingImports.add('Tuple');
+                        options.push(`Tuple[${tupleItems.join(', ')}]`);
+                        continue;
+                    }
+                }
+                if (options.length > 1) {
+                    ctx.typingImports.add('Union');
+                    return `Union[${options.join(', ')}]`;
+                }
+                if (options.length === 1) {
+                    return options[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);
+                });
+                if (items.length === 1) {
+                    return items[0];
+                }
+                ctx.typingImports.add('Tuple');
+                return `Tuple[${items.join(', ')}]`;
+            }
+            if (props.length === 1 && Object.keys(NATIVE_TYPE_MAP).includes(props[0].Name)) {
+                const keyType = NATIVE_TYPE_MAP[props[0].Name];
+                if (keyType === 'Any') {
+                    ctx.typingImports.add('Any');
+                }
+                const valType = resolveType(props[0].Type[0], ctx);
+                return `dict[${keyType}, ${valType}]`;
+            }
+            ctx.typingImports.add('Any');
+            return 'dict[str, Any]';
+        }
+        throw new Error(`Unknown group type: ${JSON.stringify(t)}`);
+    }
+    if (isLiteralWithValue(t)) {
+        ctx.typingImports.add('Literal');
+        if (typeof t.Value === 'string') {
+            return `Literal["${t.Value}"]`;
+        }
+        if (typeof t.Value === 'number') {
+            return `Literal[${t.Value}]`;
+        }
+        if (typeof t.Value === 'boolean') {
+            return `Literal[${t.Value ? 'True' : 'False'}]`;
+        }
+        if (typeof t.Value === 'bigint') {
+            return `Literal[${t.Value.toString()}]`;
+        }
+        if (t.Value === null) {
+            return 'None';
+        }
+        throw new Error(`Unsupported literal: ${JSON.stringify(t)}`);
+    }
+    if (isCDDLArray(t)) {
+        const arrValues = t.Values;
+        if (arrValues.length === 0) {
+            ctx.typingImports.add('Any');
+            return 'list[Any]';
+        }
+        const firstVal = arrValues[0];
+        const innerTypes = Array.isArray(firstVal.Type) ? firstVal.Type : [firstVal.Type];
+        const typeStrs = innerTypes.map(v => resolveType(v, ctx));
+        if (typeStrs.length === 1) {
+            return `list[${typeStrs[0]}]`;
+        }
+        ctx.typingImports.add('Union');
+        return `list[Union[${typeStrs.join(', ')}]]`;
+    }
+    if (isRange(t)) {
+        return 'int';
+    }
+    if (isPropertyReference(t) && t.Type === 'range') {
+        return 'int';
+    }
+    if (isNativeTypeWithOperator(t) && isNamedGroupReference(t.Type)) {
+        return pascalCase(t.Type.Value);
+    }
+    if (isPropertyReference(t)) {
+        const ref = t;
+        if (ref.Type === 'group_array' && typeof ref.Value === 'string') {
+            return `list[${pascalCase(ref.Value)}]`;
+        }
+        if (ref.Type === 'tag') {
+            const tag = ref.Value;
+            const mapped = NATIVE_TYPE_MAP[tag.TypePart];
+            if (mapped) {
+                if (mapped === 'Any') {
+                    ctx.typingImports.add('Any');
+                }
+                return mapped;
+            }
+            return pascalCase(tag.TypePart);
+        }
+    }
+    throw new Error(`Unknown type: ${JSON.stringify(t)}`);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function formatLeadingComments(comments) {
+    const leading = comments.filter(c => c.Leading);
+    if (leading.length === 0) {
+        return '';
+    }
+    return leading.map(c => `# ${c.Content}`).join('\n') + '\n';
+}
+function formatDefaultValue(operator) {
+    if (operator.Type !== 'default') {
+        return '';
+    }
+    const val = operator.Value;
+    if (val === 'null') {
+        return 'None';
+    }
+    const ref = val;
+    if (ref.Type === 'literal') {
+        if (typeof ref.Value === 'string') {
+            return `"${ref.Value}"`;
+        }
+        if (typeof ref.Value === 'number') {
+            return String(ref.Value);
+        }
+        if (typeof ref.Value === 'boolean') {
+            return ref.Value ? 'True' : 'False';
+        }
+    }
+    return '';
+}

package/build/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert a string to snake_case
+ * @param name - The string to convert
+ * @returns The snake_case string
+ */
+export declare function snakeCase(name: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM9C"}