ballerina-core 1.0.84 → 1.0.85

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.84",
+  "version": "1.0.85",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/forms/domains/parser/domains/built-ins/state.ts

@@ -61,7 +61,7 @@ export type ApiConverters<
 > = { [key in keyof T]: ApiConverter<T[key]["type"]> } & BuiltInApiConverters;
 
 export type VerifiedRawUnionCase = {
-  case: string;
+  caseName: string;
   fields: Record<string, any>;
 };
 
@@ -71,7 +71,7 @@ export const VerifiedRawUnionCase = {
       return (
         typeof value == "object" &&
         "caseName" in value &&
-        typeof value.case == "string" &&
+        typeof value.caseName == "string" &&
         "fields" in value &&
         typeof value.fields == "object"
       );
@@ -331,10 +331,10 @@ export const fromAPIRawValue =
           `union expected but got ${JSON.stringify(raw)}`,
         );
       }
-      const caseType = t.args.get(raw.case);
+      const caseType = t.args.get(raw.caseName);
       if (caseType == undefined) {
         return ValueOrErrors.Default.throwOne(
-          `union case ${raw.case} not found in type ${JSON.stringify(t)}`,
+          `union case ${raw.caseName} not found in type ${JSON.stringify(t)}`,
         );
       }
       return fromAPIRawValue(
@@ -371,7 +371,7 @@ export const fromAPIRawValue =
           );
         }
         return ValueOrErrors.Default.return(
-          PredicateValue.Default.unionCase(result.case, fields),
+          PredicateValue.Default.unionCase(result.caseName, fields),
         );
       });
     }
@@ -595,7 +595,7 @@ export const toAPIRawValue =
       }
       return ValueOrErrors.Operations.Return(
         converters[t.kind].toAPIRawValue([
-          { case: raw.caseName, fields: raw.fields },
+          { caseName: raw.caseName, fields: raw.fields },
           formState.modifiedByUser,
         ]),
       );

package/src/forms/domains/parser/domains/predicates/state.ts

@@ -179,7 +179,11 @@ export type PredicateValue =
 
 export type ExprLambda = { kind: "lambda"; parameter: string; body: Expr };
 export type ExprMatchCase = { kind: "matchCase"; operands: Expr[] };
-export type ExprCase = { kind: "caseName"; caseName: string; handler: ExprLambda };
+export type ExprCase = {
+  kind: "caseName";
+  caseName: string;
+  handler: ExprLambda;
+};
 export type ExprFieldLookup = { kind: "fieldLookup"; operands: [Expr, string] };
 export type ExprIsCase = { kind: "isCase"; operands: [Expr, string] };
 export type ExprBinaryOperator = {

package/src/forms/domains/parser/domains/types/state.ts

@@ -41,7 +41,7 @@ export const RawType = {
     _.fun == "Union" &&
     Array.isArray(_["args"]) &&
     _["args"].every(
-      (__) => typeof __ == "object" && "caseName"ame" in __ && "fields" in __,
+      (__) => typeof __ == "object" && "caseName" in __ && "fields" in __,
     ),
 };
 export type RawApplicationType<T> = {
@@ -113,8 +113,10 @@ export const RawFieldType = {
     RawFieldType.isApplication(_) &&
     _.fun == "MultiSelection" &&
     _.args.length == 1,
-  isUnionCase: <T>(_: RawFieldType<T>): _ is { case: string; fields: object } =>
-    typeof _ == "object" && "caseName"ame" in _ && "fields" in _,
+  isUnionCase: <T>(
+    _: RawFieldType<T>,
+  ): _ is { caseName: string; fields: object } =>
+    typeof _ == "object" && "caseName" in _ && "fields" in _,
   isUnion: <T>(
     _: RawFieldType<T>,
   ): _ is { fun: "Union"; args: Array<{ case: string; fields: object }> } =>
@@ -124,7 +126,7 @@ export const RawFieldType = {
     _.fun == "Union" &&
     _.args.length > 0 &&
     _.args.every(
-      (__) => typeof __ == "object" && "caseName"ame" in __ && "fields" in __,
+      (__) => typeof __ == "object" && "caseName" in __ && "fields" in __,
     ),
   isForm: <T>(_: RawFieldType<T>): _ is { fields: Object } =>
     typeof _ == "object" && "fields" in _ && isObject(_.fields),
@@ -323,13 +325,13 @@ export const ParsedType = {
       }
       if (RawFieldType.isUnionCase(rawFieldType)) {
         return ParsedType.Operations.ParseRawFieldType(
-          rawFieldType.case,
+          rawFieldType.caseName,
           rawFieldType.fields,
           types,
           injectedPrimitives,
         ).Then((parsedFields) =>
           ValueOrErrors.Default.return(
-            ParsedType.Default.unionCase(rawFieldType.case, parsedFields),
+            ParsedType.Default.unionCase(rawFieldType.caseName, parsedFields),
           ),
         );
       }
@@ -351,7 +353,10 @@ export const ParsedType = {
                 injectedPrimitives,
               ).Then((parsedFields) =>
                 ValueOrErrors.Default.return(
-                  ParsedType.Default.unionCase(unionCase.case, parsedFields),
+                  ParsedType.Default.unionCase(
+                    unionCase.caseName,
+                    parsedFields,
+                  ),
                 ),
               );
             }),