@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/daml-lf/container/dar-source-file-entry.js

@@ -0,0 +1,8 @@
+export class DarSourceFileEntry {
+    path;
+    content;
+    constructor(init) {
+        this.path = init.path;
+        this.content = init.content;
+    }
+}

package/dist/daml-lf/daml-lf-compilation.d.ts

@@ -1,6 +1,8 @@
 import { DamlLfChoice } from "./model/daml-lf-choice.js";
+import { DamlLfModule } from "./model/daml-lf-module.js";
 import { DamlLfTemplate } from "./model/daml-lf-template.js";
 import { DamlLfTemplateId } from "./model/daml-lf-template-id.js";
+import { DamlLfValueDefinition } from "./model/daml-lf-value-definition.js";
 import { ModuleReference } from "./model/module-reference.js";
 import { TypeConReference } from "./model/type-con-reference.js";
 import { DamlLfSemanticModel } from "./semantics/daml-lf-semantic-model.js";
@@ -12,11 +14,20 @@ export declare class DamlLfCompilation {
     private readonly moduleSymbols;
     private readonly typeSymbols;
     private readonly templates;
+    private readonly valueDefinitions;
+    private readonly valueDefinitionIdentities;
     private constructor();
     static createOrThrow(workspace: DamlLfWorkspace): DamlLfCompilation;
     getModuleSymbolOrThrow(reference: ModuleReference): ModuleSymbol;
     getTypeSymbolOrThrow(reference: TypeConReference): TypeSymbol;
     createSemanticModel(): DamlLfSemanticModel;
+    getValueDefinitionOrThrow(packageId: string, moduleName: string, definitionName: string): DamlLfValueDefinition;
+    getModuleOrThrow(packageId: string, moduleName: string): DamlLfModule;
+    getValueDefinitionIdentityOrThrow(definition: DamlLfValueDefinition): {
+        packageId: string;
+        moduleName: string;
+        definitionName: string;
+    };
     getTemplates(): readonly DamlLfTemplate[];
     getTemplateChoicesOrThrow(templateId: DamlLfTemplateId): readonly DamlLfChoice[];
     private buildIndexes;
@@ -24,6 +35,7 @@ export declare class DamlLfCompilation {
     private validateTypeOrThrow;
     private static createModuleKey;
     private static createTypeKey;
+    private static createDefinitionKey;
     private getTemplateOrThrow;
     private static createTemplateKey;
 }

package/dist/daml-lf/daml-lf-compilation.js

@@ -3,6 +3,7 @@ import { DamlLfSemanticException } from "./errors/daml-lf-semantic.exception.js"
 import { DamlLfDataType } from "./model/daml-lf-data-type.js";
 import { DamlLfTemplate } from "./model/daml-lf-template.js";
 import { DamlLfValueDefinition } from "./model/daml-lf-value-definition.js";
+import { ModuleReference } from "./model/module-reference.js";
 import { DamlLfSemanticModel } from "./semantics/daml-lf-semantic-model.js";
 import { ModuleSymbol } from "./symbols/module-symbol.js";
 import { TypeSymbol } from "./symbols/type-symbol.js";
@@ -11,6 +12,8 @@ export class DamlLfCompilation {
     moduleSymbols = new Map();
     typeSymbols = new Map();
     templates = new Map();
+    valueDefinitions = new Map();
+    valueDefinitionIdentities = new Map();
     constructor(workspace) {
         this.workspace = workspace;
         void this.workspace;
@@ -38,6 +41,26 @@ export class DamlLfCompilation {
     createSemanticModel() {
         return new DamlLfSemanticModel(this);
     }
+    getValueDefinitionOrThrow(packageId, moduleName, definitionName) {
+        const definition = this.valueDefinitions.get(DamlLfCompilation.createDefinitionKey(packageId, moduleName, definitionName));
+        if (definition === undefined) {
+            throw new DamlLfResolutionException(`could not resolve value definition '${definitionName}' in module '${moduleName}'`);
+        }
+        return definition;
+    }
+    getModuleOrThrow(packageId, moduleName) {
+        return this.getModuleSymbolOrThrow(new ModuleReference({
+            packageId,
+            moduleName,
+        })).module;
+    }
+    getValueDefinitionIdentityOrThrow(definition) {
+        const identity = this.valueDefinitionIdentities.get(definition);
+        if (identity === undefined) {
+            throw new DamlLfResolutionException(`could not resolve identity for value definition '${definition.name}'`);
+        }
+        return identity;
+    }
     getTemplates() {
         return [...this.templates.values()];
     }
@@ -58,6 +81,15 @@ export class DamlLfCompilation {
                             definition,
                         }));
                     }
+                    if (definition instanceof DamlLfValueDefinition) {
+                        const identity = {
+                            packageId: pkg.packageId,
+                            moduleName: module.name,
+                            definitionName: definition.name,
+                        };
+                        this.valueDefinitions.set(DamlLfCompilation.createDefinitionKey(identity.packageId, identity.moduleName, identity.definitionName), definition);
+                        this.valueDefinitionIdentities.set(definition, identity);
+                    }
                     if (definition instanceof DamlLfTemplate) {
                         this.templates.set(DamlLfCompilation.createTemplateKey(definition.templateId), definition);
                     }
@@ -104,6 +136,9 @@ export class DamlLfCompilation {
     static createTypeKey(packageId, moduleName, name) {
         return `${packageId}::${moduleName}::${name}`;
     }
+    static createDefinitionKey(packageId, moduleName, definitionName) {
+        return `${packageId}::${moduleName}::${definitionName}`;
+    }
     getTemplateOrThrow(templateId) {
         const template = this.templates.get(DamlLfCompilation.createTemplateKey(templateId));
         if (template === undefined) {

package/dist/daml-lf/index.d.ts

@@ -6,13 +6,24 @@ export { DamlLfVersionNotSupportedException } from "./errors/daml-lf-version-not
 export { DamlLfCompilation } from "./daml-lf-compilation.js";
 export { DamlLfPackageLoader, DamlLfPackageLoadResult } from "./daml-lf-package-loader.js";
 export { DamlLfWorkspace } from "./daml-lf-workspace.js";
+export { DarArchiveEntry } from "./container/dar-archive-entry.js";
 export { DarArchiveLoader } from "./container/dar-archive-loader.js";
+export { DarSourceBundle } from "./container/dar-source-bundle.js";
+export { DarSourceBundleLoader } from "./container/dar-source-bundle-loader.js";
+export { DarSourceFileEntry } from "./container/dar-source-file-entry.js";
+export { DamlLfLanguageVersion } from "./decoding/daml-lf-language-version.js";
 export { DamlLfBuiltinDispatch } from "./interpreter/daml-lf-builtin-dispatch.js";
+export { DamlLfEvaluator } from "./interpreter/daml-lf-evaluator.js";
 export { DamlLfInterpreterScaffold } from "./interpreter/daml-lf-interpreter-scaffold.js";
+export { DamlLfLexicalScope } from "./interpreter/daml-lf-lexical-scope.js";
+export { DamlLfRuntimeFrame } from "./interpreter/daml-lf-runtime-frame.js";
+export { DamlLfStepKind } from "./interpreter/daml-lf-step-kind.js";
+export { IDamlLfTraceSink, IDamlLfTraceStep, } from "./interpreter/daml-lf-trace-sink.interface.js";
 export { DamlLfBuiltinType } from "./model/daml-lf-builtin-type.js";
 export { DamlLfChoice } from "./model/daml-lf-choice.js";
 export { DamlLfChoiceParameter } from "./model/daml-lf-choice-parameter.js";
 export { DamlLfDataType } from "./model/daml-lf-data-type.js";
+export { DamlLfExpression } from "./model/daml-lf-expression.js";
 export { DamlLfField } from "./model/daml-lf-field.js";
 export { DamlLfModule } from "./model/daml-lf-module.js";
 export { DamlLfNodeKind } from "./model/daml-lf-node-kind.js";

package/dist/daml-lf/index.js

@@ -6,13 +6,23 @@ export { DamlLfVersionNotSupportedException } from "./errors/daml-lf-version-not
 export { DamlLfCompilation } from "./daml-lf-compilation.js";
 export { DamlLfPackageLoader, DamlLfPackageLoadResult } from "./daml-lf-package-loader.js";
 export { DamlLfWorkspace } from "./daml-lf-workspace.js";
+export { DarArchiveEntry } from "./container/dar-archive-entry.js";
 export { DarArchiveLoader } from "./container/dar-archive-loader.js";
+export { DarSourceBundle } from "./container/dar-source-bundle.js";
+export { DarSourceBundleLoader } from "./container/dar-source-bundle-loader.js";
+export { DarSourceFileEntry } from "./container/dar-source-file-entry.js";
+export { DamlLfLanguageVersion } from "./decoding/daml-lf-language-version.js";
 export { DamlLfBuiltinDispatch } from "./interpreter/daml-lf-builtin-dispatch.js";
+export { DamlLfEvaluator } from "./interpreter/daml-lf-evaluator.js";
 export { DamlLfInterpreterScaffold } from "./interpreter/daml-lf-interpreter-scaffold.js";
+export { DamlLfLexicalScope } from "./interpreter/daml-lf-lexical-scope.js";
+export { DamlLfRuntimeFrame } from "./interpreter/daml-lf-runtime-frame.js";
+export { DamlLfStepKind } from "./interpreter/daml-lf-step-kind.js";
 export { DamlLfBuiltinType } from "./model/daml-lf-builtin-type.js";
 export { DamlLfChoice } from "./model/daml-lf-choice.js";
 export { DamlLfChoiceParameter } from "./model/daml-lf-choice-parameter.js";
 export { DamlLfDataType } from "./model/daml-lf-data-type.js";
+export { DamlLfExpression } from "./model/daml-lf-expression.js";
 export { DamlLfField } from "./model/daml-lf-field.js";
 export { DamlLfModule } from "./model/daml-lf-module.js";
 export { DamlLfNodeKind } from "./model/daml-lf-node-kind.js";

package/dist/daml-lf/interpreter/daml-lf-builtin-dispatch.d.ts

@@ -1,2 +1,45 @@
+import { IDamlLfRuntimeValue } from "./daml-lf-runtime-value.js";
+interface IBuiltinRuntimeValue extends IDamlLfRuntimeValue {
+    readonly kind: "builtin";
+    readonly builtinFunction: string;
+    readonly appliedArguments: readonly IDamlLfRuntimeValue[];
+}
 export declare class DamlLfBuiltinDispatch {
+    applyOrThrow(builtin: IBuiltinRuntimeValue, argumentValues: readonly IDamlLfRuntimeValue[]): IDamlLfRuntimeValue;
+    private areEqual;
+    private readInt64;
+    private compareValues;
+    private readText;
+    private readPartyLike;
+    private readTextLike;
+    private readStringLikeOrUndefined;
+    private readContractIdLike;
+    private readExactDecimal;
+    private tryReadExactDecimal;
+    private parseExactDecimal;
+    private addExactDecimals;
+    private subtractExactDecimals;
+    private multiplyExactDecimals;
+    private divideExactDecimals;
+    private compareExactDecimals;
+    private normalizeExactDecimal;
+    private quantizeExactDecimal;
+    private shiftExactDecimal;
+    private quantizeQuotientToScale;
+    private roundHalfEvenQuotient;
+    private createExactDecimalFromScaledSignificand;
+    private formatExactDecimal;
+    private formatExactNumeric;
+    private truncateExactDecimalToInt64;
+    private readNumericScaleWitnessOrThrow;
+    private assertNumericBoundsOrThrow;
+    private pow10;
+    private readTextList;
+    private readTextMap;
+    private readGenMap;
+    private unwrapValue;
+    private hydrateValue;
+    private insertGenMapEntry;
+    private isNumericCompatible;
 }
+export {};