@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.29

package/dist/daml-lf/model/lf-2-model-mapper.js

@@ -3,7 +3,7 @@ import { DamlLfDecodeException } from "../errors/daml-lf-decode.exception.js";
 import { DamlLfBuiltinType } from "./daml-lf-builtin-type.js";
 import { DamlLfChoice } from "./daml-lf-choice.js";
 import { DamlLfChoiceParameter } from "./daml-lf-choice-parameter.js";
-import { DamlLfDataType } from "./daml-lf-data-type.js";
+import { DamlLfDataType, } from "./daml-lf-data-type.js";
 import { DamlLfExpression } from "./daml-lf-expression.js";
 import { DamlLfField } from "./daml-lf-field.js";
 import { DamlLfModule } from "./daml-lf-module.js";
@@ -43,6 +43,12 @@ export class Lf2ModelMapper {
                 ...(lhs.typeConReference === undefined
                     ? {}
                     : { typeConReference: lhs.typeConReference }),
+                ...(lhs.typeVariable === undefined
+                    ? {}
+                    : { typeVariable: lhs.typeVariable }),
+                ...(lhs.diagnosticForall === undefined
+                    ? {}
+                    : { diagnosticForall: lhs.diagnosticForall }),
                 typeArguments: numericScale === undefined
                     ? [
                         ...lhs.typeArguments,
@@ -52,7 +58,18 @@ export class Lf2ModelMapper {
             });
         }
         if (rawType?.sum.oneofKind === "forall") {
-            return Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.forall.body);
+            return new DamlLfType({
+                diagnosticForall: {
+                    typeParameters: rawType.sum.forall.vars.map((parameter) => Lf2ModelMapper.mapTypeParameter(rawPackage, parameter)),
+                    body: Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.forall.body),
+                },
+            });
+        }
+        else if (rawType?.sum.oneofKind === "var") {
+            return new DamlLfType({
+                typeVariable: Lf2ModelMapper.mapTypeVariableReference(rawPackage, rawType.sum.var.varInternedStr),
+                typeArguments: rawType.sum.var.args.map((item) => Lf2ModelMapper.mapType(currentPackageId, rawPackage, item)),
+            });
         }
         if (rawType?.sum.oneofKind === "con") {
             return new DamlLfType({
@@ -79,6 +96,53 @@ export class Lf2ModelMapper {
             builtinType: DamlLfBuiltinType.unknown,
         });
     }
+    static mapTypeParameter(rawPackage, rawParameter) {
+        const name = Lf2ModelMapper.resolveInternedStringOrUndefined(rawPackage.internedStrings, rawParameter.varInternedStr);
+        return {
+            ...(name === undefined ? {} : { name }),
+            internedStringIndex: rawParameter.varInternedStr,
+            kind: Lf2ModelMapper.mapTypeParameterKind(rawPackage, rawParameter.kind),
+        };
+    }
+    static mapTypeVariableReference(rawPackage, internedStringIndex) {
+        const name = Lf2ModelMapper.resolveInternedStringOrUndefined(rawPackage.internedStrings, internedStringIndex);
+        return {
+            ...(name === undefined ? {} : { name }),
+            internedStringIndex,
+        };
+    }
+    static mapTypeParameterKind(rawPackage, rawKind, visitedInternedKindIndices = new Set()) {
+        if (rawKind?.sum.oneofKind === "star") {
+            return { kind: "star" };
+        }
+        else if (rawKind?.sum.oneofKind === "nat") {
+            return { kind: "nat" };
+        }
+        else if (rawKind?.sum.oneofKind === "arrow") {
+            return {
+                kind: "arrow",
+                parameters: rawKind.sum.arrow.params.map((parameter) => Lf2ModelMapper.mapTypeParameterKind(rawPackage, parameter, visitedInternedKindIndices)),
+                result: Lf2ModelMapper.mapTypeParameterKind(rawPackage, rawKind.sum.arrow.result, visitedInternedKindIndices),
+            };
+        }
+        if (rawKind?.sum.oneofKind !== "internedKind") {
+            return { kind: "unknown" };
+        }
+        const internedKindIndex = rawKind.sum.internedKind;
+        if (visitedInternedKindIndices.has(internedKindIndex)) {
+            return {
+                kind: "unknown",
+                internedKindIndex,
+            };
+        }
+        const internedKind = rawPackage.internedKinds[internedKindIndex];
+        return internedKind === undefined
+            ? {
+                kind: "unknown",
+                internedKindIndex,
+            }
+            : Lf2ModelMapper.mapTypeParameterKind(rawPackage, internedKind, new Set([...visitedInternedKindIndices, internedKindIndex]));
+    }
     static mapBuiltinType(builtinType) {
         switch (builtinType) {
             case BuiltinType.UNIT:
@@ -169,6 +233,7 @@ export class Lf2ModelMapper {
         return new DamlLfDataType({
             name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawDataType.nameInternedDname),
             definition,
+            typeParameters: rawDataType.params.map((parameter) => Lf2ModelMapper.mapTypeParameter(rawPackage, parameter)),
         });
     }
     static mapTemplateOrThrow(packageId, moduleName, rawTemplate, rawPackage, dataTypes) {
@@ -648,6 +713,9 @@ export class Lf2ModelMapper {
         }
         return internedStrings[index];
     }
+    static resolveInternedStringOrUndefined(internedStrings, index) {
+        return index === undefined ? undefined : internedStrings[index];
+    }
     static resolveInternedDottedName(internedStrings, internedDottedNames, index) {
         if (index === undefined || internedDottedNames[index] === undefined) {
             throw new DamlLfDecodeException("daml lf package references a missing interned dotted name");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.28",
+    "version": "0.1.29",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",