ballerina-core 1.0.213 → 1.0.215

package/bin/src/forms/domains/parser/domains/types/state.js

@@ -5,366 +5,181 @@ export const isString = (_) => typeof _ == "string";
 export const isObject = (_) => typeof _ == "object";
 export const isGenericType = (_) => _ && GenericTypes.includes(_);
 export const hasFun = (_) => isObject(_) && "fun" in _ && isString(_.fun);
-export const hasArgs = (_) =>
-  isObject(_) && "args" in _ && Array.isArray(_.args);
+export const hasArgs = (_) => isObject(_) && "args" in _ && Array.isArray(_.args);
 export const RawType = {
-  isMaybeExtendedType: (type) =>
-    "extends" in type &&
-    Array.isArray(type.extends) &&
-    type.extends.length == 1,
-  isExtendedType: (type) =>
-    "extends" in type &&
-    Array.isArray(type.extends) &&
-    type.extends.length == 1 &&
-    isString(type.extends[0]),
-  hasFields: (type) => "fields" in type,
-  isMaybeUnion: (_) =>
-    isObject(_) &&
-    "fun" in _ &&
-    "args" in _ &&
-    _.fun == "Union" &&
-    Array.isArray(_["args"]) &&
-    _["args"].every(
-      (__) => typeof __ == "object" && "caseName" in __ && "fields" in __,
-    ),
-  isKeyOf: (_) =>
-    typeof _ == "object" &&
-    "fun" in _ &&
-    _.fun == "KeyOf" &&
-    "args" in _ &&
-    Array.isArray(_.args) &&
-    _.args.length == 1 &&
-    isString(_.args[0]),
+    isMaybeExtendedType: (type) => "extends" in type &&
+        Array.isArray(type.extends) &&
+        type.extends.length == 1,
+    isExtendedType: (type) => "extends" in type &&
+        Array.isArray(type.extends) &&
+        type.extends.length == 1 &&
+        isString(type.extends[0]),
+    hasFields: (type) => "fields" in type,
+    isMaybeUnion: (_) => isObject(_) &&
+        "fun" in _ &&
+        "args" in _ &&
+        _.fun == "Union" &&
+        Array.isArray(_["args"]) &&
+        _["args"].every((__) => typeof __ == "object" && "caseName" in __ && "fields" in __),
+    isKeyOf: (_) => typeof _ == "object" &&
+        "fun" in _ &&
+        _.fun == "KeyOf" &&
+        "args" in _ &&
+        Array.isArray(_.args) &&
+        _.args.length == 1 &&
+        isString(_.args[0]),
 };
 export const RawFieldType = {
-  isMaybePrimitive: (_) => isString(_),
-  isPrimitive: (_, injectedPrimitives) =>
-    Boolean(
-      PrimitiveTypes.some((__) => _ == __) ||
-        (injectedPrimitives === null || injectedPrimitives === void 0
-          ? void 0
-          : injectedPrimitives.injectedPrimitives.has(_)),
-    ),
-  isMaybeApplication: (_) => isObject(_),
-  isApplication: (_) => hasFun(_) && isGenericType(_.fun) && hasArgs(_),
-  isMaybeLookup: (_) => isString(_),
-  isLookup: (_) => isString(_),
-  isList: (_) =>
-    RawFieldType.isApplication(_) && _.fun == "List" && _.args.length == 1,
-  isMap: (_) =>
-    RawFieldType.isApplication(_) && _.fun == "Map" && _.args.length == 2,
-  isSum: (_) =>
-    RawFieldType.isApplication(_) && _.fun == "Sum" && _.args.length == 2,
-  isSingleSelection: (_) =>
-    RawFieldType.isApplication(_) &&
-    _.fun == "SingleSelection" &&
-    _.args.length == 1,
-  isMultiSelection: (_) =>
-    RawFieldType.isApplication(_) &&
-    _.fun == "MultiSelection" &&
-    _.args.length == 1,
-  isUnionCase: (_) => typeof _ == "object" && "caseName" in _,
-  isUnion: (_) =>
-    hasFun(_) &&
-    isGenericType(_.fun) &&
-    hasArgs(_) &&
-    _.fun == "Union" &&
-    _.args.length > 0 &&
-    _.args.every((__) => typeof __ == "object" && "caseName" in __),
-  isTuple: (_) => RawFieldType.isApplication(_) && _.fun == "Tuple",
-  isRecord: (_) => typeof _ == "object" && "fields" in _ && isObject(_.fields),
-  isOption: (_) =>
-    typeof _ == "object" &&
-    "fun" in _ &&
-    _.fun == "Option" &&
-    "args" in _ &&
-    Array.isArray(_.args) &&
-    _.args.length == 1,
-  isUnit: (_) => _ == "unit",
-  isTable: (_) =>
-    RawFieldType.isApplication(_) && _.fun == "Table" && _.args.length == 1,
+    isMaybePrimitive: (_) => isString(_),
+    isPrimitive: (_, injectedPrimitives) => Boolean(PrimitiveTypes.some((__) => _ == __) ||
+        (injectedPrimitives === null || injectedPrimitives === void 0 ? void 0 : injectedPrimitives.injectedPrimitives.has(_))),
+    isMaybeApplication: (_) => isObject(_),
+    isApplication: (_) => hasFun(_) && isGenericType(_.fun) && hasArgs(_),
+    isMaybeLookup: (_) => isString(_),
+    isLookup: (_) => isString(_),
+    isList: (_) => RawFieldType.isApplication(_) && _.fun == "List" && _.args.length == 1,
+    isMap: (_) => RawFieldType.isApplication(_) && _.fun == "Map" && _.args.length == 2,
+    isSum: (_) => RawFieldType.isApplication(_) && _.fun == "Sum" && _.args.length == 2,
+    isSingleSelection: (_) => RawFieldType.isApplication(_) &&
+        _.fun == "SingleSelection" &&
+        _.args.length == 1,
+    isMultiSelection: (_) => RawFieldType.isApplication(_) &&
+        _.fun == "MultiSelection" &&
+        _.args.length == 1,
+    isUnionCase: (_) => typeof _ == "object" && "caseName" in _,
+    isUnion: (_) => hasFun(_) &&
+        isGenericType(_.fun) &&
+        hasArgs(_) &&
+        _.fun == "Union" &&
+        _.args.length > 0 &&
+        _.args.every((__) => typeof __ == "object" && "caseName" in __),
+    isTuple: (_) => RawFieldType.isApplication(_) && _.fun == "Tuple",
+    isRecord: (_) => typeof _ == "object" && "fields" in _ && isObject(_.fields),
+    isOption: (_) => typeof _ == "object" &&
+        "fun" in _ &&
+        _.fun == "Option" &&
+        "args" in _ &&
+        Array.isArray(_.args) &&
+        _.args.length == 1,
+    isUnit: (_) => _ == "unit",
+    isTable: (_) => RawFieldType.isApplication(_) && _.fun == "Table" && _.args.length == 1,
 };
 export const ParsedType = {
-  Default: {
-    unionCase: (name, fields) => ({ kind: "unionCase", name, fields }),
-    option: (value) => ({
-      kind: "option",
-      value,
-    }),
-    record: (value, fields) => ({
-      kind: "record",
-      value,
-      fields,
-    }),
-    primitive: (name) => ({
-      kind: "primitive",
-      value: name,
-    }),
-    application: (value, args) => ({ kind: "application", value, args }),
-    union: (args) => ({
-      kind: "union",
-      args,
-    }),
-    lookup: (name) => ({ kind: "lookup", name }),
-    table: (value, tableType) => ({
-      kind: "table",
-      value,
-      tableType,
-    }),
-  },
-  Operations: {
-    Equals: (fst, snd) =>
-      fst.kind == "record" && snd.kind == "record"
-        ? fst.value == snd.value
-        : fst.kind == "lookup" && snd.kind == "lookup"
-          ? fst.name == snd.name
-          : fst.kind == "primitive" && snd.kind == "primitive"
-            ? fst.value == snd.value
-            : fst.kind == "application" && snd.kind == "application"
-              ? fst.value == snd.value &&
-                fst.args.length == snd.args.length &&
-                fst.args.every((v, i) =>
-                  ParsedType.Operations.Equals(v, snd.args[i]),
-                )
-              : fst.kind == "option" && snd.kind == "option"
-                ? fst.value.kind == "option" &&
-                  snd.value.kind == "option" &&
-                  ParsedType.Operations.Equals(fst.value.value, snd.value.value)
-                : fst.kind == "union" && snd.kind == "union"
-                  ? fst.args.size == snd.args.size &&
-                    fst.args.every((v, i) => v.name == snd.args.get(i).name)
-                  : false,
-    ParseRawKeyOf: (fieldName, rawFieldType, types) => {
-      if (RawType.isKeyOf(rawFieldType)) {
-        const extendedType = types.get(rawFieldType.args[0]);
-        if (extendedType == undefined) {
-          return ValueOrErrors.Default.throwOne(
-            `Error: cannot find arg ${JSON.stringify(rawFieldType.args[0])} in types for key of ${fieldName}`,
-          );
-        }
-        if (!RawFieldType.isRecord(extendedType)) {
-          return ValueOrErrors.Default.throwOne(
-            `Error: arg for key of ${fieldName} is not a record`,
-          );
-        }
-        const fields = extendedType.fields;
-        if (!isMap(fields) || fields.size == 0) {
-          return ValueOrErrors.Default.throwOne(
-            `No fields found for ${rawFieldType.args[0]} when parsing key of ${fieldName}`,
-          );
-        }
-        const keys = fields.keySeq().toArray();
-        return ValueOrErrors.Default.return(
-          ParsedType.Default.union(
-            Map(
-              keys.map((key) => [
-                key,
-                ParsedType.Default.unionCase(
-                  key,
-                  ParsedType.Default.record(key, Map()),
-                ),
-              ]),
-            ),
-          ),
-        );
-      }
-      return ValueOrErrors.Default.throwOne(
-        `Error: ${JSON.stringify(rawFieldType)} is not a valid key of`,
-      );
+    Default: {
+        unionCase: (name, fields) => ({ kind: "unionCase", name, fields }),
+        option: (value) => ({
+            kind: "option",
+            value,
+        }),
+        record: (value, fields) => ({
+            kind: "record",
+            value,
+            fields,
+        }),
+        primitive: (name) => ({
+            kind: "primitive",
+            value: name,
+        }),
+        application: (value, args) => ({ kind: "application", value, args }),
+        union: (args) => ({
+            kind: "union",
+            args,
+        }),
+        lookup: (name) => ({ kind: "lookup", name }),
+        table: (value, tableType) => ({
+            kind: "table",
+            value,
+            tableType,
+        }),
     },
-    ParseRawFieldType: (fieldName, rawFieldType, types, injectedPrimitives) => {
-      if (RawFieldType.isPrimitive(rawFieldType, injectedPrimitives))
-        return ValueOrErrors.Default.return(
-          ParsedType.Default.primitive(
-            rawFieldType == "guid" ? "string" : rawFieldType,
-          ),
-        );
-      if (RawFieldType.isSingleSelection(rawFieldType))
-        return ParsedType.Operations.ParseRawFieldType(
-          fieldName,
-          rawFieldType.args[0],
-          types,
-          injectedPrimitives,
-        ).Then((parsedArgs) =>
-          ValueOrErrors.Default.return(
-            ParsedType.Default.application("SingleSelection", [parsedArgs]),
-          ),
-        );
-      if (RawFieldType.isMultiSelection(rawFieldType))
-        return ParsedType.Operations.ParseRawFieldType(
-          fieldName,
-          rawFieldType.args[0],
-          types,
-          injectedPrimitives,
-        ).Then((parsedArgs) =>
-          ValueOrErrors.Default.return(
-            ParsedType.Default.application("MultiSelection", [parsedArgs]),
-          ),
-        );
-      if (RawFieldType.isList(rawFieldType))
-        return ParsedType.Operations.ParseRawFieldType(
-          fieldName,
-          rawFieldType.args[0],
-          types,
-          injectedPrimitives,
-        ).Then((parsedArgs) =>
-          ValueOrErrors.Default.return(
-            ParsedType.Default.application("List", [parsedArgs]),
-          ),
-        );
-      if (RawFieldType.isTuple(rawFieldType))
-        return ValueOrErrors.Operations.All(
-          List(
-            rawFieldType.args.map((arg) =>
-              ParsedType.Operations.ParseRawFieldType(
-                fieldName,
-                arg,
-                types,
-                injectedPrimitives,
-              ),
-            ),
-          ),
-        ).Then((parsedArgs) =>
-          ValueOrErrors.Default.return(
-            ParsedType.Default.application("Tuple", parsedArgs.toArray()),
-          ),
-        );
-      if (RawFieldType.isOption(rawFieldType))
-        return ParsedType.Operations.ParseRawFieldType(
-          fieldName,
-          rawFieldType.args[0],
-          types,
-          injectedPrimitives,
-        ).Then((parsedArg) =>
-          ValueOrErrors.Default.return(ParsedType.Default.option(parsedArg)),
-        );
-      if (RawFieldType.isMap(rawFieldType))
-        return ParsedType.Operations.ParseRawFieldType(
-          fieldName,
-          rawFieldType.args[0],
-          types,
-          injectedPrimitives,
-        ).Then((parsedArgs0) =>
-          ParsedType.Operations.ParseRawFieldType(
-            fieldName,
-            rawFieldType.args[1],
-            types,
-            injectedPrimitives,
-          ).Then((parsedArgs1) =>
-            ValueOrErrors.Default.return(
-              ParsedType.Default.application("Map", [parsedArgs0, parsedArgs1]),
-            ),
-          ),
-        );
-      if (RawFieldType.isSum(rawFieldType))
-        return ParsedType.Operations.ParseRawFieldType(
-          fieldName,
-          rawFieldType.args[0],
-          types,
-          injectedPrimitives,
-        ).Then((parsedArgs0) =>
-          ParsedType.Operations.ParseRawFieldType(
-            fieldName,
-            rawFieldType.args[1],
-            types,
-            injectedPrimitives,
-          ).Then((parsedArgs1) =>
-            ValueOrErrors.Default.return(
-              ParsedType.Default.application("Sum", [parsedArgs0, parsedArgs1]),
-            ),
-          ),
-        );
-      if (RawFieldType.isRecord(rawFieldType)) {
-        return ValueOrErrors.Operations.All(
-          List(
-            Object.entries(rawFieldType.fields).map(([fieldName, fieldType]) =>
-              ParsedType.Operations.ParseRawFieldType(
-                fieldName,
-                fieldType,
-                types,
-                injectedPrimitives,
-              ).Then((parsedField) =>
-                ValueOrErrors.Default.return([fieldName, parsedField]),
-              ),
-            ),
-          ),
-        )
-          .Then((parsedFields) =>
-            ValueOrErrors.Default.return(
-              Map(
-                parsedFields.map(([fieldName, parsedField]) => [
-                  fieldName,
-                  parsedField,
-                ]),
-              ),
-            ),
-          )
-          .Then((parsedField) =>
-            ValueOrErrors.Default.return(
-              ParsedType.Default.record(fieldName, parsedField),
-            ),
-          );
-      }
-      if (RawFieldType.isUnion(rawFieldType)) {
-        return ValueOrErrors.Operations.All(
-          List(
-            rawFieldType.args.map((unionCase) => {
-              var _a;
-              if (!RawFieldType.isUnionCase(unionCase)) {
-                return ValueOrErrors.Default.throwOne(
-                  `Error: arg ${JSON.stringify(unionCase)} is not a valid union case`,
-                );
-              }
-              return ParsedType.Operations.ParseRawFieldType(
-                unionCase.caseName,
-                typeof unionCase.fields == "string"
-                  ? unionCase.fields
-                  : {
-                      fields:
-                        (_a = unionCase.fields) !== null && _a !== void 0
-                          ? _a
-                          : {},
-                    },
-                types,
-                injectedPrimitives,
-              ).Then((parsedFields) =>
-                ValueOrErrors.Default.return(
-                  ParsedType.Default.unionCase(
-                    unionCase.caseName,
-                    parsedFields,
-                  ),
-                ),
-              );
-            }),
-          ),
-        ).Then((parsedUnionCases) =>
-          ValueOrErrors.Default.return(
-            ParsedType.Default.union(
-              Map(parsedUnionCases.toArray().map((_) => [_.name, _])),
-            ),
-          ),
-        );
-      }
-      if (RawFieldType.isTable(rawFieldType)) {
-        return ValueOrErrors.Default.return(
-          ParsedType.Default.table(fieldName, rawFieldType.args[0]),
-        );
-      }
-      if (RawFieldType.isLookup(rawFieldType))
-        return ValueOrErrors.Default.return(
-          ParsedType.Default.lookup(rawFieldType),
-        );
-      if (RawFieldType.isUnit(rawFieldType)) {
-        return ValueOrErrors.Default.return(
-          ParsedType.Default.primitive("unit"),
-        );
-      }
-      return ValueOrErrors.Default.throw(
-        List([
-          `Invalid type ${JSON.stringify(rawFieldType)} for field ${JSON.stringify(fieldName)}`,
-        ]),
-      );
+    Operations: {
+        Equals: (fst, snd) => fst.kind == "record" && snd.kind == "record"
+            ? fst.value == snd.value
+            : fst.kind == "lookup" && snd.kind == "lookup"
+                ? fst.name == snd.name
+                : fst.kind == "primitive" && snd.kind == "primitive"
+                    ? fst.value == snd.value
+                    : fst.kind == "application" && snd.kind == "application"
+                        ? fst.value == snd.value &&
+                            fst.args.length == snd.args.length &&
+                            fst.args.every((v, i) => ParsedType.Operations.Equals(v, snd.args[i]))
+                        : fst.kind == "option" && snd.kind == "option"
+                            ? fst.value.kind == "option" &&
+                                snd.value.kind == "option" &&
+                                ParsedType.Operations.Equals(fst.value.value, snd.value.value)
+                            : fst.kind == "union" && snd.kind == "union"
+                                ? fst.args.size == snd.args.size &&
+                                    fst.args.every((v, i) => v.name == snd.args.get(i).name)
+                                : false,
+        ParseRawKeyOf: (fieldName, rawFieldType, types) => {
+            if (RawType.isKeyOf(rawFieldType)) {
+                const extendedType = types.get(rawFieldType.args[0]);
+                if (extendedType == undefined) {
+                    return ValueOrErrors.Default.throwOne(`Error: cannot find arg ${JSON.stringify(rawFieldType.args[0])} in types for key of ${fieldName}`);
+                }
+                if (!RawFieldType.isRecord(extendedType)) {
+                    return ValueOrErrors.Default.throwOne(`Error: arg for key of ${fieldName} is not a record`);
+                }
+                const fields = extendedType.fields;
+                if (!isMap(fields) || fields.size == 0) {
+                    return ValueOrErrors.Default.throwOne(`No fields found for ${rawFieldType.args[0]} when parsing key of ${fieldName}`);
+                }
+                const keys = fields.keySeq().toArray();
+                return ValueOrErrors.Default.return(ParsedType.Default.union(Map(keys.map((key) => [
+                    key,
+                    ParsedType.Default.unionCase(key, ParsedType.Default.record(key, Map())),
+                ]))));
+            }
+            return ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(rawFieldType)} is not a valid key of`);
+        },
+        ParseRawFieldType: (fieldName, rawFieldType, types, injectedPrimitives) => {
+            if (RawFieldType.isPrimitive(rawFieldType, injectedPrimitives))
+                return ValueOrErrors.Default.return(ParsedType.Default.primitive(rawFieldType == "guid" ? "string" : rawFieldType));
+            if (RawFieldType.isSingleSelection(rawFieldType))
+                return ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[0], types, injectedPrimitives).Then((parsedArgs) => ValueOrErrors.Default.return(ParsedType.Default.application("SingleSelection", [parsedArgs])));
+            if (RawFieldType.isMultiSelection(rawFieldType))
+                return ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[0], types, injectedPrimitives).Then((parsedArgs) => ValueOrErrors.Default.return(ParsedType.Default.application("MultiSelection", [parsedArgs])));
+            if (RawFieldType.isList(rawFieldType))
+                return ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[0], types, injectedPrimitives).Then((parsedArgs) => ValueOrErrors.Default.return(ParsedType.Default.application("List", [parsedArgs])));
+            if (RawFieldType.isTuple(rawFieldType))
+                return ValueOrErrors.Operations.All(List(rawFieldType.args.map((arg) => ParsedType.Operations.ParseRawFieldType(fieldName, arg, types, injectedPrimitives)))).Then((parsedArgs) => ValueOrErrors.Default.return(ParsedType.Default.application("Tuple", parsedArgs.toArray())));
+            if (RawFieldType.isOption(rawFieldType))
+                return ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[0], types, injectedPrimitives).Then((parsedArg) => ValueOrErrors.Default.return(ParsedType.Default.option(parsedArg)));
+            if (RawFieldType.isMap(rawFieldType))
+                return ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[0], types, injectedPrimitives).Then((parsedArgs0) => ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[1], types, injectedPrimitives).Then((parsedArgs1) => ValueOrErrors.Default.return(ParsedType.Default.application("Map", [parsedArgs0, parsedArgs1]))));
+            if (RawFieldType.isSum(rawFieldType))
+                return ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[0], types, injectedPrimitives).Then((parsedArgs0) => ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[1], types, injectedPrimitives).Then((parsedArgs1) => ValueOrErrors.Default.return(ParsedType.Default.application("Sum", [parsedArgs0, parsedArgs1]))));
+            if (RawFieldType.isRecord(rawFieldType)) {
+                return ValueOrErrors.Operations.All(List(Object.entries(rawFieldType.fields).map(([fieldName, fieldType]) => ParsedType.Operations.ParseRawFieldType(fieldName, fieldType, types, injectedPrimitives).Then((parsedField) => ValueOrErrors.Default.return([fieldName, parsedField])))))
+                    .Then((parsedFields) => ValueOrErrors.Default.return(Map(parsedFields.map(([fieldName, parsedField]) => [
+                    fieldName,
+                    parsedField,
+                ]))))
+                    .Then((parsedField) => ValueOrErrors.Default.return(ParsedType.Default.record(fieldName, parsedField)));
+            }
+            if (RawFieldType.isUnion(rawFieldType)) {
+                return ValueOrErrors.Operations.All(List(rawFieldType.args.map((unionCase) => {
+                    var _a;
+                    if (!RawFieldType.isUnionCase(unionCase)) {
+                        return ValueOrErrors.Default.throwOne(`Error: arg ${JSON.stringify(unionCase)} is not a valid union case`);
+                    }
+                    return ParsedType.Operations.ParseRawFieldType(unionCase.caseName, typeof unionCase.fields == "string"
+                        ? unionCase.fields
+                        : { fields: (_a = unionCase.fields) !== null && _a !== void 0 ? _a : {} }, types, injectedPrimitives).Then((parsedFields) => ValueOrErrors.Default.return(ParsedType.Default.unionCase(unionCase.caseName, parsedFields)));
+                }))).Then((parsedUnionCases) => ValueOrErrors.Default.return(ParsedType.Default.union(Map(parsedUnionCases.toArray().map((_) => [_.name, _])))));
+            }
+            if (RawFieldType.isTable(rawFieldType)) {
+                return ValueOrErrors.Default.return(ParsedType.Default.table(fieldName, rawFieldType.args[0]));
+            }
+            if (RawFieldType.isLookup(rawFieldType))
+                return ValueOrErrors.Default.return(ParsedType.Default.lookup(rawFieldType));
+            if (RawFieldType.isUnit(rawFieldType)) {
+                return ValueOrErrors.Default.return(ParsedType.Default.primitive("unit"));
+            }
+            return ValueOrErrors.Default.throw(List([
+                `Invalid type ${JSON.stringify(rawFieldType)} for field ${JSON.stringify(fieldName)}`,
+            ]));
+        },
     },
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map