ballerina-core 1.0.199 → 1.0.201

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

@@ -5,181 +5,366 @@ 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"
+  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 == "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)}`,
-            ]));
-        },
+            : 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