ballerina-core 1.0.244 → 1.0.246

package/bin/src/coroutines/template.js

@@ -6,105 +6,67 @@ import { Coroutine } from "./state";
 import { Template } from "../template/state";
 const Co = Coroutine;
 class CoroutineComponent extends React.Component {
-  constructor(props) {
-    super(props);
-    this.running = false;
-    this.animationFrameId = undefined;
-    this.state = { currentCoroutine: props.initialCoroutine };
-  }
-  componentDidMount() {
-    var _a;
-    let lastTimestamp = Date.now();
-    this.running = true;
-    const tick = () => {
-      if (!this.running) {
+    constructor(props) {
+        super(props);
+        this.running = false;
+        this.animationFrameId = undefined;
+        this.state = { currentCoroutine: props.initialCoroutine };
+    }
+    componentDidMount() {
+        var _a;
+        let lastTimestamp = Date.now();
+        this.running = true;
+        const tick = () => {
+            if (!this.running) {
+                clearInterval(this.animationFrameId);
+                return;
+            }
+            const currTimestamp = Date.now();
+            const step = Co.Tick(this.props.context, this.state.currentCoroutine, currTimestamp - lastTimestamp);
+            lastTimestamp = currTimestamp;
+            if (!this.running)
+                return;
+            if (step.kind == "done") {
+                this.setState((s) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, s), { currentCoroutine: !!((_a = this.props.options) === null || _a === void 0 ? void 0 : _a.restartWhenFinished)
+                            ? this.props.initialCoroutine
+                            : Co.Nothing() }));
+                }, () => step.state && this.running
+                    ? this.props.setState(step.state)
+                    : undefined);
+            }
+            else {
+                this.setState((s) => (Object.assign(Object.assign({}, s), { currentCoroutine: step.next })), () => step.state && this.running
+                    ? this.props.setState(Updater(step.state))
+                    : undefined);
+            }
+            // if (this.running)
+            //   this.animationFrameId = setTimeout(
+            //     tick,
+            //     this.props.options?.interval || 250
+            //   );
+        };
+        this.animationFrameId = setInterval(tick, ((_a = this.props.options) === null || _a === void 0 ? void 0 : _a.interval) || 250);
+    }
+    componentWillUnmount() {
+        this.running = false;
         clearInterval(this.animationFrameId);
-        return;
-      }
-      const currTimestamp = Date.now();
-      const step = Co.Tick(
-        this.props.context,
-        this.state.currentCoroutine,
-        currTimestamp - lastTimestamp,
-      );
-      lastTimestamp = currTimestamp;
-      if (!this.running) return;
-      if (step.kind == "done") {
-        this.setState(
-          (s) => {
-            var _a;
-            return Object.assign(Object.assign({}, s), {
-              currentCoroutine: !!((_a = this.props.options) === null ||
-              _a === void 0
-                ? void 0
-                : _a.restartWhenFinished)
-                ? this.props.initialCoroutine
-                : Co.Nothing(),
-            });
-          },
-          () =>
-            step.state && this.running
-              ? this.props.setState(step.state)
-              : undefined,
-        );
-      } else {
-        this.setState(
-          (s) =>
-            Object.assign(Object.assign({}, s), {
-              currentCoroutine: step.next,
-            }),
-          () =>
-            step.state && this.running
-              ? this.props.setState(Updater(step.state))
-              : undefined,
-        );
-      }
-      // if (this.running)
-      //   this.animationFrameId = setTimeout(
-      //     tick,
-      //     this.props.options?.interval || 250
-      //   );
-    };
-    this.animationFrameId = setInterval(
-      tick,
-      ((_a = this.props.options) === null || _a === void 0
-        ? void 0
-        : _a.interval) || 250,
-    );
-  }
-  componentWillUnmount() {
-    this.running = false;
-    clearInterval(this.animationFrameId);
-  }
-  shouldComponentUpdate() {
-    return false;
-  }
-  render() {
-    return _jsx(_Fragment, {});
-  }
+    }
+    shouldComponentUpdate() {
+        return false;
+    }
+    render() {
+        return _jsx(_Fragment, {});
+    }
 }
-export const CoroutineTemplate = () =>
-  Template.Default((props) => {
+export const CoroutineTemplate = () => Template.Default((props) => {
     var _a, _b;
-    return _jsx(
-      CoroutineComponent,
-      {
+    return (_jsx(CoroutineComponent, { context: props.context, initialCoroutine: props.context.initialCoroutine, setState: props.setState, options: props.context.options }, (_b = (_a = props.context.options) === null || _a === void 0 ? void 0 : _a.key) === null || _b === void 0 ? void 0 : _b.call(_a, {
         context: props.context,
-        initialCoroutine: props.context.initialCoroutine,
         setState: props.setState,
-        options: props.context.options,
-      },
-      (_b =
-        (_a = props.context.options) === null || _a === void 0
-          ? void 0
-          : _a.key) === null || _b === void 0
-        ? void 0
-        : _b.call(_a, {
-            context: props.context,
-            setState: props.setState,
-            foreignMutations: unit,
-            view: unit,
-          }),
-    );
-  });
-//# sourceMappingURL=template.js.map
+        foreignMutations: unit,
+        view: unit,
+    })));
+});
+//# sourceMappingURL=template.js.map

package/bin/src/debounced/coroutines/debounce.js

@@ -1,124 +1,98 @@
 import { CoTypedFactory } from "../../coroutines/builder";
 import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state";
 import { Debounced } from "../state";
-export const Debounce = (
-  k,
-  debounceDurationInMs,
-  waitBeforeRetryOnTransientFailure = debounceDurationInMs * 2,
-) => {
-  const Co = CoTypedFactory();
-  const updaters = Debounced.Updaters;
-  return Co.Seq([
-    Co.SetState(updaters.Core.status(replaceWith("waiting for dirty"))),
-    Co.While(
-      ([current]) =>
-        current.dirty != "dirty" ||
-        Date.now() - current.lastUpdated <= debounceDurationInMs,
-      Co.Wait(debounceDurationInMs / 5),
-    ),
-    Co.SetState(updaters.Core.dirty(replaceWith("dirty but being processed"))),
-    Co.GetState().then((current) => {
-      if (current.status.kind == "l") {
-        return Co.SetState(
-          updaters.Core.status(
-            replaceWith("just detected dirty, starting processing"),
-          ),
-        );
-      } else return Co.Do(() => {});
-    }),
-    Co.Any([
-      // shortcircuit the validation if it takes longer than the whole cycle in the presence of an underwater update of the field
-      Co.Seq([
-        Co.While(
-          ([current]) =>
-            current.dirty != "dirty" ||
-            Date.now() - current.lastUpdated <= debounceDurationInMs,
-          Co.Wait(debounceDurationInMs / 5),
-        ),
+export const Debounce = (k, debounceDurationInMs, waitBeforeRetryOnTransientFailure = debounceDurationInMs * 2) => {
+    const Co = CoTypedFactory();
+    const updaters = Debounced.Updaters;
+    return Co.Seq([
+        Co.SetState(updaters.Core.status(replaceWith("waiting for dirty"))),
+        Co.While(([current]) => current.dirty != "dirty" ||
+            Date.now() - current.lastUpdated <= debounceDurationInMs, Co.Wait(debounceDurationInMs / 5)),
+        Co.SetState(updaters.Core.dirty(replaceWith("dirty but being processed"))),
         Co.GetState().then((current) => {
-          if (current.status.kind == "l") {
-            return Co.SetState(
-              updaters.Core.status(replaceWith("processing shortcircuited")),
-            );
-          } else return Co.Do(() => {});
+            if (current.status.kind == "l") {
+                return Co.SetState(updaters.Core.status(replaceWith("just detected dirty, starting processing")));
+            }
+            else
+                return Co.Do(() => { });
         }),
-        Co.Wait(debounceDurationInMs / 2),
-      ]),
-      k
-        .embed((_) => _, updaters.Core.value)
-        .then((apiResult) => {
-          return Co.Seq([
-            Co.GetState().then((current) => {
-              if (current.status.kind == "l") {
-                return Co.SetState(
-                  updaters.Core.status(replaceWith("processing finished")),
-                );
-              } else return Co.Do(() => {});
-            }),
-            // Co.Wait(250)
-          ]).then(() => {
-            return Co.GetState().then((current) => {
-              // alert(apiResult)
-              if (apiResult == "success" || apiResult == "permanent failure") {
-                // maybe a new change has already reset dirty, in that case we need to start all over again
-                if (current.dirty == "dirty but being processed") {
-                  return Co.Seq([
-                    Co.GetState().then((current) => {
-                      if (current.status.kind == "l") {
-                        return Co.SetState(
-                          updaters.Core.status(
-                            replaceWith(
-                              "state was still dirty but being processed, resetting to not dirty",
-                            ),
-                          ),
-                        );
-                      } else return Co.Do(() => {});
-                    }),
-                    // use UpdateState to make sure that we look up the state at the last possible moment to account for delays
-                    Co.UpdateState((state) =>
-                      state.dirty == "dirty but being processed"
-                        ? updaters.Core.dirty(replaceWith("not dirty"))
-                        : updaters.Core.dirty(replaceWith("dirty")),
-                    ),
-                  ]);
-                } else {
-                  return Co.Seq([
+        Co.Any([
+            // shortcircuit the validation if it takes longer than the whole cycle in the presence of an underwater update of the field
+            Co.Seq([
+                Co.While(([current]) => current.dirty != "dirty" ||
+                    Date.now() - current.lastUpdated <= debounceDurationInMs, Co.Wait(debounceDurationInMs / 5)),
+                Co.GetState().then((current) => {
+                    if (current.status.kind == "l") {
+                        return Co.SetState(updaters.Core.status(replaceWith("processing shortcircuited")));
+                    }
+                    else
+                        return Co.Do(() => { });
+                }),
+                Co.Wait(debounceDurationInMs / 2),
+            ]),
+            k
+                .embed((_) => _, updaters.Core.value)
+                .then((apiResult) => {
+                return Co.Seq([
                     Co.GetState().then((current) => {
-                      if (current.status.kind == "l") {
-                        return Co.SetState(
-                          updaters.Core.status(
-                            replaceWith(
-                              "state was changed underwater back to dirty, leaving the dirty flag alone",
-                            ),
-                          ),
-                        );
-                      } else return Co.Do(() => {});
+                        if (current.status.kind == "l") {
+                            return Co.SetState(updaters.Core.status(replaceWith("processing finished")));
+                        }
+                        else
+                            return Co.Do(() => { });
                     }),
-                    Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
                     // Co.Wait(250)
-                  ]);
-                }
-              } else {
-                return Co.Seq([
-                  Co.GetState().then((current) => {
-                    if (current.status.kind == "l") {
-                      return Co.SetState(
-                        updaters.Core.status(
-                          replaceWith(
-                            "inner call failed with transient failure",
-                          ),
-                        ),
-                      );
-                    } else return Co.Do(() => {});
-                  }),
-                  Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
-                  Co.Wait(waitBeforeRetryOnTransientFailure),
-                ]);
-              }
-            });
-          });
-        }),
-    ]),
-  ]);
+                ]).then(() => {
+                    return Co.GetState().then((current) => {
+                        // alert(apiResult)
+                        if (apiResult == "success" || apiResult == "permanent failure") {
+                            // maybe a new change has already reset dirty, in that case we need to start all over again
+                            if (current.dirty == "dirty but being processed") {
+                                return Co.Seq([
+                                    Co.GetState().then((current) => {
+                                        if (current.status.kind == "l") {
+                                            return Co.SetState(updaters.Core.status(replaceWith("state was still dirty but being processed, resetting to not dirty")));
+                                        }
+                                        else
+                                            return Co.Do(() => { });
+                                    }),
+                                    // use UpdateState to make sure that we look up the state at the last possible moment to account for delays
+                                    Co.UpdateState((state) => state.dirty == "dirty but being processed"
+                                        ? updaters.Core.dirty(replaceWith("not dirty"))
+                                        : updaters.Core.dirty(replaceWith("dirty"))),
+                                ]);
+                            }
+                            else {
+                                return Co.Seq([
+                                    Co.GetState().then((current) => {
+                                        if (current.status.kind == "l") {
+                                            return Co.SetState(updaters.Core.status(replaceWith("state was changed underwater back to dirty, leaving the dirty flag alone")));
+                                        }
+                                        else
+                                            return Co.Do(() => { });
+                                    }),
+                                    Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
+                                    // Co.Wait(250)
+                                ]);
+                            }
+                        }
+                        else {
+                            return Co.Seq([
+                                Co.GetState().then((current) => {
+                                    if (current.status.kind == "l") {
+                                        return Co.SetState(updaters.Core.status(replaceWith("inner call failed with transient failure")));
+                                    }
+                                    else
+                                        return Co.Do(() => { });
+                                }),
+                                Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
+                                Co.Wait(waitBeforeRetryOnTransientFailure),
+                            ]);
+                        }
+                    });
+                });
+            }),
+        ]),
+    ]);
 };
-//# sourceMappingURL=debounce.js.map
+//# sourceMappingURL=debounce.js.map

package/bin/src/debounced/state.js

@@ -1,68 +1,31 @@
 import { Sum } from "../../main";
 import { Updater } from "../fun/domains/updater/state";
 export const Debounced = {
-  Default: (initialValue, debug) =>
-    Object.assign(Object.assign({}, initialValue), {
-      lastUpdated: 0,
-      dirty: "not dirty",
-      status: debug
-        ? Sum.Default.left("waiting for dirty")
-        : Sum.Default.right("debug off"),
-    }),
-  Updaters: {
-    Core: {
-      status: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), {
-            status:
-              current.status.kind == "l"
-                ? Sum.Default.left(_(current.status.value))
-                : Sum.Default.right("debug off"),
-          }),
-        ),
-      dirty: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), {
-            dirty: _(current.dirty),
-          }),
-        ),
-      lastUpdated: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), {
-            lastUpdated: _(current.lastUpdated),
-          }),
-        ),
-      valueWithoutDebouncing: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), _(current)),
-        ),
-      value: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, _(current)), {
-            dirty: current.dirty,
-            lastUpdated: current.lastUpdated,
-            status: current.status,
-          }),
-        ),
+    Default: (initialValue, debug) => (Object.assign(Object.assign({}, initialValue), { lastUpdated: 0, dirty: "not dirty", status: debug
+            ? Sum.Default.left("waiting for dirty")
+            : Sum.Default.right("debug off") })),
+    Updaters: {
+        Core: {
+            status: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { status: current.status.kind == "l"
+                    ? Sum.Default.left(_(current.status.value))
+                    : Sum.Default.right("debug off") }))),
+            dirty: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { dirty: _(current.dirty) }))),
+            lastUpdated: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { lastUpdated: _(current.lastUpdated) }))),
+            valueWithoutDebouncing: (_) => Updater((current) => (Object.assign(Object.assign({}, current), _(current)))),
+            value: (_) => Updater((current) => (Object.assign(Object.assign({}, _(current)), { dirty: current.dirty, lastUpdated: current.lastUpdated, status: current.status }))),
+        },
+        Template: {
+            value: (_) => 
+            // Debounced.Updaters.Core.value(_).then(
+            // 	Debounced.Updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
+            // ).then(
+            // 	Debounced.Updaters.Core.lastUpdated(replaceWith(Date.now()))
+            // )
+            Updater((current) => (Object.assign(Object.assign({}, _(current)), { dirty: "dirty", lastUpdated: Date.now(), status: current.status }))),
+        },
     },
-    Template: {
-      value: (_) =>
-        // Debounced.Updaters.Core.value(_).then(
-        // 	Debounced.Updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
-        // ).then(
-        // 	Debounced.Updaters.Core.lastUpdated(replaceWith(Date.now()))
-        // )
-        Updater((current) =>
-          Object.assign(Object.assign({}, _(current)), {
-            dirty: "dirty",
-            lastUpdated: Date.now(),
-            status: current.status,
-          }),
-        ),
+    Operations: {
+        shouldCoroutineRun: (_) => _.dirty != "not dirty",
     },
-  },
-  Operations: {
-    shouldCoroutineRun: (_) => _.dirty != "not dirty",
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/diagnostics/domains/message-box/state.d.ts

@@ -1,2 +1,2 @@
 export declare const messageBox: <a>(message: string, value: () => a) => a;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/diagnostics/domains/message-box/state.js

@@ -1,5 +1,5 @@
 export const messageBox = (message, value) => {
-  alert(message);
-  return value();
+    alert(message);
+    return value();
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/foreignMutations/state.d.ts

@@ -1,7 +1,7 @@
 import { BasicUpdater } from "../fun/domains/updater/state";
 import { BasicFun } from "../fun/state";
 export type ForeignMutationsInput<context, state> = {
-  context: context & state;
-  setState: BasicFun<BasicUpdater<state>, void>;
+    context: context & state;
+    setState: BasicFun<BasicUpdater<state>, void>;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/foreignMutations/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/attachments/views/attachments-view.js

@@ -1,31 +1,9 @@
-import {
-  jsxs as _jsxs,
-  Fragment as _Fragment,
-  jsx as _jsx,
-} from "react/jsx-runtime";
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { v4 } from "uuid";
-export const AttachmentsList = (props) =>
-  _jsxs(_Fragment, {
-    children: [
-      _jsx("ul", {
-        children: props.attachments
-          .map((file, fileId) =>
-            _jsx(_Fragment, {
-              children: _jsxs("button", {
-                onClick: () => props.remove(fileId),
-                children: [file.name, " \uD83D\uDDD1\uFE0F"],
-              }),
-            }),
-          )
-          .valueSeq(),
-      }),
-      _jsx("input", {
-        type: "file",
-        onChange: (e) => {
-          if (e.currentTarget.files != null)
-            props.add([v4(), e.currentTarget.files[0]]);
-        },
-      }),
-    ],
-  });
-//# sourceMappingURL=attachments-view.js.map
+export const AttachmentsList = (props) => (_jsxs(_Fragment, { children: [_jsx("ul", { children: props.attachments
+                .map((file, fileId) => (_jsx(_Fragment, { children: _jsxs("button", { onClick: () => props.remove(fileId), children: [file.name, " \uD83D\uDDD1\uFE0F"] }) })))
+                .valueSeq() }), _jsx("input", { type: "file", onChange: (e) => {
+                if (e.currentTarget.files != null)
+                    props.add([v4(), e.currentTarget.files[0]]);
+            } })] }));
+//# sourceMappingURL=attachments-view.js.map

package/bin/src/forms/domains/collection/domains/reference/state.js

@@ -1,34 +1,28 @@
 import { simpleUpdater } from "../../../../../../main";
 export const CollectionReference = {
-  Default: Object.assign(
-    (Id, DisplayValue, source) => ({
-      Id,
-      DisplayValue,
-      source,
+    Default: Object.assign((Id, DisplayValue, source) => ({
+        Id,
+        DisplayValue,
+        source,
+    }), {
+        empty: () => CollectionReference.Default("", ""),
     }),
-    {
-      empty: () => CollectionReference.Default("", ""),
+    Updaters: Object.assign(Object.assign({}, simpleUpdater()("Id")), simpleUpdater()("DisplayValue")),
+    Operations: {
+        IsCollectionReference: (value) => {
+            return typeof value == "object" && value.Id && value.DisplayValue;
+        },
     },
-  ),
-  Updaters: Object.assign(
-    Object.assign({}, simpleUpdater()("Id")),
-    simpleUpdater()("DisplayValue"),
-  ),
-  Operations: {
-    IsCollectionReference: (value) => {
-      return typeof value == "object" && value.Id && value.DisplayValue;
-    },
-  },
 };
 export const EnumReference = {
-  Default: (value) => ({
-    Value: value,
-  }),
-  Updaters: Object.assign({}, simpleUpdater()("Value")),
-  Operations: {
-    IsEnumReference: (value) => {
-      return typeof value == "object" && value.Value;
+    Default: (value) => ({
+        Value: value,
+    }),
+    Updaters: Object.assign({}, simpleUpdater()("Value")),
+    Operations: {
+        IsEnumReference: (value) => {
+            return typeof value == "object" && value.Value;
+        },
     },
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/collection/domains/selection/state.js

@@ -1,3 +1,3 @@
 import { Sum } from "../../../../../../main";
 export const CollectionSelection = () => Sum();
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map