ballerina-core 1.0.256 → 1.0.258

package/bin/src/state/domains/repository/state.d.ts

@@ -2,14 +2,20 @@ import { ForeignMutationsInput } from "../../../foreignMutations/state";
 import { Unit } from "../../../fun/domains/unit/state";
 import { BasicFun } from "../../../fun/state";
 export type Updaters = {
-    Core: Unit;
-    Template: Unit;
-    Coroutine: Unit;
+  Core: Unit;
+  Template: Unit;
+  Coroutine: Unit;
 };
-export type Repository<Context, State, Input, ActualUpdaters extends Updaters, Operations = Unit> = {
-    Default: BasicFun<Input, State>;
-    Updaters: ActualUpdaters;
-    Operations: Operations;
-    ForeignMutations: BasicFun<ForeignMutationsInput<Context, State>, Unit>;
+export type Repository<
+  Context,
+  State,
+  Input,
+  ActualUpdaters extends Updaters,
+  Operations = Unit,
+> = {
+  Default: BasicFun<Input, State>;
+  Updaters: ActualUpdaters;
+  Operations: Operations;
+  ForeignMutations: BasicFun<ForeignMutationsInput<Context, State>, Unit>;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/state/domains/repository/state.js

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

package/bin/src/template/state.js

@@ -1,126 +1,174 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { unit } from "../../main";
 export const createTemplate = (actual) => {
-    const result = actual;
-    result.wrap = function (Wrapper) {
-        return Template.Operations.Wrap(this, Wrapper);
-    };
-    result.withView = function (view) {
-        return Template.Operations.WithView(this, view);
-    };
-    result.withViewFromProps = function (f) {
-        return Template.Operations.WithViewFromProps(this, f);
-    };
-    result.mapState = function (f) {
-        return Template.Operations.MapState(this, f);
-    };
-    result.mapStateFromProps = function (f) {
-        return Template.Operations.MapStateFromProps(this, f);
-    };
-    result.mapContext = function (f) {
-        return Template.Operations.MapContext(this, f);
-    };
-    result.mapForeignMutations = function (f) {
-        return Template.Operations.MapForeignMutations(this, f);
-    };
-    result.mapContextFromProps = function (f) {
-        return Template.Operations.MapContextFromProps(this, f);
-    };
-    result.mapForeignMutationsFromProps = function (f) {
-        return Template.Operations.MapForeignMutationsFromProps(this, f);
-    };
-    result.mapView = function (f) {
-        return Template.Operations.MapView(this, f);
-    };
-    result.mapViewFromProps = function (f) {
-        return Template.Operations.MapViewFromProps(this, f);
-    };
-    result.any = function (others) {
-        return Template.Operations.Any(this, others);
-    };
-    return result;
+  const result = actual;
+  result.wrap = function (Wrapper) {
+    return Template.Operations.Wrap(this, Wrapper);
+  };
+  result.withView = function (view) {
+    return Template.Operations.WithView(this, view);
+  };
+  result.withViewFromProps = function (f) {
+    return Template.Operations.WithViewFromProps(this, f);
+  };
+  result.mapState = function (f) {
+    return Template.Operations.MapState(this, f);
+  };
+  result.mapStateFromProps = function (f) {
+    return Template.Operations.MapStateFromProps(this, f);
+  };
+  result.mapContext = function (f) {
+    return Template.Operations.MapContext(this, f);
+  };
+  result.mapForeignMutations = function (f) {
+    return Template.Operations.MapForeignMutations(this, f);
+  };
+  result.mapContextFromProps = function (f) {
+    return Template.Operations.MapContextFromProps(this, f);
+  };
+  result.mapForeignMutationsFromProps = function (f) {
+    return Template.Operations.MapForeignMutationsFromProps(this, f);
+  };
+  result.mapView = function (f) {
+    return Template.Operations.MapView(this, f);
+  };
+  result.mapViewFromProps = function (f) {
+    return Template.Operations.MapViewFromProps(this, f);
+  };
+  result.any = function (others) {
+    return Template.Operations.Any(this, others);
+  };
+  return result;
 };
 export const Template = {
-    Default: (actual) => createTemplate(actual),
-    Operations: {
-        Wrap: (p, Wrapper) => createTemplate((props) => _jsx(Wrapper, { children: p(props) })),
-        WithView: (p, view) => createTemplate((props) => (_jsx(_Fragment, { children: p(Object.assign(Object.assign({}, props), { view: view })) }))),
-        WithViewFromProps: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p(Object.assign(Object.assign({}, props), { view: f(props) })) }))),
-        MapState: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: (_) => props.setState(f(_)),
-                foreignMutations: props.foreignMutations,
-                view: props.view,
-            }) }))),
-        MapStateFromProps: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: (_) => props.setState(f([props, _])),
-                foreignMutations: props.foreignMutations,
-                view: props.view,
-            }) }))),
-        MapContext: (p, f) => createTemplate((props) => {
-            const context = f(props.context);
-            if (!context)
-                return _jsx(_Fragment, {});
-            return (_jsx(_Fragment, { children: p({
-                    context: context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: props.view,
-                }) }));
+  Default: (actual) => createTemplate(actual),
+  Operations: {
+    Wrap: (p, Wrapper) =>
+      createTemplate((props) => _jsx(Wrapper, { children: p(props) })),
+    WithView: (p, view) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p(Object.assign(Object.assign({}, props), { view: view })),
         }),
-        MapForeignMutations: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: props.setState,
-                foreignMutations: f(props.foreignMutations),
-                view: props.view,
-            }) }))),
-        MapContextFromProps: (p, f) => createTemplate((props) => {
-            const context = f(props);
-            if (!context)
-                return _jsx(_Fragment, {});
-            return (_jsx(_Fragment, { children: p({
-                    context: context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: props.view,
-                }) }));
+      ),
+    WithViewFromProps: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p(
+            Object.assign(Object.assign({}, props), { view: f(props) }),
+          ),
         }),
-        MapForeignMutationsFromProps: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: props.setState,
-                foreignMutations: f(props),
-                view: props.view,
-            }) }))),
-        Any: (p, others) => createTemplate((props) => {
-            return (_jsx(_Fragment, { children: [
-                    p(props),
-                    ...others.map((_) => _({
-                        context: props.context,
-                        setState: props.setState,
-                        foreignMutations: props.foreignMutations,
-                        view: unit,
-                    })),
-                ] }));
+      ),
+    MapState: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: (_) => props.setState(f(_)),
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
+        }),
+      ),
+    MapStateFromProps: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: (_) => props.setState(f([props, _])),
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
         }),
-        MapView: (p, f) => createTemplate((props) => {
-            const view = f(props.view);
-            return (_jsx(_Fragment, { children: p({
-                    context: props.context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: view,
-                }) }));
+      ),
+    MapContext: (p, f) =>
+      createTemplate((props) => {
+        const context = f(props.context);
+        if (!context) return _jsx(_Fragment, {});
+        return _jsx(_Fragment, {
+          children: p({
+            context: context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
+        });
+      }),
+    MapForeignMutations: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: f(props.foreignMutations),
+            view: props.view,
+          }),
         }),
-        MapViewFromProps: (p, f) => createTemplate((props) => {
-            const view = f(props);
-            return (_jsx(_Fragment, { children: p({
-                    context: props.context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: view,
-                }) }));
+      ),
+    MapContextFromProps: (p, f) =>
+      createTemplate((props) => {
+        const context = f(props);
+        if (!context) return _jsx(_Fragment, {});
+        return _jsx(_Fragment, {
+          children: p({
+            context: context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
+        });
+      }),
+    MapForeignMutationsFromProps: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: f(props),
+            view: props.view,
+          }),
         }),
-    },
+      ),
+    Any: (p, others) =>
+      createTemplate((props) => {
+        return _jsx(_Fragment, {
+          children: [
+            p(props),
+            ...others.map((_) =>
+              _({
+                context: props.context,
+                setState: props.setState,
+                foreignMutations: props.foreignMutations,
+                view: unit,
+              }),
+            ),
+          ],
+        });
+      }),
+    MapView: (p, f) =>
+      createTemplate((props) => {
+        const view = f(props.view);
+        return _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: view,
+          }),
+        });
+      }),
+    MapViewFromProps: (p, f) =>
+      createTemplate((props) => {
+        const view = f(props);
+        return _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: view,
+          }),
+        });
+      }),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/validation/state.js

@@ -1,51 +1,44 @@
 import { Sum, unit } from "../../main";
 export const parse = (entityDescriptor) => (raw) => {
-    if (entityDescriptor == "date") {
-        if (typeof raw == "string") {
-            const parsedTimestamp = Date.parse(raw);
-            if (!Number.isNaN(parsedTimestamp))
-                return Sum.Default.right(new Date(parsedTimestamp));
-        }
-        return Sum.Default.left(unit);
+  if (entityDescriptor == "date") {
+    if (typeof raw == "string") {
+      const parsedTimestamp = Date.parse(raw);
+      if (!Number.isNaN(parsedTimestamp))
+        return Sum.Default.right(new Date(parsedTimestamp));
     }
-    if (entityDescriptor == "number") {
-        if (typeof raw == "number")
-            return Sum.Default.right(raw);
-        else if (typeof raw == "string") {
-            let parsedNumber = parseInt(raw);
-            if (!Number.isNaN(parsedNumber))
-                return Sum.Default.right(parsedNumber);
-            parsedNumber = parseFloat(raw);
-            if (!Number.isNaN(parsedNumber))
-                return Sum.Default.right(parsedNumber);
-        }
-        return Sum.Default.left(unit);
+    return Sum.Default.left(unit);
+  }
+  if (entityDescriptor == "number") {
+    if (typeof raw == "number") return Sum.Default.right(raw);
+    else if (typeof raw == "string") {
+      let parsedNumber = parseInt(raw);
+      if (!Number.isNaN(parsedNumber)) return Sum.Default.right(parsedNumber);
+      parsedNumber = parseFloat(raw);
+      if (!Number.isNaN(parsedNumber)) return Sum.Default.right(parsedNumber);
     }
-    if (entityDescriptor == "boolean") {
-        if (typeof raw == "boolean")
-            return Sum.Default.right(raw);
-        else if (typeof raw == "string") {
-            let parsedBoolean = raw == "true" ? true : raw == "false" ? false : undefined;
-            if (parsedBoolean != undefined)
-                return Sum.Default.right(parsedBoolean);
-        }
-        return Sum.Default.left(unit);
+    return Sum.Default.left(unit);
+  }
+  if (entityDescriptor == "boolean") {
+    if (typeof raw == "boolean") return Sum.Default.right(raw);
+    else if (typeof raw == "string") {
+      let parsedBoolean =
+        raw == "true" ? true : raw == "false" ? false : undefined;
+      if (parsedBoolean != undefined) return Sum.Default.right(parsedBoolean);
     }
-    if (entityDescriptor == "string") {
-        if (typeof raw == "string")
-            return Sum.Default.right(raw);
-        return Sum.Default.left(unit);
-    }
-    let result = {};
-    for (const fieldName in entityDescriptor) {
-        const fieldDescriptor = entityDescriptor[fieldName];
-        if (fieldName in raw == false)
-            return Sum.Default.left(unit);
-        const parsedField = parse(fieldDescriptor)(raw[fieldName]);
-        if (parsedField.kind == "l")
-            return Sum.Default.left(unit);
-        result[fieldName] = parsedField.value;
-    }
-    return Sum.Default.right(raw);
+    return Sum.Default.left(unit);
+  }
+  if (entityDescriptor == "string") {
+    if (typeof raw == "string") return Sum.Default.right(raw);
+    return Sum.Default.left(unit);
+  }
+  let result = {};
+  for (const fieldName in entityDescriptor) {
+    const fieldDescriptor = entityDescriptor[fieldName];
+    if (fieldName in raw == false) return Sum.Default.left(unit);
+    const parsedField = parse(fieldDescriptor)(raw[fieldName]);
+    if (parsedField.kind == "l") return Sum.Default.left(unit);
+    result[fieldName] = parsedField.value;
+  }
+  return Sum.Default.right(raw);
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/value/domains/mutable-value/state.js

@@ -1,5 +1,6 @@
 import { Value } from "../../state";
 export const MutableValue = {
-    Default: (v, onChange) => (Object.assign(Object.assign({}, Value.Default(v)), { onChange })),
+  Default: (v, onChange) =>
+    Object.assign(Object.assign({}, Value.Default(v)), { onChange }),
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,14 +1,14 @@
 import { BasicUpdater, Updater } from "../fun/domains/updater/state";
 export type Value<v> = {
-    value: v;
+  value: v;
 };
 export declare const Value: {
-    Default: <v>(v: v) => Value<v>;
-    Updaters: {
-        value: <v>(_: BasicUpdater<v>) => Updater<Value<v>>;
-    };
-    Operations: {
-        value: <v>(_: Value<v>) => v;
-    };
+  Default: <v>(v: v) => Value<v>;
+  Updaters: {
+    value: <v>(_: BasicUpdater<v>) => Updater<Value<v>>;
+  };
+  Operations: {
+    value: <v>(_: Value<v>) => v;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/value/state.js

@@ -1,11 +1,14 @@
 import { Updater } from "../fun/domains/updater/state";
 export const Value = {
-    Default: (v) => ({ value: v }),
-    Updaters: {
-        value: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { value: _(current.value) }))),
-    },
-    Operations: {
-        value: (_) => _.value,
-    },
+  Default: (v) => ({ value: v }),
+  Updaters: {
+    value: (_) =>
+      Updater((current) =>
+        Object.assign(Object.assign({}, current), { value: _(current.value) }),
+      ),
+  },
+  Operations: {
+    value: (_) => _.value,
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/value-infinite-data-stream/coroutines/builder.js

@@ -1,3 +1,3 @@
 import { CoTypedFactory } from "../../coroutines/builder";
 export const ValueStreamCo = () => CoTypedFactory();
-//# sourceMappingURL=builder.js.map
+//# sourceMappingURL=builder.js.map

package/bin/src/value-infinite-data-stream/coroutines/infiniteLoader.js

@@ -1,27 +1,62 @@
 import { AsyncState } from "../../async/state";
 import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state";
-import { ValueInfiniteStreamState, ValueStreamPosition, } from "../state";
+import { ValueInfiniteStreamState, ValueStreamPosition } from "../state";
 import { ValueStreamCo } from "./builder";
 export const ValueInfiniteStreamLoader = (maxRetries = 3) => {
-    const Co = ValueStreamCo();
-    const updaters = ValueInfiniteStreamState.Updaters;
-    const attemptLoad = (retryCount = 0) => Co.GetState().then((current) => current.loadingMore.kind === "loaded"
+  const Co = ValueStreamCo();
+  const updaters = ValueInfiniteStreamState.Updaters;
+  const attemptLoad = (retryCount = 0) =>
+    Co.GetState().then((current) =>
+      current.loadingMore.kind === "loaded"
         ? Co.Return(true)
-        : Co.Await(() => current.getChunk([current.position]), () => "error").then((apiResult) => {
+        : Co.Await(
+            () => current.getChunk([current.position]),
+            () => "error",
+          ).then((apiResult) => {
             return apiResult.kind == "l"
-                ? Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.loaded({})))
-                    .then(updaters.Coroutine.addLoadedChunk(current.position.chunkIndex, apiResult.value).then(updaters.Core.position(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith(false)))))
-                    .then(updaters.Core.position(ValueStreamPosition.Updaters.Core.nextStart(replaceWith(apiResult.value.to)))))
-                : retryCount < maxRetries
-                    ? Co.Wait(500).then(() => attemptLoad(retryCount + 1))
-                    : Co.Return(false);
-        }));
-    return Co.Seq([
-        Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.loading()))),
-        attemptLoad(),
-        Co.GetState().then((current) => current.loadingMore.kind !== "loaded"
-            ? Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.error("max retries reached"))))
-            : Co.Wait(0)),
-    ]);
+              ? Co.SetState(
+                  updaters.Core.loadingMore(
+                    replaceWith(AsyncState.Default.loaded({})),
+                  )
+                    .then(
+                      updaters.Coroutine.addLoadedChunk(
+                        current.position.chunkIndex,
+                        apiResult.value,
+                      ).then(
+                        updaters.Core.position(
+                          ValueStreamPosition.Updaters.Core.shouldLoad(
+                            replaceWith(false),
+                          ),
+                        ),
+                      ),
+                    )
+                    .then(
+                      updaters.Core.position(
+                        ValueStreamPosition.Updaters.Core.nextStart(
+                          replaceWith(apiResult.value.to),
+                        ),
+                      ),
+                    ),
+                )
+              : retryCount < maxRetries
+                ? Co.Wait(500).then(() => attemptLoad(retryCount + 1))
+                : Co.Return(false);
+          }),
+    );
+  return Co.Seq([
+    Co.SetState(
+      updaters.Core.loadingMore(replaceWith(AsyncState.Default.loading())),
+    ),
+    attemptLoad(),
+    Co.GetState().then((current) =>
+      current.loadingMore.kind !== "loaded"
+        ? Co.SetState(
+            updaters.Core.loadingMore(
+              replaceWith(AsyncState.Default.error("max retries reached")),
+            ),
+          )
+        : Co.Wait(0),
+    ),
+  ]);
 };
-//# sourceMappingURL=infiniteLoader.js.map
+//# sourceMappingURL=infiniteLoader.js.map

package/bin/src/value-infinite-data-stream/coroutines/runner.js

@@ -1,7 +1,9 @@
 import { ValueInfiniteStreamState } from "../state";
 import { ValueStreamCo } from "./builder";
 import { ValueInfiniteStreamLoader } from "./infiniteLoader";
-export const ValueStreamDataLoader = () => ValueStreamCo().Template(ValueInfiniteStreamLoader(), {
-    runFilter: (props) => ValueInfiniteStreamState.Operations.shouldCoroutineRun(props.context),
-});
-//# sourceMappingURL=runner.js.map
+export const ValueStreamDataLoader = () =>
+  ValueStreamCo().Template(ValueInfiniteStreamLoader(), {
+    runFilter: (props) =>
+      ValueInfiniteStreamState.Operations.shouldCoroutineRun(props.context),
+  });
+//# sourceMappingURL=runner.js.map