ballerina-core 1.0.203 → 1.0.205

package/bin/src/forms/domains/dispatched-forms/runner/domains/deltas/state.js

@@ -1,668 +0,0 @@
-import { unit, ValueOrErrors } from "../../../../../../../main";
-export const DispatchDeltaTransfer = {
-  Default: {
-    FromDelta: (toRawObject, parseCustomDelta) => (delta) => {
-      const result = (() => {
-        if (delta.kind == "NumberReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "NumberReplace",
-                  Replace: value,
-                },
-                "[NumberReplace]",
-                delta.flags ? [[delta.flags, "[NumberReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "StringReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "StringReplace",
-                  Replace: value,
-                },
-                "[StringReplace]",
-                delta.flags ? [[delta.flags, "[StringReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "BoolReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "BoolReplace",
-                  Replace: value,
-                },
-                "[BoolReplace]",
-                delta.flags ? [[delta.flags, "[BoolReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "TimeReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "TimeReplace",
-                  Replace: value,
-                },
-                "[TimeReplace]",
-                delta.flags ? [[delta.flags, "[TimeReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "GuidReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "GuidReplace",
-                  Replace: value,
-                },
-                "[GuidReplace]",
-                delta.flags ? [[delta.flags, "[GuidReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "UnitReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "UnitReplace",
-                  Replace: value,
-                },
-                "UnitReplace",
-                delta.flags ? [[delta.flags, "UnitReplace"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "OptionReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "OptionReplace",
-                  Replace: value,
-                },
-                "[OptionReplace]",
-                delta.flags ? [[delta.flags, "[OptionReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "OptionValue") {
-          return DispatchDeltaTransfer.Default.FromDelta(
-            toRawObject,
-            parseCustomDelta,
-          )(delta.value).Then((value) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: "OptionValue",
-                Value: value[0],
-              },
-              `[OptionValue]${value[1]}`,
-              delta.flags
-                ? [[delta.flags, `[OptionValue]${value[1]}`], ...value[2]]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "SumReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "SumReplace",
-                  Replace: value,
-                },
-                "[SumReplace]",
-                delta.flags ? [[delta.flags, "[SumReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "SumLeft") {
-          return DispatchDeltaTransfer.Default.FromDelta(
-            toRawObject,
-            parseCustomDelta,
-          )(delta.value).Then((value) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: "SumLeft",
-                Left: value[0],
-              },
-              `[SumLeft]${value[1]}`,
-              delta.flags
-                ? [[delta.flags, `[SumLeft]${value[1]}`], ...value[2]]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "SumRight") {
-          return DispatchDeltaTransfer.Default.FromDelta(
-            toRawObject,
-            parseCustomDelta,
-          )(delta.value).Then((value) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: "SumRight",
-                Right: value[0],
-              },
-              `[SumRight]${value[1]}`,
-              delta.flags
-                ? [[delta.flags, "[SumRight]"], ...value[2]]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "ArrayReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "ArrayReplace",
-                  Replace: value,
-                },
-                "[ArrayReplace]",
-                delta.flags ? [[delta.flags, "[ArrayReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "ArrayValue") {
-          return DispatchDeltaTransfer.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]}`,
-              delta.flags
-                ? [
-                    [delta.flags, `[ArrayValue][${delta.value[0]}]${value[1]}`],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "ArrayAdd") {
-          return toRawObject(delta.value, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "ArrayAdd",
-                  Add: value,
-                },
-                "[ArrayAdd]",
-                delta.flags ? [[delta.flags, "[ArrayAdd]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "ArrayAddAt") {
-          return toRawObject(
-            delta.value[1],
-            delta.elementType,
-            delta.elementState,
-          ).Then((element) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: "ArrayAddAt",
-                AddAt: { Item1: delta.value[0], Item2: element },
-              },
-              `[ArrayAddAt][${delta.value[0]}]`,
-              delta.flags
-                ? [[delta.flags, `[ArrayAddAt][${delta.value[0]}]`]]
-                : [],
-            ]),
-          );
-        }
-        if (delta.kind == "ArrayRemoveAt") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "ArrayRemoveAt",
-              RemoveAt: delta.index,
-            },
-            `[ArrayRemoveAt]`,
-            delta.flags ? [[delta.flags, "[ArrayRemoveAt]"]] : [],
-          ]);
-        }
-        if (delta.kind == "ArrayMoveFromTo") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "ArrayMoveFromTo",
-              MoveFromTo: { Item1: delta.from, Item2: delta.to },
-            },
-            `[ArrayMoveFromTo]`,
-            delta.flags ? [[delta.flags, "[ArrayMoveFromTo]"]] : [],
-          ]);
-        }
-        if (delta.kind == "ArrayDuplicateAt") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "ArrayDuplicateAt",
-              DuplicateAt: delta.index,
-            },
-            `[ArrayDuplicateAt]`,
-            delta.flags ? [[delta.flags, "[ArrayDuplicateAt]"]] : [],
-          ]);
-        }
-        if (delta.kind == "SetReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "SetReplace",
-                  Replace: value,
-                },
-                "[SetReplace]",
-                delta.flags ? [[delta.flags, "[SetReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "SetValue") {
-          return DispatchDeltaTransfer.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]}`,
-              delta.flags
-                ? [
-                    [delta.flags, `[SetValue][${delta.value[0]}]${value[1]}`],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "SetAdd") {
-          return toRawObject(delta.value, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "SetAdd",
-                  Add: value,
-                },
-                `[SetAdd]`,
-                delta.flags ? [[delta.flags, "[SetAdd]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "SetRemove") {
-          return toRawObject(delta.value, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "SetRemove",
-                  Remove: value,
-                },
-                `[SetRemove]`,
-                delta.flags ? [[delta.flags, "[SetRemove]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "MapReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "MapReplace",
-                  Replace: value,
-                },
-                "[MapReplace]",
-                delta.flags ? [[delta.flags, "[MapReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "MapKey") {
-          return DispatchDeltaTransfer.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]}`,
-              delta.flags
-                ? [
-                    [delta.flags, `[MapKey][${delta.value[0]}]${value[1]}`],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "MapValue") {
-          return DispatchDeltaTransfer.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]}`,
-              delta.flags
-                ? [
-                    [delta.flags, `[MapValue][${delta.value[0]}]${value[1]}`],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "MapAdd") {
-          return toRawObject(
-            delta.keyValue[0],
-            delta.keyType,
-            delta.keyState,
-          ).Then((key) =>
-            toRawObject(
-              delta.keyValue[1],
-              delta.valueType,
-              delta.valueState,
-            ).Then((value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "MapAdd",
-                  Add: { Item1: key, Item2: value },
-                },
-                `[MapAdd]`,
-                delta.flags ? [[delta.flags, "[MapAdd]"]] : [],
-              ]),
-            ),
-          );
-        }
-        if (delta.kind == "MapRemove") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "MapRemove",
-              Remove: delta.index,
-            },
-            `[MapRemove]`,
-            delta.flags ? [[delta.flags, "[MapRemove]"]] : [],
-          ]);
-        }
-        if (delta.kind == "RecordReplace") {
-          if (delta.type.kind != "lookup") {
-            return ValueOrErrors.Default.throwOne(
-              `Error: cannot process non look up record delta ${delta}, not currently supported.`,
-            );
-          }
-          const lookupName = delta.type.name;
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "Replace",
-                  Replace: value,
-                },
-                `[${lookupName}Replace]`,
-                delta.flags ? [[delta.flags, `[${lookupName}Replace]`]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "RecordField") {
-          return DispatchDeltaTransfer.Default.FromDelta(
-            toRawObject,
-            parseCustomDelta,
-          )(delta.field[1]).Then((value) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: delta.field[0],
-                [delta.field[0]]: value[0],
-              },
-              `[RecordField][${delta.field[0]}]${value[1]}`,
-              delta.flags
-                ? [
-                    [
-                      delta.flags,
-                      `[RecordField][${delta.field[0]}]${value[1]}`,
-                    ],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "UnionReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "UnionReplace",
-                  Replace: value,
-                },
-                "[UnionReplace]",
-                delta.flags ? [[delta.flags, "[UnionReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "UnionCase") {
-          return DispatchDeltaTransfer.Default.FromDelta(
-            toRawObject,
-            parseCustomDelta,
-          )(delta.caseName[1]).Then((value) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: delta.caseName[0],
-                [delta.caseName[0]]: value[0],
-              },
-              `[UnionCase][${delta.caseName[0]}]`,
-              delta.flags
-                ? [
-                    [delta.flags, `[UnionCase][${delta.caseName[0]}]`],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "TupleReplace") {
-          return toRawObject(delta.replace, delta.type, delta.state).Then(
-            (value) =>
-              ValueOrErrors.Default.return([
-                {
-                  Discriminator: "TupleReplace",
-                  Replace: value,
-                },
-                "[TupleReplace]",
-                delta.flags ? [[delta.flags, "[TupleReplace]"]] : [],
-              ]),
-          );
-        }
-        if (delta.kind == "TupleCase") {
-          return DispatchDeltaTransfer.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]}`,
-              delta.flags
-                ? [
-                    [
-                      delta.flags,
-                      `[TupleCase][${delta.item[0] + 1}]${value[1]}`,
-                    ],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "TableValue") {
-          return DispatchDeltaTransfer.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]}`,
-              delta.flags
-                ? [
-                    [delta.flags, `[TableValue][${delta.id}]${value[1]}`],
-                    ...value[2],
-                  ]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "TableAddEmpty") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "TableAddEmpty",
-            },
-            `[TableAddEmpty]`,
-            delta.flags ? [[delta.flags, "[TableAddEmpty]"]] : [],
-          ]);
-        }
-        if (delta.kind == "TableRemove") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "TableRemoveAt",
-              RemoveAt: delta.id,
-            },
-            `[TableRemoveAt][${delta.id}]`,
-            delta.flags ? [[delta.flags, `[TableRemoveAt][${delta.id}]`]] : [],
-          ]);
-        }
-        if (delta.kind == "TableDuplicate") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "TableDuplicateAt",
-              DuplicateAt: delta.id,
-            },
-            `[TableDuplicateAt][${delta.id}]`,
-            delta.flags
-              ? [[delta.flags, `[TableDuplicateAt][${delta.id}]`]]
-              : [],
-          ]);
-        }
-        if (delta.kind == "TableMoveTo") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "TableMoveFromTo",
-              MoveFromTo: [delta.id, delta.to],
-            },
-            `[TableMoveFromTo][${delta.id}][${delta.to}]`,
-            delta.flags
-              ? [[delta.flags, `[TableMoveFromTo][${delta.id}][${delta.to}]`]]
-              : [],
-          ]);
-        }
-        if (delta.kind == "OneValue") {
-          return DispatchDeltaTransfer.Default.FromDelta(
-            toRawObject,
-            parseCustomDelta,
-          )(delta.nestedDelta).Then((value) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: "OneValue",
-                Value: value[0],
-              },
-              `[OneValue]${value[1]}`,
-              delta.flags
-                ? [[delta.flags, `[OneValue]${value[1]}`], ...value[2]]
-                : value[2],
-            ]),
-          );
-        }
-        if (delta.kind == "OneReplace") {
-          if (delta.type.kind != "one") {
-            return ValueOrErrors.Default.throwOne(
-              `Error: one expected but received ${JSON.stringify(delta.type)} in OneReplace.`,
-            );
-          }
-          return toRawObject(delta.replace, delta.type.arg, unit).Then(
-            (value) => {
-              return ValueOrErrors.Default.return([
-                {
-                  Discriminator: "OneReplace",
-                  Replace: value,
-                },
-                `[OneReplace]`,
-                delta.flags ? [[delta.flags, `[OneReplace]`]] : [],
-              ]);
-            },
-          );
-        }
-        if (delta.kind == "OneCreateValue") {
-          if (delta.type.kind != "one") {
-            return ValueOrErrors.Default.throwOne(
-              `Error: one expected but received ${JSON.stringify(delta.type)} in OneCreateValue.`,
-            );
-          }
-          return toRawObject(delta.value, delta.type.arg, unit).Then((value) =>
-            ValueOrErrors.Default.return([
-              {
-                Discriminator: "OneCreateValue",
-                CreateValue: value,
-              },
-              `[OneCreateValue]`,
-              delta.flags ? [[delta.flags, `[OneCreateValue]`]] : [],
-            ]),
-          );
-        }
-        // TODO -- suspicious
-        if (delta.kind == "OneDeleteValue") {
-          return ValueOrErrors.Default.return([
-            {
-              Discriminator: "OneDeleteValue",
-              DeleteValue: unit,
-            },
-            `[OneDeleteValue]`,
-            delta.flags ? [[delta.flags, `[OneDeleteValue]`]] : [],
-          ]);
-        }
-        if (delta.kind == "CustomDelta") {
-          return parseCustomDelta(
-            toRawObject,
-            DispatchDeltaTransfer.Default.FromDelta(
-              toRawObject,
-              parseCustomDelta,
-            ),
-          )(delta).Then((value) =>
-            ValueOrErrors.Default.return([
-              Object.assign({}, value[0]),
-              value[1],
-              delta.flags ? [[delta.flags, value[1]], ...value[2]] : value[2],
-            ]),
-          );
-        }
-        return ValueOrErrors.Default.throwOne(
-          `Error: cannot process delta ${delta}, not currently supported.`,
-        );
-      })();
-      return result.MapErrors((errors) =>
-        errors.map(
-          (error) =>
-            `${error}\n...When dispatching delta: ${JSON.stringify(delta, null, 2)}`,
-        ),
-      );
-    },
-  },
-};
-//# sourceMappingURL=state.js.map