@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/daml-interface/cli/daml-interface-cli-options.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceCliOptions = void 0;
+const daml_interface_generation_exception_js_1 = require("../errors/daml-interface-generation.exception.js");
+const daml_module_import_style_js_1 = require("../emission/daml-module-import-style.js");
+class DamlInterfaceCliOptions {
+    inputPath;
+    outputDirectory;
+    moduleImportStyle;
+    constructor(init) {
+        this.inputPath = init.inputPath;
+        this.outputDirectory = init.outputDirectory;
+        this.moduleImportStyle = init.moduleImportStyle ?? daml_module_import_style_js_1.DamlModuleImportStyles.esm;
+    }
+    /** Parses CLI arguments into strongly typed DAML interface generation options. */
+    static parseOrThrow(args) {
+        let inputPath;
+        let outputDirectory;
+        let moduleImportStyle = daml_module_import_style_js_1.DamlModuleImportStyles.esm;
+        for (let index = 0; index < args.length; index++) {
+            const current = args[index];
+            const next = args[index + 1];
+            if (current === "--input") {
+                inputPath = next;
+                index++;
+            }
+            else if (current === "--output") {
+                outputDirectory = next;
+                index++;
+            }
+            else if (current === "--module-import-style") {
+                if (next !== daml_module_import_style_js_1.DamlModuleImportStyles.esm && next !== daml_module_import_style_js_1.DamlModuleImportStyles.tsNode) {
+                    throw new daml_interface_generation_exception_js_1.DamlInterfaceGenerationException("daml interface cli --module-import-style must be 'esm' or 'ts-node'");
+                }
+                moduleImportStyle = next;
+                index++;
+            }
+        }
+        if (inputPath === undefined || outputDirectory === undefined) {
+            throw new daml_interface_generation_exception_js_1.DamlInterfaceGenerationException("daml interface cli requires --input and --output");
+        }
+        return new DamlInterfaceCliOptions({
+            inputPath,
+            outputDirectory,
+            moduleImportStyle,
+        });
+    }
+}
+exports.DamlInterfaceCliOptions = DamlInterfaceCliOptions;

package/dist/cjs/daml-interface/cli/daml-interface-cli.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceCli = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const daml_interface_generator_js_1 = require("../daml-interface-generator.js");
+const daml_interface_generator_options_js_1 = require("../daml-interface-generator-options.js");
+const daml_interface_generation_exception_js_1 = require("../errors/daml-interface-generation.exception.js");
+const daml_interface_cli_options_js_1 = require("./daml-interface-cli-options.js");
+const daml_interface_writer_js_1 = require("../writing/daml-interface-writer.js");
+class DamlInterfaceCli {
+    generator;
+    writer;
+    readFileAsync;
+    createGenerator;
+    constructor(generator = undefined, writer = new daml_interface_writer_js_1.DamlInterfaceWriter(), readFileAsync = promises_1.readFile, createGenerator = (options) => new daml_interface_generator_js_1.DamlInterfaceGenerator(options)) {
+        this.generator = generator;
+        this.writer = writer;
+        this.readFileAsync = readFileAsync;
+        this.createGenerator = createGenerator;
+        void this.writer;
+        void this.readFileAsync;
+        void this.createGenerator;
+    }
+    /** Runs the DAML interface CLI and returns a process exit code. */
+    async runAsync(args) {
+        const options = daml_interface_cli_options_js_1.DamlInterfaceCliOptions.parseOrThrow(args);
+        const generator = this.generator ?? this.createGenerator(new daml_interface_generator_options_js_1.DamlInterfaceGeneratorOptions({
+            moduleImportStyle: options.moduleImportStyle,
+        }));
+        const bytes = await this.readFileAsync(options.inputPath);
+        const extension = (0, node_path_1.extname)(options.inputPath).toLowerCase();
+        const project = extension === ".dar"
+            ? await generator.generateFromDarOrThrowAsync(bytes)
+            : extension === ".dalf"
+                ? await generator.generateFromDalfOrThrowAsync(bytes)
+                : undefined;
+        if (project === undefined) {
+            throw new daml_interface_generation_exception_js_1.DamlInterfaceGenerationException(`daml interface cli does not support '${extension}' inputs`);
+        }
+        await this.writer.writeProjectAsync(project, options.outputDirectory);
+        return 0;
+    }
+}
+exports.DamlInterfaceCli = DamlInterfaceCli;

package/dist/cjs/daml-interface/daml-interface-generator-options.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceGeneratorOptions = void 0;
+const daml_module_import_style_js_1 = require("./emission/daml-module-import-style.js");
+class DamlInterfaceGeneratorOptions {
+    generatedDirectory;
+    moduleImportStyle;
+    constructor(init = {}) {
+        this.generatedDirectory = init.generatedDirectory ?? "generated";
+        this.moduleImportStyle = init.moduleImportStyle ?? daml_module_import_style_js_1.DamlModuleImportStyles.esm;
+    }
+}
+exports.DamlInterfaceGeneratorOptions = DamlInterfaceGeneratorOptions;

package/dist/cjs/daml-interface/daml-interface-generator.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceGenerator = void 0;
+const dar_archive_loader_js_1 = require("../daml-lf/container/dar-archive-loader.js");
+const daml_lf_compilation_js_1 = require("../daml-lf/daml-lf-compilation.js");
+const daml_lf_package_loader_js_1 = require("../daml-lf/daml-lf-package-loader.js");
+const daml_lf_workspace_js_1 = require("../daml-lf/daml-lf-workspace.js");
+const daml_interface_analyzer_js_1 = require("./analysis/daml-interface-analyzer.js");
+const daml_interface_generator_options_js_1 = require("./daml-interface-generator-options.js");
+const project_emitter_js_1 = require("./emission/project-emitter.js");
+class DamlInterfaceGenerator {
+    analyzer;
+    projectEmitter;
+    darArchiveLoader;
+    packageLoader;
+    options;
+    constructor(options = new daml_interface_generator_options_js_1.DamlInterfaceGeneratorOptions(), analyzer = new daml_interface_analyzer_js_1.DamlInterfaceAnalyzer(), projectEmitter = new project_emitter_js_1.ProjectEmitter(), darArchiveLoader = new dar_archive_loader_js_1.DarArchiveLoader(), packageLoader = new daml_lf_package_loader_js_1.DamlLfPackageLoader()) {
+        this.analyzer = analyzer;
+        this.projectEmitter = projectEmitter;
+        this.darArchiveLoader = darArchiveLoader;
+        this.packageLoader = packageLoader;
+        this.options = options;
+        void this.analyzer;
+        void this.projectEmitter;
+        void this.darArchiveLoader;
+        void this.packageLoader;
+    }
+    /** Analyzes a compiled DAML-LF workspace with the package generator rules. */
+    analyzeOrThrow(compilation) {
+        return this.analyzer.analyzeOrThrow(compilation);
+    }
+    /** Generates an in-memory project from compiled DAML-LF archive bytes. */
+    async generateFromDalfOrThrowAsync(archiveBytes) {
+        const pkg = this.packageLoader.loadPackageOrThrow(archiveBytes);
+        const compilation = daml_lf_compilation_js_1.DamlLfCompilation.createForTemplateGeneration(new daml_lf_workspace_js_1.DamlLfWorkspace([pkg]));
+        return this.projectEmitter.emitProject(this.analyzeOrThrow(compilation), this.options.moduleImportStyle);
+    }
+    /** Generates an in-memory project from DAR bytes. */
+    async generateFromDarOrThrowAsync(archiveBytes) {
+        const archive = await this.darArchiveLoader.loadDarOrThrowAsync(archiveBytes);
+        const packages = archive.packageEntries.map((entry) => this.packageLoader.loadPackageOrThrow(entry.bytes));
+        const compilation = daml_lf_compilation_js_1.DamlLfCompilation.createForTemplateGeneration(new daml_lf_workspace_js_1.DamlLfWorkspace(packages));
+        return this.projectEmitter.emitProject(this.analyzeOrThrow(compilation), this.options.moduleImportStyle);
+    }
+}
+exports.DamlInterfaceGenerator = DamlInterfaceGenerator;

package/dist/cjs/daml-interface/emission/daml-module-import-style.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlModuleImportStyles = void 0;
+/** Selects the relative module specifier format emitted for generated DAML projects. */
+class DamlModuleImportStyles {
+    static esm = "esm";
+    static tsNode = "ts-node";
+    constructor() { }
+}
+exports.DamlModuleImportStyles = DamlModuleImportStyles;

package/dist/cjs/daml-interface/emission/generated-spec-emitter.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedSpecEmitter = void 0;
+const daml_lf_builtin_type_js_1 = require("../../daml-lf/model/daml-lf-builtin-type.js");
+const generated_named_type_file_js_1 = require("../emission-model/generated-named-type-file.js");
+const generated_spec_file_js_1 = require("../emission-model/generated-spec-file.js");
+const generated_template_binding_file_js_1 = require("../emission-model/generated-template-binding-file.js");
+const generated_test_sample_emitter_js_1 = require("./generated-test-sample-emitter.js");
+const relative_module_specifier_js_1 = require("./relative-module-specifier.js");
+/** Emits dependency-free Node test modules alongside every generated DAML module. */
+class GeneratedSpecEmitter {
+    constructor() { }
+    /** Emits exactly one sibling `.spec.ts` module for every generated production module. */
+    static emitSpecFiles(project, analysis, moduleImportStyle) {
+        return project.productionFiles.map((file) => new generated_spec_file_js_1.GeneratedSpecFile(this.specPath(file.path), file instanceof generated_template_binding_file_js_1.GeneratedTemplateBindingFile
+            ? this.emitTemplateSpec(file, project, analysis, moduleImportStyle)
+            : file instanceof generated_named_type_file_js_1.GeneratedNamedTypeFile
+                ? this.emitNamedTypeSpec(file, project, analysis, moduleImportStyle)
+                : this.emitSupportSpec(file.path, project, analysis, moduleImportStyle), file.path));
+    }
+    static emitTemplateSpec(file, project, analysis, moduleImportStyle) {
+        const binding = file.binding;
+        const reservedLocalNames = [
+            binding.className,
+            ...binding.choices.map((choice) => choice.exercisedEventTypeName),
+        ];
+        let imports = [];
+        const sampleContext = this.sampleContext(project, analysis);
+        const emitTypeScriptSample = (type) => {
+            const emission = generated_test_sample_emitter_js_1.GeneratedTestSampleEmitter.emitTypeScriptExpressionWithImportsOrThrow(this.normalizeType(type), sampleContext, { imports, reservedLocalNames });
+            imports = emission.imports;
+            return emission.expression;
+        };
+        const expectedFields = binding.createFields.map((field) => ({
+            propertyName: field.propertyName,
+            expression: emitTypeScriptSample(field.type),
+        }));
+        const payload = this.emitObject(binding.createFields.map((field) => ({
+            key: field.name,
+            expression: generated_test_sample_emitter_js_1.GeneratedTestSampleEmitter.emitLedgerExpressionOrThrow(this.normalizeType(field.type), sampleContext),
+        })));
+        const localImports = [binding.className, ...binding.choices.map((choice) => choice.exercisedEventTypeName)];
+        const choiceBlocks = binding.choices.map((choice) => this.emitChoiceSpec(binding.templateIdLiteral, binding.className, choice, sampleContext, emitTypeScriptSample));
+        const lines = [
+            ...this.nodeImports(),
+            ...this.emitSampleImports(imports, this.specPath(file.path), moduleImportStyle),
+            `import { ${localImports.join(", ")} } from ${JSON.stringify(this.modulePath(this.specPath(file.path), file.path, moduleImportStyle))};`,
+            "",
+            `test(${JSON.stringify(`${binding.className} materializes a created event`)}, () => {`,
+            `    const expected = ${this.emitObject(expectedFields.map((field) => ({ key: field.propertyName, expression: field.expression })))};`,
+            `    const materialized = ${binding.className}.fromCreatedEvent({`,
+            '        contract_id: "#sample-contract-id",',
+            `        template_id: ${this.identityExpression(binding.templateIdLiteral)},`,
+            `        create_arguments: ${payload},`,
+            "    });",
+            `    assert.ok(materialized instanceof ${binding.className});`,
+            '    assert.equal(materialized.contractId, "#sample-contract-id");',
+            ...expectedFields.map((field) => `    assert.deepEqual(materialized.${field.propertyName}, expected.${field.propertyName});`),
+            "});",
+            ...choiceBlocks.flat(),
+            "",
+        ];
+        return lines.join("\n");
+    }
+    static emitNamedTypeSpec(file, project, analysis, moduleImportStyle) {
+        const definitions = analysis.typeDefinitions.filter((definition) => definition.identity.packageId === file.packageId
+            && definition.identity.moduleName === file.moduleName);
+        const context = this.sampleContext(project, analysis);
+        let imports = [];
+        const emitTypeScriptSample = (type, typeVariableBindings) => {
+            const emission = generated_test_sample_emitter_js_1.GeneratedTestSampleEmitter.emitTypeScriptExpressionWithImportsOrThrow(type, { ...context, typeVariableBindings }, { imports });
+            imports = emission.imports;
+            return emission.expression;
+        };
+        const samples = [];
+        const usedSampleLocalNames = new Set();
+        for (const definition of definitions) {
+            const exportedName = file.exportedTypeNamesByIdentity.get(this.definitionKey(definition));
+            if (exportedName === undefined) {
+                throw new Error(`Cannot emit generated spec for unresolved type '${definition.identity.name}'`);
+            }
+            const typeArguments = this.sampleTypeArguments(definition);
+            const reference = {
+                kind: "namedReference",
+                identity: definition.identity,
+                typeArguments,
+            };
+            const sample = emitTypeScriptSample(reference);
+            if (definition.kind === "enum") {
+                for (const constructor of definition.constructors) {
+                    samples.push(`const ${this.allocateSafeLocalName(exportedName, constructor, usedSampleLocalNames)}: ${exportedName} = ${JSON.stringify(constructor)};`);
+                }
+            }
+            else if (definition.kind === "variant") {
+                for (const constructor of definition.constructors) {
+                    const variant = {
+                        kind: "variant",
+                        constructors: [constructor],
+                    };
+                    const expression = emitTypeScriptSample(variant, new Map((definition.typeParameters ?? []).map((parameter) => [
+                        `${parameter.name}\u0000${parameter.internedStringIndex}`,
+                        { kind: "primitive", builtinType: daml_lf_builtin_type_js_1.DamlLfBuiltinType.text },
+                    ])));
+                    samples.push(`const ${this.allocateSafeLocalName(exportedName, constructor.constructor, usedSampleLocalNames)} = (${expression} satisfies ${this.appliedTypeName(exportedName, typeArguments)});`);
+                }
+            }
+            else {
+                samples.push(`const ${this.allocateSafeLocalName(exportedName, "sample", usedSampleLocalNames)} = ${sample};`);
+            }
+        }
+        const namedImports = [...file.exportedTypeNames].sort();
+        return [
+            ...this.nodeImports(),
+            ...this.emitSampleImports(imports.filter((entry) => entry.modulePath !== file.path), this.specPath(file.path), moduleImportStyle),
+            ...(namedImports.length === 0 ? [] : [`import type { ${namedImports.join(", ")} } from ${JSON.stringify(this.modulePath(this.specPath(file.path), file.path, moduleImportStyle))};`]),
+            "",
+            ...samples,
+            "",
+            `test(${JSON.stringify(`${file.packageId}:${file.moduleName} named types compile`)}, () => {`,
+            "    assert.ok(true);",
+            "});",
+            "",
+        ].join("\n");
+    }
+    static emitChoiceSpec(templateIdLiteral, className, choice, sampleContext, emitTypeScriptSample) {
+        const argument = emitTypeScriptSample(choice.parameterType);
+        const result = emitTypeScriptSample(choice.returnType);
+        const ledgerArgument = generated_test_sample_emitter_js_1.GeneratedTestSampleEmitter.emitLedgerExpressionOrThrow(this.normalizeType(choice.parameterType), sampleContext);
+        const ledgerResult = generated_test_sample_emitter_js_1.GeneratedTestSampleEmitter.emitLedgerExpressionOrThrow(this.normalizeType(choice.returnType), sampleContext);
+        const metadata = this.identityExpression(templateIdLiteral);
+        return [
+            "",
+            `test(${JSON.stringify(`${className}.${choice.name} materializes an exercised event`)}, () => {`,
+            `    const expectedArgument = ${argument};`,
+            `    const expectedResult = ${result};`,
+            `    const materialized = ${className}.fromExercisedEvent({`,
+            '        contract_id: "#sample-contract-id",',
+            `        template_id: ${metadata},`,
+            `        choice: ${JSON.stringify(choice.name)},`,
+            "        consuming: false,",
+            `        choice_argument: ${ledgerArgument},`,
+            `        exercise_result: ${ledgerResult},`,
+            "    });",
+            `    assert.ok(materialized instanceof ${choice.exercisedEventTypeName});`,
+            '    assert.equal(materialized.contractId, "#sample-contract-id");',
+            "    assert.equal(materialized.consuming, false);",
+            "    assert.deepEqual(materialized.argument, expectedArgument);",
+            "    assert.deepEqual(materialized.result, expectedResult);",
+            `    assert.deepEqual(materialized.metadata, { templateId: ${metadata} });`,
+            "});",
+        ];
+    }
+    static emitSupportSpec(path, project, analysis, moduleImportStyle) {
+        if (path === "generated/support/contracts.ts") {
+            return [
+                ...this.nodeImports(),
+                `import type { GeneratedContractId } from ${JSON.stringify(this.modulePath(this.specPath(path), path, moduleImportStyle))};`,
+                "",
+                'const sampleContractId = "#sample-contract-id" satisfies GeneratedContractId;',
+                "",
+                'test("generated contract support types compile", () => {',
+                '    assert.equal(sampleContractId, "#sample-contract-id");',
+                "});",
+                "",
+            ].join("\n");
+        }
+        else if (path === "generated/support/runtime.ts") {
+            return [
+                ...this.nodeImports(),
+                `import type { DamlDate, DamlNumeric, DamlParty, DamlTimestamp, DamlUnit } from ${JSON.stringify(this.modulePath(this.specPath(path), path, moduleImportStyle))};`,
+                "",
+                "const runtimeTypes = undefined as unknown as readonly [DamlDate, DamlNumeric, DamlParty, DamlTimestamp, DamlUnit];",
+                "",
+                'test("generated runtime support types compile", () => {',
+                "    void runtimeTypes;",
+                "    assert.ok(true);",
+                "});",
+                "",
+            ].join("\n");
+        }
+        else if (path === "generated/support/descriptors.ts") {
+            return this.emitDescriptorSpec(path, project, analysis, moduleImportStyle);
+        }
+        else if (path === "generated/registry.ts") {
+            return [
+                ...this.nodeImports(),
+                `import { GeneratedRegistry } from ${JSON.stringify(this.modulePath(this.specPath(path), path, moduleImportStyle))};`,
+                "",
+                'test("generated registry exposes static event readers", () => {',
+                '    assert.equal(typeof GeneratedRegistry.fromCreatedEvent, "function");',
+                '    assert.equal(typeof GeneratedRegistry.fromExercisedEvent, "function");',
+                "});",
+                "",
+            ].join("\n");
+        }
+        else if (path === "generated/index.ts") {
+            return [
+                ...this.nodeImports(),
+                `import * as Generated from ${JSON.stringify(this.modulePath(this.specPath(path), path, moduleImportStyle))};`,
+                "",
+                'test("generated project index exports the registry", () => {',
+                '    assert.equal(typeof Generated.GeneratedRegistry, "function");',
+                "});",
+                "",
+            ].join("\n");
+        }
+        return this.emitNamespaceSpec(path, project, analysis, moduleImportStyle);
+    }
+    static emitNamespaceSpec(path, project, analysis, moduleImportStyle) {
+        const directoryPath = path.replace(/\/[^/]+$/, "");
+        const typeFile = project.namedTypeFiles.find((file) => file.path === `${directoryPath}/types.ts`);
+        const typeExports = typeFile?.exportedTypeNames ?? [];
+        const valueExports = project.templateFiles
+            .filter((file) => file.path.startsWith(`${directoryPath}/`))
+            .flatMap((file) => [file.binding.className, ...file.binding.choices.map((choice) => choice.exercisedEventTypeName)]);
+        const modulePath = this.modulePath(this.specPath(path), path, moduleImportStyle);
+        const typeAssertions = typeExports.map((exportedName, index) => {
+            const definition = analysis.typeDefinitions.find((candidate) => typeFile?.exportedTypeNamesByIdentity.get(this.definitionKey(candidate)) === exportedName);
+            const typeParameterCount = definition === undefined || definition.kind === "enum"
+                ? 0
+                : (definition.typeParameters?.length ?? 0);
+            const arguments_ = typeParameterCount === 0
+                ? ""
+                : `<${Array.from({ length: typeParameterCount }, () => "unknown").join(", ")}>`;
+            return `const forwardedType_${index} = undefined as unknown as ${exportedName}${arguments_};`;
+        });
+        return [
+            ...this.nodeImports(),
+            ...(typeExports.length === 0 ? [] : [`import type { ${typeExports.join(", ")} } from ${JSON.stringify(modulePath)};`]),
+            ...(valueExports.length === 0 ? [] : [`import { ${valueExports.join(", ")} } from ${JSON.stringify(modulePath)};`]),
+            "",
+            ...typeAssertions,
+            ...(typeAssertions.length === 0 ? [] : [""]),
+            `test(${JSON.stringify(`${path} forwards its generated exports`)}, () => {`,
+            ...typeAssertions.map((_, index) => `    void forwardedType_${index};`),
+            ...valueExports.map((exportedName) => `    assert.equal(typeof ${exportedName}, "function");`),
+            ...(typeAssertions.length === 0 && valueExports.length === 0 ? ["    assert.ok(true);"] : []),
+            "});",
+            "",
+        ].join("\n");
+    }
+    static emitDescriptorSpec(path, project, analysis, moduleImportStyle) {
+        const resolveLines = analysis.typeDefinitions.flatMap((definition) => {
+            const typeParameterCount = definition.kind === "enum" ? 0 : (definition.typeParameters?.length ?? 0);
+            const argumentsExpression = typeParameterCount === 0
+                ? "[]"
+                : `[${Array.from({ length: typeParameterCount }, () => '{ kind: "primitive", primitive: "text" }').join(", ")}]`;
+            const identity = this.identityExpression(`${definition.identity.packageId}:${definition.identity.moduleName}:${definition.identity.name}`);
+            return [
+                `    assert.notEqual(GeneratedDamlTypeDescriptorRegistry.resolve(${identity}, ${argumentsExpression}), undefined);`,
+            ];
+        });
+        return [
+            ...this.nodeImports(),
+            `import { GeneratedDamlTypeDescriptorRegistry } from ${JSON.stringify(this.modulePath(this.specPath(path), path, moduleImportStyle))};`,
+            "",
+            'test("generated descriptor registry resolves every emitted type", () => {',
+            ...resolveLines,
+            "    assert.ok(true);",
+            "});",
+            "",
+        ].join("\n");
+    }
+    static sampleContext(project, analysis) {
+        return {
+            definitions: analysis.typeDefinitions.map((definition) => this.normalizeDefinition(definition)),
+            namedTypeFiles: project.namedTypeFiles,
+        };
+    }
+    static emitSampleImports(imports, sourcePath, moduleImportStyle) {
+        return imports.map((entry) => {
+            const modulePath = entry.modulePath.startsWith("generated/")
+                ? this.modulePath(sourcePath, entry.modulePath, moduleImportStyle)
+                : entry.modulePath;
+            const imported = entry.exportedName === entry.localName
+                ? entry.exportedName
+                : `${entry.exportedName} as ${entry.localName}`;
+            return `import${entry.typeOnly ? " type" : ""} { ${imported} } from ${JSON.stringify(modulePath)};`;
+        });
+    }
+    static sampleTypeArguments(definition) {
+        if (definition.kind === "enum") {
+            return [];
+        }
+        return (definition.typeParameters ?? []).map(() => ({
+            kind: "primitive",
+            builtinType: daml_lf_builtin_type_js_1.DamlLfBuiltinType.text,
+        }));
+    }
+    static appliedTypeName(name, typeArguments) {
+        return typeArguments.length === 0 ? name : `${name}<${typeArguments.map(() => "string").join(", ")}>`;
+    }
+    static normalizeType(type) {
+        switch (type.kind) {
+            case "optional":
+                return { ...type, element: this.normalizeType(type.element) };
+            case "list":
+                return { ...type, element: this.normalizeType(type.element) };
+            case "textMap":
+                return { ...type, value: this.normalizeType(type.value) };
+            case "genMap":
+                return { ...type, key: this.normalizeType(type.key), value: this.normalizeType(type.value) };
+            case "record":
+                return { ...type, fields: type.fields.map((field) => ({ ...field, type: this.normalizeType(field.type) })) };
+            case "variant":
+                return { ...type, constructors: type.constructors.map((constructor) => ({ ...constructor, payload: this.normalizeType(constructor.payload) })) };
+            case "namedReference":
+                return { ...type, typeArguments: (type.typeArguments ?? []).map((argument) => this.normalizeType(argument)) };
+            default:
+                return type;
+        }
+    }
+    static normalizeDefinition(definition) {
+        if (definition.kind === "enum") {
+            return definition;
+        }
+        else if (definition.kind === "record") {
+            return {
+                ...definition,
+                typeParameters: definition.typeParameters ?? [],
+                fields: definition.fields.map((field) => ({ ...field, type: this.normalizeType(field.type) })),
+            };
+        }
+        return {
+            ...definition,
+            typeParameters: definition.typeParameters ?? [],
+            constructors: definition.constructors.map((constructor) => ({
+                ...constructor,
+                payload: this.normalizeType(constructor.payload),
+            })),
+        };
+    }
+    static nodeImports() {
+        return [
+            'import assert from "node:assert/strict";',
+            'import { test } from "node:test";',
+        ];
+    }
+    static emitObject(entries) {
+        return `{ ${entries.map((entry) => `${JSON.stringify(entry.key)}: ${entry.expression}`).join(", ")} }`;
+    }
+    static identityExpression(templateId) {
+        const [packageId, moduleName, entityName] = templateId.split(":");
+        return `{ packageId: ${JSON.stringify(packageId)}, moduleName: ${JSON.stringify(moduleName)}, entityName: ${JSON.stringify(entityName)} }`;
+    }
+    static definitionKey(definition) {
+        return `${definition.identity.packageId}\u0000${definition.identity.moduleName}\u0000${definition.identity.name}`;
+    }
+    static allocateSafeLocalName(typeName, suffix, usedNames) {
+        const baseName = `${typeName.replace(/[^A-Za-z0-9_$]/g, "_")}_${suffix.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+        let localName = baseName;
+        let number = 2;
+        while (usedNames.has(localName)) {
+            localName = `${baseName}_${number}`;
+            number += 1;
+        }
+        usedNames.add(localName);
+        return localName;
+    }
+    static specPath(path) {
+        return path.replace(/\.ts$/, ".spec.ts");
+    }
+    static modulePath(fromPath, toPath, moduleImportStyle) {
+        return relative_module_specifier_js_1.RelativeModuleSpecifier.fromPaths(fromPath, toPath, moduleImportStyle);
+    }
+}
+exports.GeneratedSpecEmitter = GeneratedSpecEmitter;