ballerina-core 1.0.231 → 1.0.233

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

@@ -0,0 +1,835 @@
+import { Map, List, Set, OrderedMap } from "immutable";
+import {
+  CollectionReference,
+  EnumReference,
+} from "../../../collection/domains/reference/state";
+import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
+import {
+  Base64FileFormState,
+  BooleanFormState,
+  DateFormState,
+  MapFieldState,
+  ListFieldState,
+  NumberFormState,
+  PredicateValue,
+  StringFormState,
+  UnitFormState,
+  SumFormState,
+  TupleFormState,
+  SecretFormState,
+  replaceWith,
+  unit,
+} from "../../../../../../main";
+import { Sum } from "../../../../../../main";
+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 BuiltInPrimitiveTypes = [
+  "unit",
+  "guid", //resolves to string
+  "string",
+  "number",
+  "boolean",
+  "Date",
+  "base64File",
+  "secret",
+];
+export const BuiltInGenericTypes = [
+  "SingleSelection",
+  "MultiSelection",
+  "List",
+  "Map",
+  "Union",
+  "Tuple",
+  "Sum",
+  "Record",
+];
+export const CommonFormState = {
+  Default: () => ({
+    modifiedByUser: false,
+  }),
+};
+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(Map()),
+        },
+      ],
+      [
+        "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),
+        },
+      ],
+    ]),
+    specifics: Map([
+      [
+        "sumUnitDate",
+        {
+          defaultValue: PredicateValue.Default.sum(
+            Sum.Default.left(PredicateValue.Default.unit()),
+          ),
+        },
+      ],
+    ]),
+    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(),
+      sumUnitDate: 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);
+      });
+    } else {
+      console.error(
+        `field view kind ${categoryName} missing in fieldViews when building builtInsFromFieldViews`,
+      );
+    }
+  });
+  return builtins;
+};
+export const defaultState = (types, builtIns, injectedPrimitives) => (t) => {
+  if (
+    t.kind == "union" ||
+    t.kind == "singleSelection" ||
+    t.kind == "multiSelection"
+  ) {
+    throw Error(
+      `t.kind: ${t.kind} not currently supported by the defaultState function`,
+    );
+  }
+  if (t.kind == "primitive") {
+    const primitive = builtIns.primitives.get(t.name);
+    const injectedPrimitive =
+      injectedPrimitives === null || injectedPrimitives === void 0
+        ? void 0
+        : injectedPrimitives.injectedPrimitives.get(t.name);
+    if (primitive != undefined) return primitive.defaultState;
+    if (injectedPrimitive != undefined)
+      return {
+        commonFormState: CommonFormState.Default(),
+        customFormState: injectedPrimitive.defaultState,
+      };
+  }
+  if (t.kind == "tuple") {
+    return builtIns.generics
+      .get("Tuple")
+      .defaultState(
+        t.args.map((_) => defaultState(types, builtIns, injectedPrimitives)(_)),
+      );
+  }
+  if (t.kind == "sum") {
+    return builtIns.generics
+      .get("Sum")
+      .defaultState(
+        defaultState(types, builtIns, injectedPrimitives)(t.args[0]),
+        defaultState(types, builtIns, injectedPrimitives)(t.args[1]),
+      );
+  }
+  if (t.kind == "list" || t.kind == "map") {
+    const generic = builtIns.generics.get(t.name);
+    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.name);
+    const injectedPrimitive =
+      injectedPrimitives === null || injectedPrimitives === void 0
+        ? void 0
+        : injectedPrimitives.injectedPrimitives.get(t.name);
+    if (primitive != undefined) return primitive.defaultValue;
+    if (injectedPrimitive != undefined) return injectedPrimitive.defaultValue;
+  }
+  if (t.kind == "tuple") {
+    return builtIns.generics
+      .get("Tuple")
+      .defaultValue(
+        t.args.map((_) => defaultValue(types, builtIns, injectedPrimitives)(_)),
+      );
+  }
+  if (t.kind == "sum") {
+    return builtIns.generics
+      .get("Sum")
+      .defaultValue(
+        defaultValue(types, builtIns, injectedPrimitives)(t.args[0]),
+        defaultValue(types, builtIns, injectedPrimitives)(t.args[1]),
+      );
+  }
+  if (t.kind == "list" || t.kind == "map") {
+    const generic = builtIns.generics.get(t.name);
+    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(Map(res));
+  }
+  throw Error(
+    `cannot find type ${JSON.stringify(t)} when resolving defaultValue`,
+  );
+};
+// TODO: also return the formState / defaultState
+export const fromAPIRawValue =
+  (t, types, builtIns, converters, injectedPrimitives) => (raw) => {
+    // allow undefined for unit renderer
+    if (raw == undefined && (t.kind !== "primitive" || t.name != "unit")) {
+      return ValueOrErrors.Default.throwOne(
+        `raw value is undefined for type ${JSON.stringify(t)}`,
+      );
+    }
+    if (t.kind == "primitive") {
+      // unit is a special kind of primitive
+      if (t.name == "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.name))
+      ) {
+        return ValueOrErrors.Default.throwOne(
+          `primitive expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      return ValueOrErrors.Default.return(
+        converters[t.name].fromAPIRawValue(raw),
+      );
+    }
+    if (t.kind == "union") {
+      // TODO
+      return ValueOrErrors.Default.throwOne("unions not supported yet");
+      // 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,
+      //     )}`,
+      //   );
+      // // TODO :fix this and converters for generic types
+      // return fromAPIRawValue(
+      //   caseType,
+      //   types,
+      //   builtIns,
+      //   converters,
+      //   injectedPrimitives,
+      // )(result.fields).Then((fields) => {
+      //   return ValueOrErrors.Default.return(
+      //     PredicateValue.Default.unionCase(
+      //       result.caseName,
+      //       fields as ValueRecord,
+      //     ),
+      //   );
+      // });
+    }
+    if (t.kind == "singleSelection") {
+      const result = converters["SingleSelection"].fromAPIRawValue(raw);
+      const isSome = result.kind == "l";
+      const value = isSome
+        ? PredicateValue.Default.record(Map(result.value))
+        : PredicateValue.Default.unit();
+      return ValueOrErrors.Default.return(
+        PredicateValue.Default.option(isSome, value),
+      );
+    }
+    if (t.kind == "multiSelection") {
+      const result = converters["MultiSelection"].fromAPIRawValue(raw);
+      const values = result.map((_) => PredicateValue.Default.record(Map(_)));
+      return ValueOrErrors.Default.return(
+        PredicateValue.Default.record(Map(values)),
+      );
+    }
+    if (t.kind == "list") {
+      const result = converters["List"].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.kind == "map" && t.args.length == 2) {
+      const result = converters["Map"].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.kind == "tuple") {
+      const result = converters["Tuple"].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.kind == "sum" && t.args.length === 2) {
+      const result = converters["Sum"].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];
+        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),
+      );
+    }
+    return ValueOrErrors.Default.throwOne(
+      `unsupported type ${JSON.stringify(t)} for raw: `,
+    );
+  };
+export const toAPIRawValue =
+  (t, types, builtIns, converters, injectedPrimitives) => (raw, formState) => {
+    if (t.kind == "primitive") {
+      if (t.name == "unit") {
+        return ValueOrErrors.Default.return(unit);
+      }
+      return ValueOrErrors.Operations.Return(
+        converters[t.name].toAPIRawValue([
+          raw,
+          formState.commonFormState.modifiedByUser,
+        ]),
+      );
+    }
+    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,
+          formState.commonFormState.modifiedByUser,
+        ]),
+      );
+    }
+    if (t.kind == "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["SingleSelection"].toAPIRawValue([
+            Sum.Default.left(rawValue),
+            formState.commonFormState.modifiedByUser,
+          ]),
+        );
+      } else {
+        return ValueOrErrors.Operations.Return(
+          converters["SingleSelection"].toAPIRawValue([
+            Sum.Default.right("no selection"),
+            formState.commonFormState.modifiedByUser,
+          ]),
+        );
+      }
+    }
+    if (t.kind == "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) =>
+          ValueOrErrors.Default.return(
+            converters["MultiSelection"].toAPIRawValue([
+              OrderedMap(
+                values
+                  .map((v) => {
+                    if (
+                      CollectionReference.Operations.IsCollectionReference(v)
+                    ) {
+                      return [v.Id, v];
+                    }
+                    return [v.Value, v];
+                  })
+                  .toArray(),
+              ),
+              formState.commonFormState.modifiedByUser,
+            ]),
+          ),
+      );
+    }
+    if (t.kind == "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) =>
+            toAPIRawValue(
+              t.args[0],
+              types,
+              builtIns,
+              converters,
+              injectedPrimitives,
+            )(value, formState.elementFormStates.get(index)),
+          ),
+        ),
+      ).Then((values) =>
+        ValueOrErrors.Default.return(
+          converters["List"].toAPIRawValue([
+            values,
+            formState.commonFormState.modifiedByUser,
+          ]),
+        ),
+      );
+    }
+    if (t.kind == "map" && t.args.length == 2) {
+      const keyValues = raw.values.map((keyValue, index) => {
+        return toAPIRawValue(
+          t.args[0],
+          types,
+          builtIns,
+          converters,
+          injectedPrimitives,
+        )(
+          keyValue.values.get(0),
+          formState.elementFormStates.get(index).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) =>
+            toAPIRawValue(
+              t.args[1],
+              types,
+              builtIns,
+              converters,
+              injectedPrimitives,
+            )(
+              keyValue.values.get(1),
+              formState.elementFormStates.get(index).ValueFormState,
+            ).Then((value) => ValueOrErrors.Default.return([key, value])),
+          );
+      });
+      return ValueOrErrors.Operations.All(List(keyValues)).Then((values) => {
+        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, formState.modifiedByUser]),
+        );
+      });
+    }
+    if (t.kind == "sum" && t.args.length === 2) {
+      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) =>
+        ValueOrErrors.Default.return(
+          converters["Sum"].toAPIRawValue([
+            raw.value.kind == "l"
+              ? Sum.Default.left(value)
+              : Sum.Default.right(value),
+            formState.commonFormState.modifiedByUser,
+          ]),
+        ),
+      );
+    }
+    if (t.kind == "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) => {
+            return toAPIRawValue(
+              t.args[index],
+              types,
+              builtIns,
+              converters,
+              injectedPrimitives,
+            )(value, formState.elementFormStates.get(index));
+          }),
+        ),
+      ).Then((values) =>
+        ValueOrErrors.Default.return(
+          converters["Tuple"].toAPIRawValue([
+            values,
+            formState.commonFormState.modifiedByUser,
+          ]),
+        ),
+      );
+    }
+    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
+        return res.push([
+          fieldName,
+          toAPIRawValue(
+            fieldType,
+            types,
+            builtIns,
+            converters,
+            injectedPrimitives,
+          )(
+            raw.fields.get(fieldName),
+            (_b =
+              (_a = 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