ballerina-core 1.0.205 → 1.0.206

package/bin/src/forms/domains/parser/domains/built-ins/state.js

@@ -0,0 +1,1000 @@
+import { Map, List, Set, OrderedMap } from "immutable";
+import {
+  CollectionReference,
+  EnumReference,
+} from "../../../collection/domains/reference/state";
+import {
+  BooleanFormState,
+  CommonFormState,
+  DateFormState,
+  NumberFormState,
+  PredicateValue,
+  replaceWith,
+  StringFormState,
+  Sum,
+  unit,
+  UnitFormState,
+  Base64FileFormState,
+  SecretFormState,
+  ListFieldState,
+  MapFieldState,
+  TupleFormState,
+  SumFormState,
+} from "../../../../../../main";
+import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
+const sortObjectKeys = (obj) =>
+  Object.keys(obj)
+    .sort()
+    .reduce((sortedObj, key) => {
+      sortedObj[key] = obj[key];
+      return sortedObj;
+    }, {});
+const simpleMapKeyToIdentifer = (key) => {
+  if (typeof key == "object") return JSON.stringify(sortObjectKeys(key));
+  return JSON.stringify(key);
+};
+export const PrimitiveTypes = [
+  "unit",
+  "guid", //resolves to string
+  "string",
+  "number",
+  "boolean",
+  "Date",
+  "base64File",
+  "secret",
+];
+export const GenericTypes = [
+  "SingleSelection",
+  "MultiSelection",
+  "List",
+  "Map",
+  "Union",
+  "Tuple",
+  "Option",
+  "Sum",
+  "KeyOf",
+  "Table",
+];
+export const builtInsFromFieldViews = (fieldViews) => {
+  const builtins = {
+    primitives: Map([
+      [
+        "unit",
+        {
+          renderers: Set(["unit"]),
+          defaultValue: PredicateValue.Default.unit(),
+          defaultState: UnitFormState.Default(),
+        },
+      ],
+      [
+        "string",
+        {
+          renderers: Set(["string"]),
+          defaultValue: PredicateValue.Default.string(),
+          defaultState: StringFormState.Default(),
+        },
+      ],
+      [
+        "number",
+        {
+          renderers: Set(["number"]),
+          defaultValue: PredicateValue.Default.number(),
+          defaultState: NumberFormState.Default(),
+        },
+      ],
+      [
+        "boolean",
+        {
+          renderers: Set(["boolean"]),
+          defaultValue: PredicateValue.Default.boolean(),
+          defaultState: BooleanFormState.Default(),
+        },
+      ],
+      [
+        "date",
+        {
+          renderers: Set(["date"]),
+          defaultValue: PredicateValue.Default.date(),
+          defaultState: DateFormState.Default(),
+        },
+      ],
+      [
+        "Date",
+        {
+          renderers: Set(["date"]),
+          defaultValue: PredicateValue.Default.date(),
+          defaultState: DateFormState.Default(),
+        },
+      ],
+      [
+        "base64File",
+        {
+          renderers: Set(["base64File"]),
+          defaultValue: PredicateValue.Default.string(),
+          defaultState: Base64FileFormState.Default(),
+        },
+      ],
+      [
+        "secret",
+        {
+          renderers: Set(["secret"]),
+          defaultValue: PredicateValue.Default.string(),
+          defaultState: SecretFormState.Default(),
+        },
+      ],
+    ]),
+    generics: Map([
+      [
+        "SingleSelection",
+        {
+          defaultValue: PredicateValue.Default.option(
+            false,
+            PredicateValue.Default.unit(),
+          ),
+        },
+      ],
+      [
+        "MultiSelection",
+        { defaultValue: PredicateValue.Default.record(OrderedMap()) },
+      ],
+      [
+        "List",
+        {
+          defaultValue: PredicateValue.Default.tuple(List()),
+          defaultState: ListFieldState().zero(),
+        },
+      ],
+      [
+        "Map",
+        {
+          defaultValue: PredicateValue.Default.tuple(List()),
+          defaultState: MapFieldState().zero(),
+        },
+      ],
+      [
+        "Tuple",
+        {
+          defaultValue: (values) => PredicateValue.Default.tuple(List(values)),
+          defaultState: (argStates) => TupleFormState().Default(argStates),
+        },
+      ],
+      [
+        "Sum",
+        {
+          defaultValue: (kind, value) =>
+            PredicateValue.Default.sum(
+              kind == "l" ? Sum.Default.left(value) : Sum.Default.right(value),
+            ),
+          defaultState: (left, right) =>
+            SumFormState().Default({ left, right }),
+        },
+      ],
+      [
+        "Union",
+        {
+          defaultValue: (fields) => PredicateValue.Default.record(fields),
+          // TODO : Union Renderer form
+          // defaultState: (fields: Map<string, any>) =>
+          //   UnionFormState().Default(fields),
+        },
+      ],
+    ]),
+    renderers: {
+      unit: Set(),
+      boolean: Set(),
+      date: Set(),
+      enumMultiSelection: Set(),
+      enumSingleSelection: Set(),
+      streamMultiSelection: Set(),
+      streamSingleSelection: Set(),
+      number: Set(),
+      string: Set(),
+      list: Set(),
+      tuple: Set(),
+      base64File: Set(),
+      secret: Set(),
+      map: Set(),
+      sum: Set(),
+    },
+  };
+  Object.keys(builtins.renderers).forEach((_categoryName) => {
+    const categoryName = _categoryName;
+    if (categoryName in fieldViews) {
+      Object.keys(fieldViews[categoryName]).forEach((viewName) => {
+        builtins.renderers[categoryName] =
+          builtins.renderers[categoryName].add(viewName);
+      });
+    }
+  });
+  return builtins;
+};
+export const defaultState = (types, builtIns, injectedPrimitives) => (t) => {
+  if (
+    t.kind == "union" ||
+    (t.kind == "application" &&
+      (t.value == "SingleSelection" || t.value == "MultiSelection"))
+  ) {
+    throw Error(
+      `t.kind: ${t.kind} ${t.kind == "application" ? ` t.value: ${t.value}` : ""} not currently supported by the defaultState function`,
+    );
+  }
+  if (t.kind == "primitive") {
+    const primitive = builtIns.primitives.get(t.value);
+    const injectedPrimitive =
+      injectedPrimitives === null || injectedPrimitives === void 0
+        ? void 0
+        : injectedPrimitives.injectedPrimitives.get(t.value);
+    if (primitive != undefined) return primitive.defaultState;
+    if (injectedPrimitive != undefined)
+      return {
+        commonFormState: CommonFormState.Default(),
+        customFormState: injectedPrimitive.defaultState,
+      };
+  }
+  if (t.kind == "application" && t.value == "Tuple") {
+    return builtIns.generics
+      .get("Tuple")
+      .defaultState(
+        t.args.map((_) => defaultState(types, builtIns, injectedPrimitives)(_)),
+      );
+  }
+  if (t.kind == "application" && t.value == "Sum") {
+    return builtIns.generics
+      .get("Sum")
+      .defaultState(
+        defaultState(types, builtIns, injectedPrimitives)(t.args[0]),
+        defaultState(types, builtIns, injectedPrimitives)(t.args[1]),
+      );
+  }
+  if (t.kind == "application") {
+    const generic = builtIns.generics.get(t.value);
+    if (generic) return generic.defaultState;
+  }
+  if (t.kind == "lookup")
+    return defaultState(types, builtIns, injectedPrimitives)(types.get(t.name));
+  throw Error(
+    `cannot find type ${JSON.stringify(t)} when resolving defaultValue`,
+  );
+};
+export const defaultValue = (types, builtIns, injectedPrimitives) => (t) => {
+  if (t.kind == "primitive") {
+    const primitive = builtIns.primitives.get(t.value);
+    const injectedPrimitive =
+      injectedPrimitives === null || injectedPrimitives === void 0
+        ? void 0
+        : injectedPrimitives.injectedPrimitives.get(t.value);
+    if (primitive != undefined) return primitive.defaultValue;
+    if (injectedPrimitive != undefined) return injectedPrimitive.defaultValue;
+  }
+  if (t.kind == "application" && t.value == "Tuple") {
+    return builtIns.generics
+      .get("Tuple")
+      .defaultValue(
+        t.args.map((_) => defaultValue(types, builtIns, injectedPrimitives)(_)),
+      );
+  }
+  if (t.kind == "application" && t.value == "Sum") {
+    return builtIns.generics
+      .get("Sum")
+      .defaultValue(
+        defaultValue(types, builtIns, injectedPrimitives)(t.args[0]),
+        defaultValue(types, builtIns, injectedPrimitives)(t.args[1]),
+      );
+  }
+  if (t.kind == "application") {
+    const generic = builtIns.generics.get(t.value);
+    if (generic) return generic.defaultValue;
+  }
+  if (t.kind == "lookup")
+    return defaultValue(types, builtIns, injectedPrimitives)(types.get(t.name));
+  if (t.kind == "record") {
+    let res = {};
+    t.fields.forEach((field, fieldName) => {
+      res[fieldName] = defaultValue(types, builtIns, injectedPrimitives)(field);
+    });
+    return PredicateValue.Default.record(OrderedMap(res));
+  }
+  if (t.kind == "table") {
+    let res = {};
+    const tableType = types.get(t.tableType);
+    if (tableType == undefined) {
+      throw Error(
+        `cannot find type ${t.tableType} when resolving defaultValue`,
+      );
+    }
+    if (tableType.kind != "record") {
+      throw Error(`tableType ${t.tableType} is not a record`);
+    }
+    tableType.fields.forEach((column, columnName) => {
+      res[columnName] = defaultValue(
+        types,
+        builtIns,
+        injectedPrimitives,
+      )(column);
+    });
+    return PredicateValue.Default.record(OrderedMap(res));
+  }
+  throw Error(
+    `cannot find type ${JSON.stringify(t)} when resolving defaultValue`,
+  );
+};
+export const fromAPIRawValue =
+  (t, types, builtIns, converters, injectedPrimitives) => (raw) => {
+    if (t.kind == "primitive") {
+      // unit is a special kind of primitive
+      if (t.value == "unit") {
+        return ValueOrErrors.Default.return(PredicateValue.Default.unit());
+      }
+      if (
+        !PredicateValue.Operations.IsPrimitive(raw) &&
+        !(injectedPrimitives === null || injectedPrimitives === void 0
+          ? void 0
+          : injectedPrimitives.injectedPrimitives.keySeq().contains(t.value))
+      ) {
+        return ValueOrErrors.Default.throwOne(
+          `primitive expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      return ValueOrErrors.Default.return(
+        converters[t.value].fromAPIRawValue(raw),
+      );
+    }
+    if (t.kind == "union") {
+      const result = converters[t.kind].fromAPIRawValue(raw);
+      const caseType = t.args.get(result.caseName);
+      if (caseType == undefined)
+        return ValueOrErrors.Default.throwOne(
+          `union case ${result.caseName} not found in type ${JSON.stringify(t)}`,
+        );
+      return fromAPIRawValue(
+        caseType.fields,
+        types,
+        builtIns,
+        converters,
+        injectedPrimitives,
+      )(result.fields).Then((fields) => {
+        return ValueOrErrors.Default.return(
+          PredicateValue.Default.unionCase(result.caseName, fields),
+        );
+      });
+    }
+    if (t.kind == "application") {
+      if (t.value == "SingleSelection") {
+        const result = converters[t.value].fromAPIRawValue(raw);
+        const isSome = result.kind == "l";
+        const value = isSome
+          ? PredicateValue.Default.record(OrderedMap(result.value))
+          : PredicateValue.Default.unit();
+        return ValueOrErrors.Default.return(
+          PredicateValue.Default.option(isSome, value),
+        );
+      }
+      if (t.value == "MultiSelection") {
+        const result = converters[t.value].fromAPIRawValue(raw);
+        const values = result.map((_) =>
+          PredicateValue.Default.record(OrderedMap(_)),
+        );
+        return ValueOrErrors.Default.return(
+          PredicateValue.Default.record(OrderedMap(values)),
+        );
+      }
+      if (t.value == "List") {
+        const result = converters[t.value].fromAPIRawValue(raw);
+        return ValueOrErrors.Operations.All(
+          result.map((_) =>
+            fromAPIRawValue(
+              t.args[0],
+              types,
+              builtIns,
+              converters,
+              injectedPrimitives,
+            )(_),
+          ),
+        ).Then((values) =>
+          ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
+        );
+      }
+      if (t.value == "Map" && t.args.length == 2) {
+        const result = converters[t.value].fromAPIRawValue(raw);
+        return ValueOrErrors.Operations.All(
+          List(
+            result.map((_) =>
+              fromAPIRawValue(
+                t.args[0],
+                types,
+                builtIns,
+                converters,
+                injectedPrimitives,
+              )(_[0]).Then((key) =>
+                fromAPIRawValue(
+                  t.args[1],
+                  types,
+                  builtIns,
+                  converters,
+                  injectedPrimitives,
+                )(_[1]).Then((value) =>
+                  ValueOrErrors.Default.return(
+                    PredicateValue.Default.tuple(List([key, value])),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ).Then((values) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.tuple(List(values)),
+          ),
+        );
+      }
+      if (t.value == "Tuple") {
+        const result = converters[t.value].fromAPIRawValue(raw);
+        return ValueOrErrors.Operations.All(
+          List(
+            result.map((_, index) =>
+              fromAPIRawValue(
+                t.args[index],
+                types,
+                builtIns,
+                converters,
+                injectedPrimitives,
+              )(_),
+            ),
+          ),
+        ).Then((values) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.tuple(List(values)),
+          ),
+        );
+      }
+      if (t.value === "Sum" && t.args.length === 2) {
+        const result = converters[t.value].fromAPIRawValue(raw);
+        return fromAPIRawValue(
+          result.kind == "l" ? t.args[0] : t.args[1],
+          types,
+          builtIns,
+          converters,
+          injectedPrimitives,
+        )(result.value).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.sum(
+              Sum.Updaters.map2(replaceWith(value), replaceWith(value))(result),
+            ),
+          ),
+        );
+      }
+    }
+    if (t.kind == "lookup")
+      return fromAPIRawValue(
+        types.get(t.name),
+        types,
+        builtIns,
+        converters,
+        injectedPrimitives,
+      )(raw);
+    if (t.kind == "record") {
+      if (typeof raw != "object") {
+        return ValueOrErrors.Default.throwOne(
+          `object expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      let result = Map();
+      let errors = List();
+      t.fields.forEach((fieldType, fieldName) => {
+        const fieldValue = raw[fieldName];
+        if (fieldValue !== null && fieldValue === undefined) {
+          return;
+        }
+        const parsedValue = fromAPIRawValue(
+          fieldType,
+          types,
+          builtIns,
+          converters,
+          injectedPrimitives,
+        )(fieldValue);
+        if (parsedValue.kind == "errors") {
+          errors = errors.concat(parsedValue.errors);
+        } else {
+          result = result.set(fieldName, parsedValue.value);
+        }
+      });
+      if (errors.size > 0) {
+        return ValueOrErrors.Default.throw(errors);
+      }
+      return ValueOrErrors.Default.return(
+        PredicateValue.Default.record(result),
+      );
+    }
+    if (t.kind == "table") {
+      const converted = converters["Table"].fromAPIRawValue(raw);
+      let result = Map();
+      let errors = List();
+      const tableType = types.get(t.tableType);
+      if (tableType == undefined) {
+        throw Error(
+          `cannot find type ${t.tableType} when resolving defaultValue`,
+        );
+      }
+      if (tableType.kind != "record") {
+        throw Error(`tableType ${t.tableType} is not a record`);
+      }
+      converted.data.forEach((row, rowIndex) => {
+        let rowResult = Map();
+        tableType.fields.forEach((fieldType, fieldName) => {
+          const fieldValue = row[fieldName];
+          if (fieldValue != null && fieldValue == undefined) {
+            return;
+          }
+          const parsedValue = fromAPIRawValue(
+            fieldType,
+            types,
+            builtIns,
+            converters,
+            injectedPrimitives,
+          )(fieldValue);
+          if (parsedValue.kind == "errors") {
+            errors = errors.concat(parsedValue.errors);
+          } else {
+            rowResult = rowResult.set(fieldName, parsedValue.value);
+          }
+        });
+        result = result.set(
+          rowIndex.toString(),
+          PredicateValue.Default.record(rowResult),
+        );
+      });
+      if (errors.size > 0) {
+        return ValueOrErrors.Default.throw(errors);
+      }
+      return ValueOrErrors.Default.return(
+        // PredicateValue.Default.record(result),
+        PredicateValue.Default.record(
+          OrderedMap([
+            ["data", PredicateValue.Default.record(result)],
+            ["hasMoreValues", converted.hasMoreValues],
+            ["to", converted.to],
+            ["from", converted.from],
+          ]),
+        ),
+      );
+    }
+    return ValueOrErrors.Default.throwOne(
+      `unsupported type ${JSON.stringify(t)} for raw: `,
+    );
+  };
+export const toAPIRawValue =
+  (t, types, builtIns, converters, injectedPrimitives) => (raw, formState) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (t.kind == "primitive") {
+      if (t.value == "unit") {
+        return ValueOrErrors.Default.return(unit);
+      }
+      return ValueOrErrors.Operations.Return(
+        converters[t.value].toAPIRawValue([
+          raw,
+          (_b =
+            (_a =
+              formState === null || formState === void 0
+                ? void 0
+                : formState.commonFormState) === null || _a === void 0
+              ? void 0
+              : _a.modifiedByUser) !== null && _b !== void 0
+            ? _b
+            : false,
+        ]),
+      );
+    }
+    if (t.kind == "union") {
+      if (!PredicateValue.Operations.IsRecord(raw)) {
+        return ValueOrErrors.Default.throwOne(
+          `Option expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      const caseName = raw.fields.get("caseName");
+      if (
+        caseName == undefined ||
+        !PredicateValue.Operations.IsString(caseName)
+      ) {
+        return ValueOrErrors.Default.throwOne(
+          `caseName expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      const fields = raw.fields.get("fields");
+      if (fields == undefined || !PredicateValue.Operations.IsRecord(fields)) {
+        return ValueOrErrors.Default.throwOne(
+          `fields expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      const rawUnionCase = {
+        caseName,
+        fields: fields.fields.toJS(),
+      };
+      return ValueOrErrors.Operations.Return(
+        converters["union"].toAPIRawValue([
+          rawUnionCase,
+          (_d =
+            (_c =
+              formState === null || formState === void 0
+                ? void 0
+                : formState.commonFormState) === null || _c === void 0
+              ? void 0
+              : _c.modifiedByUser) !== null && _d !== void 0
+            ? _d
+            : false,
+        ]),
+      );
+    }
+    if (t.kind == "application") {
+      if (t.value == "SingleSelection") {
+        if (!PredicateValue.Operations.IsOption(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Option expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        if (raw.isSome) {
+          if (!PredicateValue.Operations.IsRecord(raw.value)) {
+            return ValueOrErrors.Default.throwOne(
+              `Record expected but got ${JSON.stringify(raw.value)}`,
+            );
+          }
+          const rawValue = raw.value.fields.toJS();
+          if (
+            !CollectionReference.Operations.IsCollectionReference(rawValue) &&
+            !EnumReference.Operations.IsEnumReference(rawValue)
+          ) {
+            return ValueOrErrors.Default.throwOne(
+              `CollectionReference or EnumReference expected but got ${rawValue}`,
+            );
+          }
+          return ValueOrErrors.Operations.Return(
+            converters[t.value].toAPIRawValue([
+              Sum.Default.left(rawValue),
+              (_f =
+                (_e =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _e === void 0
+                  ? void 0
+                  : _e.modifiedByUser) !== null && _f !== void 0
+                ? _f
+                : false,
+            ]),
+          );
+        } else {
+          return ValueOrErrors.Operations.Return(
+            converters[t.value].toAPIRawValue([
+              Sum.Default.right("no selection"),
+              (_h =
+                (_g =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _g === void 0
+                  ? void 0
+                  : _g.modifiedByUser) !== null && _h !== void 0
+                ? _h
+                : false,
+            ]),
+          );
+        }
+      }
+      if (t.value == "MultiSelection") {
+        if (!PredicateValue.Operations.IsRecord(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Record expected but got multi selection of ${JSON.stringify(raw)}`,
+          );
+        }
+        const rawValue = raw.fields.map((value) => {
+          if (!PredicateValue.Operations.IsRecord(value)) {
+            return ValueOrErrors.Default.throwOne(
+              `Record expected but got ${JSON.stringify(value)}`,
+            );
+          }
+          const fieldsObject = value.fields.toJS();
+          if (
+            !CollectionReference.Operations.IsCollectionReference(
+              fieldsObject,
+            ) &&
+            !EnumReference.Operations.IsEnumReference(fieldsObject)
+          ) {
+            return ValueOrErrors.Default.throwOne(
+              `CollectionReference or EnumReference expected but got ${JSON.stringify(fieldsObject)}`,
+            );
+          }
+          return ValueOrErrors.Default.return(fieldsObject);
+        });
+        return ValueOrErrors.Operations.All(rawValue.valueSeq().toList()).Then(
+          (values) => {
+            var _a, _b;
+            return ValueOrErrors.Default.return(
+              converters["MultiSelection"].toAPIRawValue([
+                OrderedMap(
+                  values
+                    .map((v) => {
+                      if (
+                        CollectionReference.Operations.IsCollectionReference(v)
+                      ) {
+                        return [v.Id, v];
+                      }
+                      return [v.Value, v];
+                    })
+                    .toArray(),
+                ),
+                (_b =
+                  (_a =
+                    formState === null || formState === void 0
+                      ? void 0
+                      : formState.commonFormState) === null || _a === void 0
+                    ? void 0
+                    : _a.modifiedByUser) !== null && _b !== void 0
+                  ? _b
+                  : false,
+              ]),
+            );
+          },
+        );
+      }
+      if (t.value == "List") {
+        if (!PredicateValue.Operations.IsTuple(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Tuple expected but got list of${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Operations.All(
+          List(
+            raw.values.map((value, index) => {
+              var _a;
+              return toAPIRawValue(
+                t.args[0],
+                types,
+                builtIns,
+                converters,
+                injectedPrimitives,
+              )(
+                value,
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.elementFormStates) === null || _a === void 0
+                  ? void 0
+                  : _a.get(index),
+              );
+            }),
+          ),
+        ).Then((values) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["List"].toAPIRawValue([
+              values,
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.value == "Map") {
+        const keyValues = raw.values.map((keyValue, index) => {
+          var _a, _b;
+          return toAPIRawValue(
+            t.args[0],
+            types,
+            builtIns,
+            converters,
+            injectedPrimitives,
+          )(
+            keyValue.values.get(0),
+            (_b =
+              (_a =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.elementFormStates) === null || _a === void 0
+                ? void 0
+                : _a.get(index)) === null || _b === void 0
+              ? void 0
+              : _b.KeyFormState,
+          )
+            .Then((possiblyUndefinedKey) => {
+              if (
+                possiblyUndefinedKey == undefined ||
+                possiblyUndefinedKey == null ||
+                possiblyUndefinedKey == "" ||
+                (typeof possiblyUndefinedKey == "object" &&
+                  (Object.keys(possiblyUndefinedKey).length == 0 ||
+                    ("IsSome" in possiblyUndefinedKey &&
+                      !possiblyUndefinedKey.IsSome)))
+              ) {
+                return ValueOrErrors.Default.throwOne(
+                  `A mapped key is undefined for type ${JSON.stringify(t.args[0])}`,
+                );
+              } else {
+                return ValueOrErrors.Default.return(possiblyUndefinedKey);
+              }
+            })
+            .Then((key) => {
+              var _a;
+              return toAPIRawValue(
+                t.args[1],
+                types,
+                builtIns,
+                converters,
+                injectedPrimitives,
+              )(
+                keyValue.values.get(1),
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.elementFormStates.get(index)) === null ||
+                  _a === void 0
+                  ? void 0
+                  : _a.ValueFormState,
+              ).Then((value) => ValueOrErrors.Default.return([key, value]));
+            });
+        });
+        return ValueOrErrors.Operations.All(List(keyValues)).Then((values) => {
+          var _a;
+          if (
+            values.map((kv) => JSON.stringify(kv[0])).toSet().size !=
+            values.size
+          ) {
+            return ValueOrErrors.Default.throwOne(
+              "Keys in the map are not unique",
+            );
+          }
+          return ValueOrErrors.Operations.Return(
+            converters["Map"].toAPIRawValue([
+              values,
+              (_a = formState.modifiedByUser) !== null && _a !== void 0
+                ? _a
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.value === "Sum") {
+        if (!PredicateValue.Operations.IsSum(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Sum expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return toAPIRawValue(
+          raw.value.kind == "l" ? t.args[0] : t.args[1],
+          types,
+          builtIns,
+          converters,
+          injectedPrimitives,
+        )(
+          raw.value.value,
+          raw.value.kind == "l"
+            ? formState.customFormState.left
+            : formState.customFormState.right,
+        ).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["Sum"].toAPIRawValue([
+              raw.value.kind == "l"
+                ? Sum.Default.left(value)
+                : Sum.Default.right(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.value == "Tuple") {
+        if (!PredicateValue.Operations.IsTuple(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Tuple expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Operations.All(
+          List(
+            raw.values.map((value, index) => {
+              var _a;
+              return toAPIRawValue(
+                t.args[index],
+                types,
+                builtIns,
+                converters,
+                injectedPrimitives,
+              )(
+                value,
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.elementFormStates) === null || _a === void 0
+                  ? void 0
+                  : _a.get(index),
+              );
+            }),
+          ),
+        ).Then((values) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["Tuple"].toAPIRawValue([
+              values,
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+    }
+    if (t.kind == "lookup")
+      return toAPIRawValue(
+        types.get(t.name),
+        types,
+        builtIns,
+        converters,
+        injectedPrimitives,
+      )(raw, formState);
+    if (t.kind == "record") {
+      if (!PredicateValue.Operations.IsRecord(raw)) {
+        return ValueOrErrors.Default.throwOne(
+          `Record expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      const res = [];
+      t.fields.forEach((fieldType, fieldName) => {
+        var _a, _b;
+        // nullish coalescing operator on state used for extended type state, but this maybe should have its own kind
+        const rawField = raw.fields.get(fieldName);
+        if (rawField == undefined) {
+          return;
+        }
+        res.push([
+          fieldName,
+          toAPIRawValue(
+            fieldType,
+            types,
+            builtIns,
+            converters,
+            injectedPrimitives,
+          )(
+            raw.fields.get(fieldName),
+            (_b =
+              (_a =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.formFieldStates) === null || _a === void 0
+                ? void 0
+                : _a[fieldName]) !== null && _b !== void 0
+              ? _b
+              : formState,
+          ),
+        ]);
+      });
+      const errors = ValueOrErrors.Operations.All(
+        List(res.map(([_, value]) => value)),
+      );
+      if (errors.kind == "errors") return errors;
+      return ValueOrErrors.Operations.Return(
+        res.reduce((acc, [fieldName, value]) => {
+          acc[fieldName] = value.value;
+          return acc;
+        }, {}),
+      );
+    }
+    return ValueOrErrors.Operations.Return(
+      defaultValue(types, builtIns, injectedPrimitives)(t),
+    );
+  };
+//# sourceMappingURL=state.js.map