ballerina-core 1.0.237 → 1.0.239

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

@@ -1,321 +1,447 @@
-import { ValueOrErrors, } from "../../../../../../main";
+import { ValueOrErrors } from "../../../../../../main";
 export const DeltaTransfer = {
-    Default: {
-        FromDelta: (toRawObject, parseCustomDelta) => (delta) => {
-            if (delta.kind == "NumberReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "NumberReplace",
-                        Replace: value,
-                    },
-                    "[NumberReplace]",
-                ]));
-            }
-            if (delta.kind == "StringReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "StringReplace",
-                        Replace: value,
-                    },
-                    "[StringReplace]",
-                ]));
-            }
-            if (delta.kind == "BoolReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "BoolReplace",
-                        Replace: value,
-                    },
-                    "[BoolReplace]",
-                ]));
-            }
-            if (delta.kind == "TimeReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "TimeReplace",
-                        Replace: value,
-                    },
-                    "[TimeReplace]",
-                ]));
-            }
-            if (delta.kind == "GuidReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "GuidReplace",
-                        Replace: value,
-                    },
-                    "[GuidReplace]",
-                ]));
-            }
-            if (delta.kind == "UnitReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "UnitReplace",
-                        Replace: value,
-                    },
-                    "UnitReplace",
-                ]));
-            }
-            if (delta.kind == "OptionReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "OptionReplace",
-                        Replace: value,
-                    },
-                    "[OptionReplace]",
-                ]));
-            }
-            if (delta.kind == "OptionValue") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.value).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "OptionValue",
-                        Value: value[0],
-                    },
-                    `[OptionValue]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "SumReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "SumReplace",
-                        Replace: value,
-                    },
-                    "[SumReplace]",
-                ]));
-            }
-            if (delta.kind == "SumLeft") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.value).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "SumLeft",
-                        Left: value[0],
-                    },
-                    `[SumLeft]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "SumRight") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.value).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "SumRight",
-                        Right: value[0],
-                    },
-                    `[SumRight]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "ArrayReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "ArrayReplace",
-                        Replace: value,
-                    },
-                    "[ArrayReplace]",
-                ]));
-            }
-            if (delta.kind == "ArrayValue") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.value[1]).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "ArrayValue",
-                        Value: {
-                            Item1: delta.value[0],
-                            Item2: value[0],
-                        },
-                    },
-                    `[ArrayValue][${delta.value[0]}]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "ArrayAdd") {
-                return toRawObject(delta.value, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "ArrayAdd",
-                        Add: value,
-                    },
-                    "[ArrayAdd]",
-                ]));
-            }
-            if (delta.kind == "ArrayAddAt") {
-                return toRawObject(delta.value[1], delta.elementState, delta.elementType).Then((element) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "ArrayAddAt",
-                        AddAt: { Item1: delta.value[0], Item2: element },
-                    },
-                    `[ArrayAddAt][${delta.value[0]}]`,
-                ]));
-            }
-            if (delta.kind == "ArrayRemoveAt") {
-                return ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "ArrayRemoveAt",
-                        RemoveAt: delta.index,
-                    },
-                    `[ArrayRemoveAt]`,
-                ]);
-            }
-            if (delta.kind == "ArrayMoveFromTo") {
-                return ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "ArrayMoveFromTo",
-                        MoveFromTo: { Item1: delta.from, Item2: delta.to },
-                    },
-                    `[ArrayMoveFromTo]`,
-                ]);
-            }
-            if (delta.kind == "ArrayDuplicateAt") {
-                return ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "ArrayDuplicateAt",
-                        DuplicateAt: delta.index,
-                    },
-                    `[ArrayDuplicateAt]`,
-                ]);
-            }
-            if (delta.kind == "SetReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "SetReplace",
-                        Replace: value,
-                    },
-                    "[SetReplace]",
-                ]));
-            }
-            if (delta.kind == "SetValue") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.value[1]).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "SetValue",
-                        Value: { Item1: delta.value[0], Item2: value[0] },
-                    },
-                    `[SetValue][${delta.value[0]}]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "SetAdd") {
-                return toRawObject(delta.value, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "SetAdd",
-                        Add: value,
-                    },
-                    `[SetAdd]`,
-                ]));
-            }
-            if (delta.kind == "SetRemove") {
-                return toRawObject(delta.value, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "SetRemove",
-                        Remove: value,
-                    },
-                    `[SetRemove]`,
-                ]));
-            }
-            if (delta.kind == "MapReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "MapReplace",
-                        Replace: value,
-                    },
-                    "[MapReplace]",
-                ]));
-            }
-            if (delta.kind == "MapKey") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.value[1]).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "MapKey",
-                        Key: { Item1: delta.value[0], Item2: value[0] },
-                    },
-                    `[MapKey][${delta.value[0]}]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "MapValue") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.value[1]).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "MapValue",
-                        Value: { Item1: delta.value[0], Item2: value[0] },
-                    },
-                    `[MapValue][${delta.value[0]}]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "MapAdd") {
-                return toRawObject(delta.keyValue[0], delta.keyState, delta.keyType).Then((key) => toRawObject(delta.keyValue[1], delta.valueState, delta.valueType).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "MapAdd",
-                        Add: { Item1: key, Item2: value },
-                    },
-                    `[MapAdd]`,
-                ])));
-            }
-            if (delta.kind == "MapRemove") {
-                return ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "MapRemove",
-                        Remove: delta.index,
-                    },
-                    `[MapRemove]`,
-                ]);
-            }
-            if (delta.kind == "RecordReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "RecordReplace",
-                        Replace: value,
-                    },
-                    "[RecordReplace]",
-                ]));
-            }
-            if (delta.kind == "RecordField") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.field[1]).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: `${delta.recordType.value}${delta.field[0]}`,
-                        [delta.field[0]]: value[0],
-                    },
-                    `[RecordField][${delta.field[0]}]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "UnionReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "UnionReplace",
-                        Replace: value,
-                    },
-                    "[UnionReplace]",
-                ]));
-            }
-            if (delta.kind == "UnionCase") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.caseName[1]).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "UnionCase",
-                        [delta.caseName[0]]: value,
-                    },
-                    `[UnionCase][${delta.caseName[0]}]`,
-                ]));
-            }
-            if (delta.kind == "TupleReplace") {
-                return toRawObject(delta.replace, delta.state, delta.type).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "TupleReplace",
-                        Replace: value,
-                    },
-                    "[TupleReplace]",
-                ]));
-            }
-            if (delta.kind == "TupleCase") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.item[1]).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: `Tuple${delta.tupleType.args.length}Item${delta.item[0] + 1}`,
-                        [`Item${delta.item[0] + 1}`]: value[0],
-                    },
-                    `[TupleCase][${delta.item[0] + 1}]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "TableValue") {
-                return DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta)(delta.nestedDelta).Then((value) => ValueOrErrors.Default.return([
-                    {
-                        Discriminator: "TableValue",
-                        Value: { Item1: delta.id, Item2: value[0] },
-                    },
-                    `[TableValue][${delta.id}]${value[1]}`,
-                ]));
-            }
-            if (delta.kind == "CustomDelta") {
-                return parseCustomDelta(toRawObject, DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta))(delta);
-            }
-            return ValueOrErrors.Default.throwOne(`Error: cannot process delta ${delta}, not currently supported.`);
-        },
+  Default: {
+    FromDelta: (toRawObject, parseCustomDelta) => (delta) => {
+      if (delta.kind == "NumberReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "NumberReplace",
+                Replace: value,
+              },
+              "[NumberReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "StringReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "StringReplace",
+                Replace: value,
+              },
+              "[StringReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "BoolReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "BoolReplace",
+                Replace: value,
+              },
+              "[BoolReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "TimeReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "TimeReplace",
+                Replace: value,
+              },
+              "[TimeReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "GuidReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "GuidReplace",
+                Replace: value,
+              },
+              "[GuidReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "UnitReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "UnitReplace",
+                Replace: value,
+              },
+              "UnitReplace",
+            ]),
+        );
+      }
+      if (delta.kind == "OptionReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "OptionReplace",
+                Replace: value,
+              },
+              "[OptionReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "OptionValue") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.value).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "OptionValue",
+              Value: value[0],
+            },
+            `[OptionValue]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "SumReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "SumReplace",
+                Replace: value,
+              },
+              "[SumReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "SumLeft") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.value).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "SumLeft",
+              Left: value[0],
+            },
+            `[SumLeft]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "SumRight") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.value).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "SumRight",
+              Right: value[0],
+            },
+            `[SumRight]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "ArrayReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "ArrayReplace",
+                Replace: value,
+              },
+              "[ArrayReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "ArrayValue") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.value[1]).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "ArrayValue",
+              Value: {
+                Item1: delta.value[0],
+                Item2: value[0],
+              },
+            },
+            `[ArrayValue][${delta.value[0]}]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "ArrayAdd") {
+        return toRawObject(delta.value, delta.state, delta.type).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "ArrayAdd",
+              Add: value,
+            },
+            "[ArrayAdd]",
+          ]),
+        );
+      }
+      if (delta.kind == "ArrayAddAt") {
+        return toRawObject(
+          delta.value[1],
+          delta.elementState,
+          delta.elementType,
+        ).Then((element) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "ArrayAddAt",
+              AddAt: { Item1: delta.value[0], Item2: element },
+            },
+            `[ArrayAddAt][${delta.value[0]}]`,
+          ]),
+        );
+      }
+      if (delta.kind == "ArrayRemoveAt") {
+        return ValueOrErrors.Default.return([
+          {
+            Discriminator: "ArrayRemoveAt",
+            RemoveAt: delta.index,
+          },
+          `[ArrayRemoveAt]`,
+        ]);
+      }
+      if (delta.kind == "ArrayMoveFromTo") {
+        return ValueOrErrors.Default.return([
+          {
+            Discriminator: "ArrayMoveFromTo",
+            MoveFromTo: { Item1: delta.from, Item2: delta.to },
+          },
+          `[ArrayMoveFromTo]`,
+        ]);
+      }
+      if (delta.kind == "ArrayDuplicateAt") {
+        return ValueOrErrors.Default.return([
+          {
+            Discriminator: "ArrayDuplicateAt",
+            DuplicateAt: delta.index,
+          },
+          `[ArrayDuplicateAt]`,
+        ]);
+      }
+      if (delta.kind == "SetReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "SetReplace",
+                Replace: value,
+              },
+              "[SetReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "SetValue") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.value[1]).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "SetValue",
+              Value: { Item1: delta.value[0], Item2: value[0] },
+            },
+            `[SetValue][${delta.value[0]}]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "SetAdd") {
+        return toRawObject(delta.value, delta.state, delta.type).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "SetAdd",
+              Add: value,
+            },
+            `[SetAdd]`,
+          ]),
+        );
+      }
+      if (delta.kind == "SetRemove") {
+        return toRawObject(delta.value, delta.state, delta.type).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "SetRemove",
+              Remove: value,
+            },
+            `[SetRemove]`,
+          ]),
+        );
+      }
+      if (delta.kind == "MapReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "MapReplace",
+                Replace: value,
+              },
+              "[MapReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "MapKey") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.value[1]).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "MapKey",
+              Key: { Item1: delta.value[0], Item2: value[0] },
+            },
+            `[MapKey][${delta.value[0]}]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "MapValue") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.value[1]).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "MapValue",
+              Value: { Item1: delta.value[0], Item2: value[0] },
+            },
+            `[MapValue][${delta.value[0]}]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "MapAdd") {
+        return toRawObject(
+          delta.keyValue[0],
+          delta.keyState,
+          delta.keyType,
+        ).Then((key) =>
+          toRawObject(
+            delta.keyValue[1],
+            delta.valueState,
+            delta.valueType,
+          ).Then((value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "MapAdd",
+                Add: { Item1: key, Item2: value },
+              },
+              `[MapAdd]`,
+            ]),
+          ),
+        );
+      }
+      if (delta.kind == "MapRemove") {
+        return ValueOrErrors.Default.return([
+          {
+            Discriminator: "MapRemove",
+            Remove: delta.index,
+          },
+          `[MapRemove]`,
+        ]);
+      }
+      if (delta.kind == "RecordReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "RecordReplace",
+                Replace: value,
+              },
+              "[RecordReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "RecordField") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.field[1]).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: `${delta.recordType.value}${delta.field[0]}`,
+              [delta.field[0]]: value[0],
+            },
+            `[RecordField][${delta.field[0]}]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "UnionReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "UnionReplace",
+                Replace: value,
+              },
+              "[UnionReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "UnionCase") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.caseName[1]).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "UnionCase",
+              [delta.caseName[0]]: value,
+            },
+            `[UnionCase][${delta.caseName[0]}]`,
+          ]),
+        );
+      }
+      if (delta.kind == "TupleReplace") {
+        return toRawObject(delta.replace, delta.state, delta.type).Then(
+          (value) =>
+            ValueOrErrors.Default.return([
+              {
+                Discriminator: "TupleReplace",
+                Replace: value,
+              },
+              "[TupleReplace]",
+            ]),
+        );
+      }
+      if (delta.kind == "TupleCase") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.item[1]).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: `Tuple${delta.tupleType.args.length}Item${delta.item[0] + 1}`,
+              [`Item${delta.item[0] + 1}`]: value[0],
+            },
+            `[TupleCase][${delta.item[0] + 1}]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "TableValue") {
+        return DeltaTransfer.Default.FromDelta(
+          toRawObject,
+          parseCustomDelta,
+        )(delta.nestedDelta).Then((value) =>
+          ValueOrErrors.Default.return([
+            {
+              Discriminator: "TableValue",
+              Value: { Item1: delta.id, Item2: value[0] },
+            },
+            `[TableValue][${delta.id}]${value[1]}`,
+          ]),
+        );
+      }
+      if (delta.kind == "CustomDelta") {
+        return parseCustomDelta(
+          toRawObject,
+          DeltaTransfer.Default.FromDelta(toRawObject, parseCustomDelta),
+        )(delta);
+      }
+      return ValueOrErrors.Default.throwOne(
+        `Error: cannot process delta ${delta}, not currently supported.`,
+      );
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map