ballerina-core 1.0.197 → 1.0.198

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/types/state.js

@@ -1,777 +0,0 @@
-import { List, Map } from "immutable";
-import { ValueOrErrors } from "../../../../../../../../collections/domains/valueOrErrors/state";
-import { DispatchGenericTypes, MapRepo } from "../../../../../../../../../main";
-export const DispatchisString = (_) => typeof _ == "string";
-export const DispatchIsObject = (_) => typeof _ == "object";
-export const DispatchIsGenericType = (_) =>
-  _ && DispatchGenericTypes.includes(_);
-export const DispatchHasFun = (_) =>
-  DispatchIsObject(_) && "fun" in _ && DispatchisString(_.fun);
-export const DispatchHasArgs = (_) =>
-  DispatchIsObject(_) && "args" in _ && Array.isArray(_.args);
-export const DispatchPrimitiveTypeNames = [
-  "unit",
-  "guid", //resolves to string
-  "string",
-  "number",
-  "boolean",
-  "Date",
-  "base64File",
-  "secret",
-];
-export const SerializedType = {
-  isExtendedType: (type) =>
-    typeof type == "object" &&
-    "extends" in type &&
-    Array.isArray(type.extends) &&
-    type.extends.length > 0 &&
-    type.extends.every(DispatchisString),
-  hasFields: (type) => typeof type == "object" && "fields" in type,
-  isPrimitive: (_, injectedPrimitives) =>
-    Boolean(
-      DispatchPrimitiveTypeNames.some((__) => _ == __) ||
-        (injectedPrimitives === null || injectedPrimitives === void 0
-          ? void 0
-          : injectedPrimitives.has(_)),
-    ),
-  isApplication: (_) =>
-    DispatchHasFun(_) && DispatchIsGenericType(_.fun) && DispatchHasArgs(_),
-  isLookup: (_, forms) => DispatchisString(_) && forms.has(_),
-  isList: (_) =>
-    SerializedType.isApplication(_) && _.fun == "List" && _.args.length == 1,
-  isMap: (_) =>
-    SerializedType.isApplication(_) && _.fun == "Map" && _.args.length == 2,
-  isSum: (_) =>
-    SerializedType.isApplication(_) && _.fun == "Sum" && _.args.length == 2,
-  isSumUnitDate: (_) => typeof _ == "string" && _ == "SumUnitDate",
-  isSingleSelection: (_) =>
-    SerializedType.isApplication(_) &&
-    _.fun == "SingleSelection" &&
-    _.args.length == 1,
-  isMultiSelection: (_) =>
-    SerializedType.isApplication(_) &&
-    _.fun == "MultiSelection" &&
-    _.args.length == 1,
-  isUnion: (_) =>
-    DispatchHasFun(_) &&
-    DispatchIsGenericType(_.fun) &&
-    DispatchHasArgs(_) &&
-    _.fun == "Union" &&
-    _.args.length > 0 &&
-    _.args.every(
-      (arg) =>
-        (DispatchIsObject(arg) && "caseName" in arg && !("fields" in arg)) ||
-        ("fields" in arg &&
-          (DispatchisString(arg.fields) || DispatchIsObject(arg.fields))),
-    ),
-  isTuple: (_) => SerializedType.isApplication(_) && _.fun == "Tuple",
-  isRecord: (_) =>
-    _ != null &&
-    typeof _ == "object" &&
-    "fields" in _ &&
-    (DispatchIsObject(_.fields) || DispatchisString(_.fields)),
-  isTable: (_) =>
-    SerializedType.isApplication(_) && _.fun == "Table" && _.args.length == 1,
-  isOption: (_) =>
-    typeof _ == "object" &&
-    "fun" in _ &&
-    _.fun == "Option" &&
-    "args" in _ &&
-    Array.isArray(_.args) &&
-    _.args.length == 1,
-  isUnit: (_) => _ == "unit",
-  isKeyOf: (_) =>
-    typeof _ == "object" &&
-    "fun" in _ &&
-    _.fun == "KeyOf" &&
-    "args" in _ &&
-    Array.isArray(_.args) &&
-    _.args.length == 1 &&
-    DispatchisString(_.args[0]),
-  isOne: (_) =>
-    SerializedType.isApplication(_) && _.fun == "One" && _.args.length == 1,
-  isReadOnly: (_) =>
-    SerializedType.isApplication(_) &&
-    _.fun == "ReadOnly" &&
-    _.args.length == 1,
-  isRecordFields: (_) =>
-    typeof _ == "object" && _ != null && !("fun" in _) && !("args" in _),
-};
-export const UnionType = {
-  SerializeToString: (serializedArgs) => {
-    return `[union; cases: {${serializedArgs.map((v, k) => `${k}: ${v}`).join(", ")}}]`;
-  },
-};
-export const RecordType = {
-  SerializeToString: (serializedFields) => {
-    return `[record; fields: {${serializedFields.map((v, k) => `${k}: ${v}`).join(", ")}}]`;
-  },
-};
-export const LookupType = {
-  SerializeToString: (name) => {
-    return `${name}`;
-  },
-};
-export const DispatchPrimitiveType = {
-  SerializeToString: (name) => {
-    return `[primitive; name: ${String(name)}]`;
-  },
-};
-export const SingleSelectionType = {
-  SerializeToString: (serializedArgs) => {
-    return `[singleSelection; args: [${serializedArgs.join(", ")}]]`;
-  },
-};
-export const MultiSelectionType = {
-  SerializeToString: (serializedArgs) => {
-    return `[multiSelection; args: [${serializedArgs.join(", ")}]]`;
-  },
-};
-export const ListType = {
-  SerializeToString: (serializedArgs) => {
-    return `[list; args: [${serializedArgs.join(", ")}]]`;
-  },
-};
-export const TupleType = {
-  SerializeToString: (serializedArgs) => {
-    return `[tuple; args: [${serializedArgs.join(", ")}]]`;
-  },
-};
-export const SumType = {
-  SerializeToString: (serializedArgs) => {
-    return `[sum; args: [${serializedArgs.join(", ")}]]`;
-  },
-};
-export const MapType = {
-  SerializeToString: (serializedArgs) => {
-    return `[map; args: [${serializedArgs.join(", ")}]]`;
-  },
-};
-export const TableType = {
-  SerializeToString: (serializedArg) => {
-    return `[table; arg: ${serializedArg}]`;
-  },
-};
-export const ReadOnlyType = {
-  SerializeToString: (serializedArg) => {
-    return `[readOnly; arg: ${serializedArg}]`;
-  },
-};
-export const OneType = {
-  SerializeToString: (serializedArg) => {
-    return `[one; arg: ${serializedArg}]`;
-  },
-};
-export const DispatchParsedType = {
-  Default: {
-    table: (arg) => ({
-      kind: "table",
-      arg,
-      asString: () => TableType.SerializeToString(arg.asString()),
-    }),
-    record: (fields) => ({
-      kind: "record",
-      fields,
-      asString: () =>
-        RecordType.SerializeToString(fields.map((v) => v.asString())),
-    }),
-    primitive: (name) => ({
-      kind: "primitive",
-      name,
-      asString: () => DispatchPrimitiveType.SerializeToString(name),
-    }),
-    singleSelection: (args) => ({
-      kind: "singleSelection",
-      args,
-      asString: () =>
-        SingleSelectionType.SerializeToString(args.map((v) => v.asString())),
-    }),
-    multiSelection: (args) => ({
-      kind: "multiSelection",
-      args,
-      asString: () =>
-        MultiSelectionType.SerializeToString(args.map((v) => v.asString())),
-    }),
-    list: (args) => ({
-      kind: "list",
-      args,
-      asString: () => ListType.SerializeToString(args.map((v) => v.asString())),
-    }),
-    tuple: (args) => ({
-      kind: "tuple",
-      args,
-      asString: () =>
-        TupleType.SerializeToString(args.map((v) => v.asString())),
-    }),
-    sum: (args) => ({
-      kind: "sum",
-      args,
-      asString: () => SumType.SerializeToString(args.map((v) => v.asString())),
-    }),
-    map: (args) => ({
-      kind: "map",
-      args,
-      asString: () => MapType.SerializeToString(args.map((v) => v.asString())),
-    }),
-    union: (args) => ({
-      kind: "union",
-      args,
-      asString: () =>
-        UnionType.SerializeToString(args.map((v) => v.asString())),
-    }),
-    readOnly: (arg) => ({
-      kind: "readOnly",
-      arg,
-      asString: () => ReadOnlyType.SerializeToString(arg.asString()),
-    }),
-    lookup: (name) => ({
-      kind: "lookup",
-      name,
-      asString: () => LookupType.SerializeToString(name),
-    }),
-    one: (arg) => ({
-      kind: "one",
-      arg,
-      asString: () => OneType.SerializeToString(arg.asString()),
-    }),
-  },
-  Operations: {
-    // We don't use this at the moment, if we need it, then we can fix
-    // Equals: <T>(
-    //   fst: DispatchParsedType<T>,
-    //   snd: DispatchParsedType<T>,
-    // ): boolean =>
-    //   fst.kind == "record" && snd.kind == "record"
-    //     ? fst.name == snd.name
-    //     : fst.kind == "table" && snd.kind == "table"
-    //       ? fst.name == snd.name
-    //       : fst.kind == "one" && snd.kind == "one"
-    //         ? fst.name == snd.name
-    //         : fst.kind == "lookup" && snd.kind == "lookup"
-    //           ? fst.name == snd.name
-    //           : fst.kind == "primitive" && snd.kind == "primitive"
-    //             ? fst.name == snd.name
-    //             : fst.kind == "list" && snd.kind == "list"
-    //               ? fst.name == snd.name
-    //               : fst.kind == "singleSelection" &&
-    //                   snd.kind == "singleSelection"
-    //                 ? fst.name == snd.name
-    //                 : fst.kind == "multiSelection" &&
-    //                     snd.kind == "multiSelection"
-    //                   ? fst.name == snd.name
-    //                   : fst.kind == "map" && snd.kind == "map"
-    //                     ? fst.name == snd.name
-    //                     : fst.kind == "sum" && snd.kind == "sum"
-    //                       ? fst.name == snd.name
-    //                       : fst.kind == "tuple" && snd.kind == "tuple"
-    //                         ? fst.name == snd.name &&
-    //                           fst.args.length == snd.args.length &&
-    //                           fst.args.every((v, i) =>
-    //                             DispatchParsedType.Operations.Equals(
-    //                               v,
-    //                               snd.args[i],
-    //                             ),
-    //                           )
-    //                         : 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: (rawType, typeNames, serializedTypes, alreadyParsedTypes) =>
-      (alreadyParsedTypes.has(rawType.args[0])
-        ? alreadyParsedTypes
-            .get(rawType.args[0])
-            .Then((parsedType) =>
-              ValueOrErrors.Default.return([parsedType, alreadyParsedTypes]),
-            )
-        : DispatchParsedType.Operations.ParseRawType(
-            rawType.args[0],
-            serializedTypes[rawType.args[0]],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-          )
-      )
-        .Then((parsingResult) =>
-          parsingResult[0].kind != "record"
-            ? ValueOrErrors.Default.throwOne(
-                `Error: ${JSON.stringify(parsingResult[0])} is not a record type`,
-              )
-            : ValueOrErrors.Default.return([
-                DispatchParsedType.Default.union(
-                  Map(
-                    parsingResult[0].fields
-                      .keySeq()
-                      .toArray()
-                      .map((key) => [
-                        key,
-                        DispatchParsedType.Default.record(Map()),
-                      ]),
-                  ),
-                ),
-                parsingResult[1],
-              ]),
-        )
-        .MapErrors((errors) =>
-          errors.map((error) => `${error}\n...When parsing keyOf type`),
-        ),
-    SerializeToString: (type) => {
-      switch (type.kind) {
-        case "primitive":
-          return DispatchPrimitiveType.SerializeToString(type.name);
-        case "record":
-          return RecordType.SerializeToString(
-            type.fields.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "table":
-          return TableType.SerializeToString(
-            DispatchParsedType.Operations.SerializeToString(type.arg),
-          );
-        case "one":
-          return OneType.SerializeToString(
-            DispatchParsedType.Operations.SerializeToString(type.arg),
-          );
-        case "singleSelection":
-          return SingleSelectionType.SerializeToString(
-            type.args.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "multiSelection":
-          return MultiSelectionType.SerializeToString(
-            type.args.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "list":
-          return ListType.SerializeToString(
-            type.args.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "tuple":
-          return TupleType.SerializeToString(
-            type.args.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "sum":
-          return SumType.SerializeToString(
-            type.args.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "map":
-          return MapType.SerializeToString(
-            type.args.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "union":
-          return UnionType.SerializeToString(
-            type.args.map((v) =>
-              DispatchParsedType.Operations.SerializeToString(v),
-            ),
-          );
-        case "lookup":
-          return LookupType.SerializeToString(type.name);
-        default:
-          throw new Error(`Unknown type: ${JSON.stringify(type)}`);
-      }
-    },
-    ParseRecord: (
-      typeName,
-      rawType,
-      typeNames,
-      serializedTypes,
-      alreadyParsedTypes,
-      injectedPrimitives,
-    ) =>
-      // will already been parsed if it was extended by another type which was already parsed
-      alreadyParsedTypes.has(typeName)
-        ? alreadyParsedTypes
-            .get(typeName)
-            .Then((parsedType) =>
-              parsedType.kind != "record"
-                ? ValueOrErrors.Default.throwOne(
-                    `Error: ${JSON.stringify(parsedType)} is not a record type`,
-                  )
-                : ValueOrErrors.Default.return([
-                    parsedType,
-                    alreadyParsedTypes,
-                  ]),
-            )
-        : !SerializedType.isRecord(rawType)
-          ? ValueOrErrors.Default.throwOne(
-              `Error: ${JSON.stringify(rawType)} is not a valid record`,
-            )
-          : (SerializedType.isExtendedType(rawType)
-              ? ValueOrErrors.Operations.All(
-                  List(
-                    rawType.extends.map((extendedTypeName) =>
-                      alreadyParsedTypes.has(extendedTypeName)
-                        ? alreadyParsedTypes
-                            .get(extendedTypeName)
-                            .Then((extendedType) =>
-                              extendedType.kind != "record"
-                                ? ValueOrErrors.Default.throwOne(
-                                    `Error: ${JSON.stringify(extendedType)} is not a record type`,
-                                  )
-                                : ValueOrErrors.Default.return([
-                                    extendedTypeName,
-                                    extendedType,
-                                  ]),
-                            )
-                        : serializedTypes[extendedTypeName] == undefined
-                          ? ValueOrErrors.Default.throwOne(
-                              `Error: cannot find extended type ${extendedTypeName} in types`,
-                            )
-                          : DispatchParsedType.Operations.ParseRawType(
-                              extendedTypeName,
-                              serializedTypes[extendedTypeName],
-                              typeNames,
-                              serializedTypes,
-                              alreadyParsedTypes,
-                              injectedPrimitives,
-                            ).Then((parsedType) =>
-                              parsedType[0].kind == "record"
-                                ? ValueOrErrors.Default.return([
-                                    extendedTypeName,
-                                    parsedType[0],
-                                  ])
-                                : ValueOrErrors.Default.throwOne(
-                                    `Error: ${JSON.stringify(parsedType[0])} is not a record type`,
-                                  ),
-                            ),
-                    ),
-                  ),
-                )
-                  .MapErrors((errors) =>
-                    errors.map(
-                      (error) => `${error}\n...When parsing extended types`,
-                    ),
-                  )
-                  .Then((parsedExtendedRecordTypes) =>
-                    ValueOrErrors.Default.return(
-                      parsedExtendedRecordTypes.reduce(
-                        (acc, type) => acc.set(type[0], type[1]),
-                        Map(),
-                      ),
-                    ),
-                  )
-              : ValueOrErrors.Default.return(Map())
-            ).Then((parsedExtendedRecordTypesMap) =>
-              ValueOrErrors.Operations.All(
-                List(
-                  Object.entries(rawType.fields).map(([fieldName, fieldType]) =>
-                    DispatchParsedType.Operations.ParseRawType(
-                      fieldName,
-                      fieldType,
-                      typeNames,
-                      serializedTypes,
-                      alreadyParsedTypes,
-                      injectedPrimitives,
-                    ).Then((parsedField) =>
-                      ValueOrErrors.Default.return([fieldName, parsedField]),
-                    ),
-                  ),
-                ),
-              )
-                .Then((parsedFields) =>
-                  ValueOrErrors.Default.return(
-                    Map(
-                      parsedFields.map(([fieldName, parsedField]) => [
-                        fieldName,
-                        parsedField[0],
-                      ]),
-                    ),
-                  ),
-                )
-                .Then((parsedFieldsMap) =>
-                  ValueOrErrors.Default.return(
-                    DispatchParsedType.Default.record(
-                      parsedFieldsMap.merge(
-                        parsedExtendedRecordTypesMap.reduce(
-                          (acc, type) => acc.merge(type.fields),
-                          Map(),
-                        ),
-                      ),
-                    ),
-                  ).Then((parsedRecord) =>
-                    ValueOrErrors.Default.return([
-                      parsedRecord,
-                      parsedExtendedRecordTypesMap.reduce(
-                        (acc, type, name) =>
-                          acc.set(name, ValueOrErrors.Default.return(type)),
-                        alreadyParsedTypes,
-                      ),
-                    ]),
-                  ),
-                ),
-            ),
-    ParseRawType: (
-      typeName,
-      rawType,
-      typeNames,
-      serializedTypes,
-      alreadyParsedTypes,
-      injectedPrimitives,
-    ) => {
-      const result = (() => {
-        if (SerializedType.isPrimitive(rawType, injectedPrimitives))
-          return ValueOrErrors.Default.return([
-            DispatchParsedType.Default.primitive(
-              rawType == "guid" ? "string" : rawType,
-            ),
-            alreadyParsedTypes,
-          ]);
-        if (SerializedType.isSingleSelection(rawType))
-          return DispatchParsedType.Operations.ParseRawType(
-            `SingleSelection:Element`,
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then((parsedArgs) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.singleSelection([parsedArgs[0]]),
-              alreadyParsedTypes,
-            ]),
-          );
-        if (SerializedType.isMultiSelection(rawType))
-          return DispatchParsedType.Operations.ParseRawType(
-            `MultiSelection:Element`,
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then((parsedArgs) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.multiSelection([parsedArgs[0]]),
-              alreadyParsedTypes,
-            ]),
-          );
-        if (SerializedType.isList(rawType))
-          return DispatchParsedType.Operations.ParseRawType(
-            `List:Element`,
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then((parsedArgs) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.list([parsedArgs[0]]),
-              alreadyParsedTypes,
-            ]),
-          );
-        if (SerializedType.isTuple(rawType))
-          return ValueOrErrors.Operations.All(
-            List(
-              rawType.args.map((arg, index) =>
-                DispatchParsedType.Operations.ParseRawType(
-                  `Tuple:Item ${index + 1}`,
-                  arg,
-                  typeNames,
-                  serializedTypes,
-                  alreadyParsedTypes,
-                  injectedPrimitives,
-                ),
-              ),
-            ),
-          ).Then((parsedArgs) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.tuple(
-                parsedArgs.map(([parsedArg]) => parsedArg).toArray(),
-              ),
-              alreadyParsedTypes,
-            ]),
-          );
-        if (SerializedType.isMap(rawType))
-          return DispatchParsedType.Operations.ParseRawType(
-            "Map:Key",
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then((parsedArgs0) =>
-            DispatchParsedType.Operations.ParseRawType(
-              "Map:Value",
-              rawType.args[1],
-              typeNames,
-              serializedTypes,
-              alreadyParsedTypes,
-              injectedPrimitives,
-            ).Then((parsedArgs1) =>
-              ValueOrErrors.Default.return([
-                DispatchParsedType.Default.map([
-                  parsedArgs0[0],
-                  parsedArgs1[0],
-                ]),
-                alreadyParsedTypes,
-              ]),
-            ),
-          );
-        if (SerializedType.isSum(rawType))
-          return DispatchParsedType.Operations.ParseRawType(
-            "Sum:Left",
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then((parsedArgs0) =>
-            DispatchParsedType.Operations.ParseRawType(
-              "Sum:Right",
-              rawType.args[1],
-              typeNames,
-              serializedTypes,
-              alreadyParsedTypes,
-              injectedPrimitives,
-            ).Then((parsedArgs1) =>
-              ValueOrErrors.Default.return([
-                DispatchParsedType.Default.sum([
-                  parsedArgs0[0],
-                  parsedArgs1[0],
-                ]),
-                alreadyParsedTypes,
-              ]),
-            ),
-          );
-        if (SerializedType.isRecord(rawType))
-          return DispatchParsedType.Operations.ParseRecord(
-            typeName,
-            rawType,
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          );
-        if (SerializedType.isTable(rawType)) {
-          return DispatchParsedType.Operations.ParseRawType(
-            "TableArg",
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then((parsedArg) =>
-            parsedArg[0].kind != "lookup"
-              ? ValueOrErrors.Default.throwOne(
-                  `Error: ${JSON.stringify(parsedArg[0])} is not a lookup type`,
-                )
-              : ValueOrErrors.Default.return([
-                  DispatchParsedType.Default.table(parsedArg[0]),
-                  alreadyParsedTypes,
-                ]),
-          );
-        }
-        if (SerializedType.isLookup(rawType, typeNames))
-          return ValueOrErrors.Default.return([
-            DispatchParsedType.Default.lookup(rawType),
-            alreadyParsedTypes,
-          ]);
-        if (SerializedType.isUnit(rawType)) {
-          return ValueOrErrors.Default.return([
-            DispatchParsedType.Default.primitive("unit"),
-            alreadyParsedTypes,
-          ]);
-        }
-        if (SerializedType.isUnion(rawType))
-          // for now we assume all union cases are lookup types
-          return ValueOrErrors.Operations.All(
-            List(
-              rawType.args.map((unionCase) =>
-                DispatchParsedType.Operations.ParseRawType(
-                  `Union:Case ${unionCase.caseName}`,
-                  unionCase.fields == undefined
-                    ? { fields: {} }
-                    : // we allow the record fields to be defined directly in the spec instead of
-                      // inside a fields key
-                      SerializedType.isRecordFields(unionCase.fields)
-                      ? { fields: unionCase.fields }
-                      : unionCase.fields,
-                  typeNames,
-                  serializedTypes,
-                  alreadyParsedTypes,
-                  injectedPrimitives,
-                ).Then((parsedType) =>
-                  ValueOrErrors.Default.return([
-                    unionCase.caseName,
-                    parsedType[0],
-                  ]),
-                ),
-              ),
-            ),
-          ).Then((parsedUnionCases) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.union(Map(parsedUnionCases)),
-              alreadyParsedTypes,
-            ]),
-          );
-        if (SerializedType.isOne(rawType))
-          return DispatchParsedType.Operations.ParseRawType(
-            "One:Element",
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then((parsedArg) =>
-            parsedArg[0].kind != "lookup"
-              ? ValueOrErrors.Default.throwOne(
-                  `one content type ${JSON.stringify(parsedArg[0])} is not a lookup type`,
-                )
-              : ValueOrErrors.Default.return([
-                  DispatchParsedType.Default.one(parsedArg[0]),
-                  alreadyParsedTypes,
-                ]),
-          );
-        if (SerializedType.isReadOnly(rawType))
-          return DispatchParsedType.Operations.ParseRawType(
-            "ReadOnly:Element",
-            rawType.args[0],
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-            injectedPrimitives,
-          ).Then(([parsedArg, _]) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.readOnly(parsedArg),
-              alreadyParsedTypes,
-            ]),
-          );
-        if (SerializedType.isKeyOf(rawType))
-          return DispatchParsedType.Operations.ParseRawKeyOf(
-            rawType,
-            typeNames,
-            serializedTypes,
-            alreadyParsedTypes,
-          );
-        return ValueOrErrors.Default.throwOne(
-          `Unrecognised type "${typeName}" : ${JSON.stringify(rawType)}`,
-        );
-      })();
-      return result.MapErrors((errors) =>
-        errors.map((error) => `${error}\n...When parsing type "${typeName}"`),
-      );
-    },
-    ResolveLookupType: (typeName, types) =>
-      MapRepo.Operations.tryFindWithError(
-        typeName,
-        types,
-        () => `cannot find lookup type ${typeName} in types`,
-      ),
-    AsResolvedType: (type, types) =>
-      type.kind == "lookup"
-        ? DispatchParsedType.Operations.ResolveLookupType(type.name, types)
-        : ValueOrErrors.Default.return(type),
-  },
-};
-//# sourceMappingURL=state.js.map