@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/daml-interface/emission/named-type-emitter.js

@@ -0,0 +1,510 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamedTypeEmitter = 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 type_script_name_resolver_js_1 = require("./type-script-name-resolver.js");
+const relative_module_specifier_js_1 = require("./relative-module-specifier.js");
+/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+class NamedTypeEmitter {
+    nameResolver;
+    constructor(nameResolver = new type_script_name_resolver_js_1.TypeScriptNameResolver()) {
+        this.nameResolver = nameResolver;
+        void this.nameResolver;
+    }
+    /** Prepares shared package/module output mappings with template emission. */
+    prepareProjectOrThrow(templates, definitions, packageMetadata = new Map()) {
+        this.nameResolver.prepareProjectOrThrow(templates, definitions, packageMetadata);
+    }
+    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    emitNamedTypeFiles(definitions, moduleImportStyle) {
+        this.nameResolver.prepareProjectOrThrow([], definitions);
+        return this.emitPreparedNamedTypeFiles(definitions, [], moduleImportStyle);
+    }
+    /** Emits named type files from an already prepared shared name resolver. */
+    emitPreparedNamedTypeFiles(definitions, templateFiles = [], moduleImportStyle) {
+        const modules = this.resolveModulesOrThrow(definitions);
+        const names = this.resolveDefinitionNamesOrThrow(definitions, this.mergeReservedNames(this.getReservedModuleExports(templateFiles), this.getReservedRuntimeBindings(definitions)));
+        const fieldPropertyNames = this.resolveFieldPropertyNames(definitions);
+        return [...modules.values()].map((module) => {
+            const moduleDefinitions = definitions.filter((definition) => definition.identity.packageId === module.packageId
+                && definition.identity.moduleName === module.moduleName);
+            const externalTypeAliases = this.resolveExternalTypeAliases(module, moduleDefinitions, modules, names);
+            const typeParameterNames = this.resolveTypeParameterNames(moduleDefinitions, names, externalTypeAliases);
+            const imports = this.emitImports(module, moduleDefinitions, modules, names, externalTypeAliases, moduleImportStyle);
+            return new generated_named_type_file_js_1.GeneratedNamedTypeFile({
+                path: module.path,
+                contents: [
+                    ...imports,
+                    ...(imports.length === 0 ? [] : [""]),
+                    ...moduleDefinitions.map((definition) => this.emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames, typeParameterNames)),
+                    "",
+                ].join("\n"),
+                packageId: module.packageId,
+                moduleName: module.moduleName,
+                namespaceAlias: module.namespaceAlias,
+                exportedTypeNames: moduleDefinitions.map((definition) => this.getDefinitionName(definition, names)),
+                exportedTypeNamesByIdentity: new Map(moduleDefinitions.map((definition) => [
+                    this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name),
+                    this.getDefinitionName(definition, names),
+                ])),
+                fieldPropertyNames: new Map([...fieldPropertyNames.entries()].filter(([key]) => key.startsWith(`${module.key}\u0000`))),
+            });
+        });
+    }
+    emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames, typeParameterNames) {
+        const name = this.getDefinitionName(definition, names);
+        const parameters = this.getDefinitionTypeParameters(definition, typeParameterNames);
+        const declarationName = `${name}${parameters.length === 0 ? "" : `<${parameters.join(", ")}>`}`;
+        if (definition.kind === "record") {
+            return [
+                `export interface ${declarationName} {`,
+                ...definition.fields.map((field, index) => `    readonly ${this.getFieldPropertyName(definition, index, fieldPropertyNames)}: ${this.getTypeName(field.type, definition, names, externalTypeAliases, typeParameterNames)};`),
+                "}",
+            ].join("\n");
+        }
+        else if (definition.kind === "variant") {
+            return [
+                `export type ${declarationName} =`,
+                ...definition.constructors.map((constructor) => `    | { readonly tag: ${JSON.stringify(constructor.constructor)}; readonly value: ${this.getTypeName(constructor.payload, definition, names, externalTypeAliases, typeParameterNames)}; }`),
+            ].map((line, index, lines) => index === lines.length - 1 ? `${line};` : line).join("\n");
+        }
+        return `export type ${name} = ${definition.constructors.map((constructor) => JSON.stringify(constructor)).join(" | ")};`;
+    }
+    emitImports(module, definitions, modules, names, externalTypeAliases, moduleImportStyle) {
+        const imports = new Map();
+        const runtimeTypes = new Set();
+        for (const definition of definitions) {
+            for (const primitive of this.getRuntimePrimitiveTypes(definition)) {
+                runtimeTypes.add(primitive);
+            }
+            for (const reference of this.getNamedReferences(definition)) {
+                const referencedModuleKey = this.getModuleKey(reference.identity.packageId, reference.identity.moduleName);
+                if (referencedModuleKey === module.key) {
+                    continue;
+                }
+                const referencedModule = modules.get(referencedModuleKey);
+                if (referencedModule === undefined) {
+                    throw new Error(`Cannot emit unresolved named DAML type '${reference.identity.name}'`);
+                }
+                const importPath = this.relativeFilePath(module.path, referencedModule.path, moduleImportStyle);
+                const importedNames = imports.get(importPath) ?? new Map();
+                importedNames.set(this.getNamedReferenceTypeName(reference.identity, names), this.getExternalTypeAlias(reference.identity, externalTypeAliases));
+                imports.set(importPath, importedNames);
+            }
+        }
+        return [
+            ...(runtimeTypes.size === 0 ? [] : [
+                `import type { ${[...runtimeTypes].sort().join(", ")} } from ${JSON.stringify(this.relativeFilePath(module.path, "generated/support/runtime.ts", moduleImportStyle))};`,
+            ]),
+            ...[...imports.entries()]
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([path, importedNames]) => `import type { ${[...importedNames.entries()]
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([exportedName, alias]) => exportedName === alias
+                ? exportedName
+                : `${exportedName} as ${alias}`)
+                .join(", ")} } from ${JSON.stringify(path)};`),
+        ];
+    }
+    resolveExternalTypeAliases(module, definitions, modules, names) {
+        const references = new Map();
+        for (const definition of definitions) {
+            for (const reference of this.getNamedReferences(definition)) {
+                const moduleKey = this.getModuleKey(reference.identity.packageId, reference.identity.moduleName);
+                if (moduleKey !== module.key) {
+                    const key = this.getDefinitionKey(reference.identity.packageId, reference.identity.moduleName, reference.identity.name);
+                    references.set(key, reference.identity);
+                }
+            }
+        }
+        const aliases = new Map();
+        const usedNames = new Set(definitions.map((definition) => this.getDefinitionName(definition, names)));
+        for (const [key, identity] of [...references.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+            const referencedModule = modules.get(this.getModuleKey(identity.packageId, identity.moduleName));
+            if (referencedModule === undefined) {
+                throw new Error(`Cannot emit unresolved named DAML type '${identity.name}'`);
+            }
+            const exportedName = this.getNamedReferenceTypeName(identity, names);
+            const baseName = this.safeTypeName(`${referencedModule.namespaceAlias} ${exportedName}`);
+            let alias = exportedName;
+            let escalation = 2;
+            if (usedNames.has(alias)) {
+                alias = baseName;
+            }
+            while (usedNames.has(alias)) {
+                alias = `${baseName}_${this.shortHash(key)}_${escalation}`;
+                escalation += 1;
+            }
+            usedNames.add(alias);
+            aliases.set(key, alias);
+        }
+        return aliases;
+    }
+    getExternalTypeAlias(identity, aliases) {
+        const alias = aliases.get(this.getDefinitionKey(identity.packageId, identity.moduleName, identity.name));
+        if (alias === undefined) {
+            throw new Error(`Cannot resolve external named DAML type '${identity.name}'`);
+        }
+        return alias;
+    }
+    *getNamedReferences(type) {
+        switch (type.kind) {
+            case "namedReference":
+                yield type;
+                for (const typeArgument of type.typeArguments ?? []) {
+                    yield* this.getNamedReferences(typeArgument);
+                }
+                return;
+            case "contractId": return;
+            case "optional":
+            case "list":
+                yield* this.getNamedReferences(type.element);
+                return;
+            case "textMap":
+                yield* this.getNamedReferences(type.value);
+                return;
+            case "genMap":
+                yield* this.getNamedReferences(type.key);
+                yield* this.getNamedReferences(type.value);
+                return;
+            case "record":
+                for (const field of type.fields) {
+                    yield* this.getNamedReferences(field.type);
+                }
+                return;
+            case "variant":
+                for (const constructor of type.constructors) {
+                    yield* this.getNamedReferences(constructor.payload);
+                }
+                return;
+            case "primitive":
+            case "enum":
+            case "typeVariable":
+                return;
+        }
+    }
+    getTypeName(type, definition, names, externalTypeAliases, typeParameterNames) {
+        switch (type.kind) {
+            case "primitive":
+                return this.getPrimitiveTypeName(type.builtinType);
+            case "contractId":
+                return "string";
+            case "optional":
+                return `${this.getTypeName(type.element, definition, names, externalTypeAliases, typeParameterNames)} | undefined`;
+            case "list":
+                return `readonly ${this.getArrayElementTypeName(type.element, definition, names, externalTypeAliases, typeParameterNames)}[]`;
+            case "textMap":
+                return `ReadonlyMap<string, ${this.getTypeName(type.value, definition, names, externalTypeAliases, typeParameterNames)}>`;
+            case "genMap":
+                return `ReadonlyMap<${this.getTypeName(type.key, definition, names, externalTypeAliases, typeParameterNames)}, ${this.getTypeName(type.value, definition, names, externalTypeAliases, typeParameterNames)}>`;
+            case "record":
+            case "variant":
+            case "enum":
+                throw new Error("Named DAML declarations must not contain anonymous record, variant, or enum shapes");
+            case "typeVariable":
+                return this.getTypeParameterName(definition, type, typeParameterNames);
+            case "namedReference": {
+                const name = externalTypeAliases.get(this.getDefinitionKey(type.identity.packageId, type.identity.moduleName, type.identity.name)) ?? this.getNamedReferenceTypeName(type.identity, names);
+                return (type.typeArguments?.length ?? 0) === 0
+                    ? name
+                    : `${name}<${(type.typeArguments ?? []).map((argument) => this.getTypeName(argument, definition, names, externalTypeAliases, typeParameterNames)).join(", ")}>`;
+            }
+        }
+    }
+    getArrayElementTypeName(type, definition, names, externalTypeAliases, typeParameterNames) {
+        const name = this.getTypeName(type, definition, names, externalTypeAliases, typeParameterNames);
+        return type.kind === "optional" || type.kind === "variant" || type.kind === "enum"
+            ? `(${name})`
+            : name;
+    }
+    getPrimitiveTypeName(type) {
+        switch (type) {
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.unit:
+                return "DamlUnit";
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.bool:
+                return "boolean";
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.int64:
+                return "bigint";
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.date:
+                return "DamlDate";
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.timestamp:
+                return "DamlTimestamp";
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.numeric:
+                return "DamlNumeric";
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.party:
+                return "DamlParty";
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.text:
+                return "string";
+            default:
+                throw new Error(`Cannot emit unsupported primitive DAML type '${type}'`);
+        }
+    }
+    resolveTypeParameterNames(definitions, names, externalTypeAliases) {
+        const values = definitions.flatMap((definition) => this.getTypeParameters(definition).map((parameter) => ({
+            definition,
+            parameter,
+        })));
+        const moduleBindings = new Set([
+            ...definitions.map((definition) => this.getDefinitionName(definition, names)),
+            ...externalTypeAliases.values(),
+        ]);
+        for (const definition of definitions) {
+            for (const runtimeType of this.getRuntimePrimitiveTypes(definition)) {
+                moduleBindings.add(runtimeType);
+            }
+        }
+        const reservedNamesByDefinition = new Map(definitions.map((definition) => [
+            this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name),
+            moduleBindings,
+        ]));
+        const resolved = this.resolveCollisionSafeNames(values, ({ parameter }) => this.safeTypeName(parameter.name ?? `T${parameter.internedStringIndex}`), ({ definition }) => this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name), "_", reservedNamesByDefinition);
+        return new Map(values.map((value) => [
+            this.getTypeParameterKey(value.definition, value.parameter.internedStringIndex),
+            resolved.get(value),
+        ]));
+    }
+    getDefinitionTypeParameters(definition, typeParameterNames) {
+        return this.getTypeParameters(definition).map((parameter) => this.getTypeParameterName(definition, parameter, typeParameterNames));
+    }
+    getTypeParameterName(definition, parameter, typeParameterNames) {
+        const name = typeParameterNames.get(this.getTypeParameterKey(definition, parameter.internedStringIndex));
+        if (name === undefined) {
+            throw new Error(`Cannot resolve generic parameter '${parameter.internedStringIndex}' for '${definition.identity.name}'`);
+        }
+        return name;
+    }
+    getTypeParameters(definition) {
+        return definition.kind === "enum" ? [] : definition.typeParameters ?? [];
+    }
+    getTypeParameterKey(definition, internedStringIndex) {
+        return `${this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name)}\u0000type-parameter\u0000${internedStringIndex}`;
+    }
+    resolveModulesOrThrow(definitions) {
+        const identities = new Map();
+        for (const definition of definitions) {
+            const key = this.getModuleKey(definition.identity.packageId, definition.identity.moduleName);
+            identities.set(key, {
+                packageId: definition.identity.packageId,
+                moduleName: definition.identity.moduleName,
+            });
+        }
+        return new Map([...identities.entries()].map(([key, identity]) => [
+            key,
+            {
+                ...identity,
+                key,
+                path: `${this.nameResolver.getNamedTypeModuleDirectoryPath(identity.packageId, identity.moduleName)}/types.ts`,
+                namespaceAlias: this.nameResolver.getNamedTypeModuleNamespaceAlias(identity.packageId, identity.moduleName),
+            },
+        ]));
+    }
+    resolveDefinitionNamesOrThrow(definitions, reservedNamesByModule) {
+        const values = definitions.map((definition) => [
+            this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name),
+            definition,
+        ]);
+        const duplicate = new Set();
+        for (const [key] of values) {
+            if (duplicate.has(key)) {
+                throw new Error(`Cannot emit duplicate named DAML type '${key.replaceAll("\u0000", ":")}'`);
+            }
+            duplicate.add(key);
+        }
+        const resolvedNames = this.resolveCollisionSafeNames(values, ([, definition]) => this.safeTypeName(definition.identity.name), ([, definition]) => this.getModuleKey(definition.identity.packageId, definition.identity.moduleName), "_", reservedNamesByModule);
+        return new Map(values.map((value) => [
+            value[0],
+            resolvedNames.get(value),
+        ]));
+    }
+    resolveCollisionSafeNames(values, getBaseName, getScope, collisionSeparator = "_", reservedNamesByScope = new Map()) {
+        const counts = new Map();
+        for (const value of values) {
+            const key = `${getScope(value)}\u0000${getBaseName(value)}`;
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        }
+        const names = new Map();
+        const allocated = new Map();
+        for (const value of [...values].sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))) {
+            const scope = getScope(value);
+            const baseName = getBaseName(value);
+            const groupKey = `${scope}\u0000${baseName}`;
+            const suffix = counts.get(groupKey) === 1 ? "" : `${collisionSeparator}${this.shortHash(JSON.stringify(value))}`;
+            const baseCandidate = `${baseName}${suffix}`;
+            const used = allocated.get(scope) ?? new Set(reservedNamesByScope.get(scope));
+            let candidate = used.has(baseCandidate) ? `${baseCandidate}Type` : baseCandidate;
+            let escalation = 2;
+            while (used.has(candidate)) {
+                candidate = `${baseCandidate}_${escalation}`;
+                escalation += 1;
+            }
+            used.add(candidate);
+            allocated.set(scope, used);
+            names.set(value, candidate);
+        }
+        return names;
+    }
+    getReservedModuleExports(templateFiles) {
+        const exportsByModule = new Map();
+        for (const file of templateFiles) {
+            const binding = file.binding;
+            const moduleKey = this.getModuleKeyFromTemplateIdentity(binding.templateIdentityKey);
+            const exports = exportsByModule.get(moduleKey) ?? new Set();
+            exports.add(binding.className);
+            exports.add(binding.createFieldsTypeName);
+            exports.add(binding.createdEventTypeName);
+            for (const choice of binding.choices) {
+                exports.add(choice.choiceTypeName);
+                exports.add(choice.exercisedEventTypeName);
+            }
+            exportsByModule.set(moduleKey, exports);
+        }
+        return exportsByModule;
+    }
+    getReservedRuntimeBindings(definitions) {
+        const bindings = new Set([
+            "DamlDate",
+            "DamlNumeric",
+            "DamlParty",
+            "DamlTimestamp",
+            "DamlUnit",
+        ]);
+        return new Map([...new Set(definitions.map((definition) => this.getModuleKey(definition.identity.packageId, definition.identity.moduleName)))].map((moduleKey) => [
+            moduleKey,
+            bindings,
+        ]));
+    }
+    mergeReservedNames(...reservations) {
+        const merged = new Map();
+        for (const reservation of reservations) {
+            for (const [moduleKey, names] of reservation) {
+                const mergedNames = merged.get(moduleKey) ?? new Set();
+                for (const name of names) {
+                    mergedNames.add(name);
+                }
+                merged.set(moduleKey, mergedNames);
+            }
+        }
+        return merged;
+    }
+    resolveFieldPropertyNames(definitions) {
+        const fields = definitions.flatMap((definition) => definition.kind === "record"
+            ? definition.fields.map((field, index) => ({ definition, field, index }))
+            : []);
+        const counts = new Map();
+        for (const item of fields) {
+            const baseName = this.safePropertyName(item.field.propertyName);
+            const groupKey = `${this.getDefinitionKey(item.definition.identity.packageId, item.definition.identity.moduleName, item.definition.identity.name)}\u0000${baseName}`;
+            counts.set(groupKey, (counts.get(groupKey) ?? 0) + 1);
+        }
+        const names = new Map();
+        for (const item of [...fields].sort((left, right) => this.getFieldKey(left.definition, left.index).localeCompare(this.getFieldKey(right.definition, right.index)))) {
+            const baseName = this.safePropertyName(item.field.propertyName);
+            const definitionKey = this.getDefinitionKey(item.definition.identity.packageId, item.definition.identity.moduleName, item.definition.identity.name);
+            const groupKey = `${definitionKey}\u0000${baseName}`;
+            const name = counts.get(groupKey) === 1
+                ? baseName
+                : `${baseName}_${this.shortHash(this.getFieldKey(item.definition, item.index))}`;
+            names.set(this.getFieldKey(item.definition, item.index), name);
+        }
+        return names;
+    }
+    getFieldPropertyName(definition, index, names) {
+        const name = names.get(this.getFieldKey(definition, index));
+        if (name === undefined) {
+            throw new Error(`Cannot resolve property name for named DAML type '${definition.identity.name}'`);
+        }
+        return name;
+    }
+    getFieldKey(definition, index) {
+        return `${this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name)}\u0000field\u0000${index}`;
+    }
+    safePropertyName(value) {
+        const name = value.replace(/[^A-Za-z0-9_$]/g, "_");
+        if (name.length === 0) {
+            return "field";
+        }
+        return /^[0-9]/.test(name) ? `_${name}` : name;
+    }
+    getModuleKeyFromTemplateIdentity(identityKey) {
+        const [packageId, moduleName] = identityKey.split("\u0000");
+        return this.getModuleKey(packageId, moduleName);
+    }
+    relativeFilePath(fromPath, toPath, moduleImportStyle) {
+        return relative_module_specifier_js_1.RelativeModuleSpecifier.fromPaths(fromPath, toPath, moduleImportStyle);
+    }
+    getDefinitionName(definition, names) {
+        return this.getNamedReferenceTypeName(definition.identity, names);
+    }
+    getNamedReferenceTypeName(identity, names) {
+        const name = names.get(this.getDefinitionKey(identity.packageId, identity.moduleName, identity.name));
+        if (name === undefined) {
+            throw new Error(`Cannot emit unresolved named DAML type '${identity.name}'`);
+        }
+        return name;
+    }
+    getModuleKey(packageId, moduleName) {
+        return `${packageId}\u0000${moduleName}`;
+    }
+    getDefinitionKey(packageId, moduleName, name) {
+        return `${this.getModuleKey(packageId, moduleName)}\u0000${name}`;
+    }
+    safeTypeName(value) {
+        const normalized = value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9]+/g, " ").trim();
+        if (normalized.length === 0) {
+            throw new Error("Cannot normalize an empty DAML identifier");
+        }
+        const name = normalized.split(/\s+/).map((segment) => `${segment[0].toUpperCase()}${segment.slice(1)}`).join("");
+        return /^[0-9]/.test(name) ? `_${name}` : name;
+    }
+    *getRuntimePrimitiveTypes(type) {
+        switch (type.kind) {
+            case "primitive": {
+                const name = this.getPrimitiveTypeName(type.builtinType);
+                if (name.startsWith("Daml")) {
+                    yield name;
+                }
+                return;
+            }
+            case "contractId": return;
+            case "optional":
+            case "list":
+                yield* this.getRuntimePrimitiveTypes(type.element);
+                return;
+            case "textMap":
+                yield* this.getRuntimePrimitiveTypes(type.value);
+                return;
+            case "genMap":
+                yield* this.getRuntimePrimitiveTypes(type.key);
+                yield* this.getRuntimePrimitiveTypes(type.value);
+                return;
+            case "record":
+                for (const field of type.fields) {
+                    yield* this.getRuntimePrimitiveTypes(field.type);
+                }
+                return;
+            case "variant":
+                for (const constructor of type.constructors) {
+                    yield* this.getRuntimePrimitiveTypes(constructor.payload);
+                }
+                return;
+            case "enum":
+            case "typeVariable":
+                return;
+            case "namedReference":
+                for (const typeArgument of type.typeArguments ?? []) {
+                    yield* this.getRuntimePrimitiveTypes(typeArgument);
+                }
+                return;
+        }
+    }
+    shortHash(value) {
+        let hash = 0x811c9dc5;
+        for (const character of value) {
+            hash ^= character.charCodeAt(0);
+            hash = Math.imul(hash, 0x01000193);
+        }
+        return (hash >>> 0).toString(36).padStart(6, "0").slice(-6);
+    }
+}
+exports.NamedTypeEmitter = NamedTypeEmitter;

package/dist/cjs/daml-interface/emission/project-emitter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectEmitter = void 0;
+const generated_daml_interface_project_js_1 = require("../emission-model/generated-daml-interface-project.js");
+const generated_spec_emitter_js_1 = require("./generated-spec-emitter.js");
+const named_type_emitter_js_1 = require("./named-type-emitter.js");
+const registry_emitter_js_1 = require("./registry-emitter.js");
+const support_file_emitter_js_1 = require("./support-file-emitter.js");
+const template_binding_emitter_js_1 = require("./template-binding-emitter.js");
+const type_script_name_resolver_js_1 = require("./type-script-name-resolver.js");
+const daml_module_import_style_js_1 = require("./daml-module-import-style.js");
+class ProjectEmitter {
+    nameResolver;
+    templateBindingEmitter;
+    supportFileEmitter;
+    registryEmitter;
+    namedTypeEmitter;
+    constructor(nameResolver = new type_script_name_resolver_js_1.TypeScriptNameResolver(), templateBindingEmitter = new template_binding_emitter_js_1.TemplateBindingEmitter(nameResolver), supportFileEmitter = new support_file_emitter_js_1.SupportFileEmitter(), registryEmitter = new registry_emitter_js_1.RegistryEmitter(), namedTypeEmitter = new named_type_emitter_js_1.NamedTypeEmitter(nameResolver)) {
+        this.nameResolver = nameResolver;
+        this.templateBindingEmitter = templateBindingEmitter;
+        this.supportFileEmitter = supportFileEmitter;
+        this.registryEmitter = registryEmitter;
+        this.namedTypeEmitter = namedTypeEmitter;
+        void this.nameResolver;
+        void this.templateBindingEmitter;
+        void this.namedTypeEmitter;
+        void this.supportFileEmitter;
+        void this.registryEmitter;
+    }
+    /** Emits the complete in-memory DAML interface project from analyzed templates. */
+    emitProject(analysis, moduleImportStyle = daml_module_import_style_js_1.DamlModuleImportStyles.esm) {
+        this.namedTypeEmitter.prepareProjectOrThrow(analysis.templates, analysis.typeDefinitions, analysis.packageMetadata);
+        const templateBindingFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateBindingFile(template));
+        const namedTypeFiles = this.namedTypeEmitter.emitPreparedNamedTypeFiles(analysis.typeDefinitions, templateBindingFiles, moduleImportStyle);
+        const templateFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateFile(template, namedTypeFiles, moduleImportStyle));
+        const supportFiles = [
+            ...this.supportFileEmitter.emitSupportFiles(analysis, namedTypeFiles),
+            ...this.supportFileEmitter.emitNamespaceFiles(new generated_daml_interface_project_js_1.GeneratedDamlInterfaceProject({ templateFiles, namedTypeFiles }), moduleImportStyle),
+        ];
+        const baseProject = new generated_daml_interface_project_js_1.GeneratedDamlInterfaceProject({
+            templateFiles,
+            namedTypeFiles,
+            supportFiles,
+        });
+        const registryFile = this.registryEmitter.emitRegistry(baseProject, moduleImportStyle);
+        const projectWithRegistry = new generated_daml_interface_project_js_1.GeneratedDamlInterfaceProject({
+            templateFiles,
+            namedTypeFiles,
+            supportFiles,
+            registryFile,
+        });
+        const indexFile = this.supportFileEmitter.emitIndexFile(projectWithRegistry, moduleImportStyle);
+        const project = new generated_daml_interface_project_js_1.GeneratedDamlInterfaceProject({
+            templateFiles,
+            namedTypeFiles,
+            supportFiles,
+            registryFile,
+            indexFile,
+        });
+        return new generated_daml_interface_project_js_1.GeneratedDamlInterfaceProject({
+            templateFiles,
+            namedTypeFiles,
+            supportFiles,
+            registryFile,
+            indexFile,
+            specFiles: generated_spec_emitter_js_1.GeneratedSpecEmitter.emitSpecFiles(project, analysis, moduleImportStyle),
+        });
+    }
+}
+exports.ProjectEmitter = ProjectEmitter;

package/dist/cjs/daml-interface/emission/registry-emitter.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryEmitter = void 0;
+const generated_registry_file_js_1 = require("../emission-model/generated-registry-file.js");
+const relative_module_specifier_js_1 = require("./relative-module-specifier.js");
+class RegistryEmitter {
+    /** Emits a registry that dispatches created and exercised events by template id. */
+    emitRegistry(project, moduleImportStyle) {
+        const importLines = project.templateFiles.map((file) => {
+            const modulePath = relative_module_specifier_js_1.RelativeModuleSpecifier.fromPaths("generated/registry.ts", file.path, moduleImportStyle);
+            return `import { ${file.binding.className} } from "${modulePath}";`;
+        });
+        const createdCases = this.emitCases(project, "fromCreatedEvent");
+        const exercisedCases = this.emitCases(project, "fromExercisedEvent");
+        return new generated_registry_file_js_1.GeneratedRegistryFile({
+            path: "generated/registry.ts",
+            contents: [
+                'import { DamlEventSourceNormalizer, DamlMaterializationError } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+                'import type { DamlCreatedEventSource, DamlExercisedEventSource } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+                ...importLines,
+                "",
+                "export class GeneratedRegistry {",
+                "    public static fromCreatedEvent(event: DamlCreatedEventSource): unknown {",
+                "        const normalized = DamlEventSourceNormalizer.normalizeCreated(event);",
+                "        switch (`${normalized.metadata.templateId.packageId}:${normalized.metadata.templateId.moduleName}:${normalized.metadata.templateId.entityName}`) {",
+                ...createdCases,
+                "            default:",
+                "                throw new DamlMaterializationError(\"template ID\", \"no generated template binding matches the created event\");",
+                "        }",
+                "    }",
+                "",
+                "    public static fromExercisedEvent(event: DamlExercisedEventSource): unknown {",
+                "        const normalized = DamlEventSourceNormalizer.normalizeExercised(event);",
+                "        switch (`${normalized.metadata.templateId.packageId}:${normalized.metadata.templateId.moduleName}:${normalized.metadata.templateId.entityName}`) {",
+                ...exercisedCases,
+                "            default:",
+                "                throw new DamlMaterializationError(\"template ID\", \"no generated template binding matches the exercised event\");",
+                "        }",
+                "    }",
+                "}",
+                "",
+            ].join("\n"),
+        });
+    }
+    emitCases(project, methodName) {
+        return project.templateFiles.map((file) => `            case "${file.binding.templateIdLiteral}":\n                return ${file.binding.className}.${methodName}(event);`);
+    }
+}
+exports.RegistryEmitter = RegistryEmitter;

package/dist/cjs/daml-interface/emission/relative-module-specifier.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelativeModuleSpecifier = void 0;
+const daml_module_import_style_js_1 = require("./daml-module-import-style.js");
+/** Formats generated-project relative module specifiers for the selected execution mode. */
+class RelativeModuleSpecifier {
+    constructor() { }
+    /** Resolves a generated TypeScript target path relative to a generated source path. */
+    static fromPaths(fromPath, toPath, moduleImportStyle = daml_module_import_style_js_1.DamlModuleImportStyles.esm) {
+        const from = fromPath.split("/").slice(0, -1);
+        const to = toPath.replace(/\.ts$/, "").split("/");
+        while (from[0] === to[0] && from.length > 0) {
+            from.shift();
+            to.shift();
+        }
+        const relativePath = from.map(() => "..").concat(to).join("/") || ".";
+        const prefixedPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        return moduleImportStyle === daml_module_import_style_js_1.DamlModuleImportStyles.esm ? `${prefixedPath}.js` : prefixedPath;
+    }
+}
+exports.RelativeModuleSpecifier = RelativeModuleSpecifier;