ballerina-core 1.0.256 → 1.0.258

package/bin/src/coroutines/template.js

@@ -6,67 +6,105 @@ 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) {
-                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;
+  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);
-    }
-    shouldComponentUpdate() {
-        return false;
-    }
-    render() {
-        return _jsx(_Fragment, {});
-    }
+        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, {});
+  }
 }
-export const CoroutineTemplate = () => Template.Default((props) => {
+export const CoroutineTemplate = () =>
+  Template.Default((props) => {
     var _a, _b;
-    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, {
+    return _jsx(
+      CoroutineComponent,
+      {
         context: props.context,
+        initialCoroutine: props.context.initialCoroutine,
         setState: props.setState,
-        foreignMutations: unit,
-        view: unit,
-    })));
-});
-//# sourceMappingURL=template.js.map
+        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

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

@@ -1,98 +1,124 @@
 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"))),
+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),
+        ),
         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(() => { });
+          if (current.status.kind == "l") {
+            return Co.SetState(
+              updaters.Core.status(replaceWith("processing shortcircuited")),
+            );
+          } 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)),
-                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.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.GetState().then((current) => {
-                        if (current.status.kind == "l") {
-                            return Co.SetState(updaters.Core.status(replaceWith("processing finished")));
-                        }
-                        else
-                            return Co.Do(() => { });
+                      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)
-                ]).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),
-                            ]);
-                        }
-                    });
-                });
-            }),
-        ]),
-    ]);
+                  ]);
+                }
+              } 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,31 +1,68 @@
 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 }))),
-        },
-        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 }))),
-        },
+  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,
+          }),
+        ),
     },
-    Operations: {
-        shouldCoroutineRun: (_) => _.dirty != "not dirty",
+    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",
+  },
 };
-//# 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,9 +1,31 @@
-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,28 +1,34 @@
 import { simpleUpdater } from "../../../../../../main";
 export const CollectionReference = {
-    Default: Object.assign((Id, DisplayValue, source) => ({
-        Id,
-        DisplayValue,
-        source,
-    }), {
-        empty: () => CollectionReference.Default("", ""),
+  Default: Object.assign(
+    (Id, DisplayValue, source) => ({
+      Id,
+      DisplayValue,
+      source,
     }),
-    Updaters: Object.assign(Object.assign({}, simpleUpdater()("Id")), simpleUpdater()("DisplayValue")),
-    Operations: {
-        IsCollectionReference: (value) => {
-            return typeof value == "object" && value.Id && value.DisplayValue;
-        },
+    {
+      empty: () => CollectionReference.Default("", ""),
     },
+  ),
+  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