ballerina-core 1.0.256 → 1.0.258

package/bin/src/infinite-data-stream/state.js

@@ -4,73 +4,137 @@ import { replaceWith } from "../fun/domains/updater/domains/replaceWith/state";
 import { simpleUpdater } from "../fun/domains/updater/domains/simpleUpdater/state";
 import { AsyncState } from "../async/state";
 export const StreamPosition = {
-    Default: (initialChunkSize, shouldLoad = false) => ({
-        chunkSize: initialChunkSize,
-        chunkIndex: 0,
-        shouldLoad,
-        lastModifiedTime: Date.now(),
-    }),
-    Updaters: {
-        Template: {
-            loadInitial: () => StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore"))),
-            changeChunkSize: (chunkSize) => StreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(StreamPosition.Updaters.Template.reload()),
-            reload: () => StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
-                .then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")))
-                .then(StreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
-            loadMore: () => StreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")))),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("lastModifiedTime")), simpleUpdater()("shouldLoad")), simpleUpdater()("chunkIndex")), simpleUpdater()("chunkSize")),
-        Coroutine: {},
+  Default: (initialChunkSize, shouldLoad = false) => ({
+    chunkSize: initialChunkSize,
+    chunkIndex: 0,
+    shouldLoad,
+    lastModifiedTime: Date.now(),
+  }),
+  Updaters: {
+    Template: {
+      loadInitial: () =>
+        StreamPosition.Updaters.Core.lastModifiedTime(
+          replaceWith(Date.now()),
+        ).then(
+          StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")),
+        ),
+      changeChunkSize: (chunkSize) =>
+        StreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(
+          StreamPosition.Updaters.Template.reload(),
+        ),
+      reload: () =>
+        StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
+          .then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")))
+          .then(StreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
+      loadMore: () =>
+        StreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(
+          StreamPosition.Updaters.Core.lastModifiedTime(
+            replaceWith(Date.now()),
+          ).then(
+            StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")),
+          ),
+        ),
     },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("lastModifiedTime")),
+          simpleUpdater()("shouldLoad"),
+        ),
+        simpleUpdater()("chunkIndex"),
+      ),
+      simpleUpdater()("chunkSize"),
+    ),
+    Coroutine: {},
+  },
 };
 export const Chunk = () => ({
-    Default: (hasMoreValues, data) => ({
-        hasMoreValues,
-        data,
-    }),
+  Default: (hasMoreValues, data) => ({
+    hasMoreValues,
+    data,
+  }),
 });
 export const InfiniteStreamState = () => ({
-    Default: (initialChunkSize, getChunk, shouldLoad) => ({
-        loadingMore: AsyncState.Default.unloaded(),
-        loadedElements: OrderedMap(),
-        position: StreamPosition.Default(initialChunkSize, shouldLoad),
-        getChunk,
-    }),
-    Operations: {
-        shouldCoroutineRun: (current) => current.position.shouldLoad != false,
-        loadNextPage: (current) => {
-            var _a;
-            return current.position.shouldLoad !== false &&
-                ((_a = current.loadedElements.last()) === null || _a === void 0 ? void 0 : _a.hasMoreValues) !== false;
-        },
+  Default: (initialChunkSize, getChunk, shouldLoad) => ({
+    loadingMore: AsyncState.Default.unloaded(),
+    loadedElements: OrderedMap(),
+    position: StreamPosition.Default(initialChunkSize, shouldLoad),
+    getChunk,
+  }),
+  Operations: {
+    shouldCoroutineRun: (current) => current.position.shouldLoad != false,
+    loadNextPage: (current) => {
+      var _a;
+      return (
+        current.position.shouldLoad !== false &&
+        ((_a = current.loadedElements.last()) === null || _a === void 0
+          ? void 0
+          : _a.hasMoreValues) !== false
+      );
     },
-    Updaters: {
-        Coroutine: {
-            addLoadedChunk: (chunkIndex, newChunk) => InfiniteStreamState().Updaters.Core.loadedElements((_) => _.set(chunkIndex, newChunk)),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("getChunk")), simpleUpdater()("loadingMore")), simpleUpdater()("loadedElements")), { whenNotAlreadyLoading: (_) => {
-                return Updater((current) => {
-                    if (InfiniteStreamState().Operations.loadNextPage(current)) {
-                        return current;
-                    }
-                    return _(current);
-                });
-            }, position: (positionUpdater) => Updater((current) => {
-                const newPosition = positionUpdater(current.position);
-                let newState = current;
-                if (newPosition.chunkSize != current.position.chunkSize)
-                    newState =
-                        InfiniteStreamState().Updaters.Core.clearLoadedElements()(newState);
-                return Object.assign(Object.assign({}, newState), { position: newPosition });
-            }), clearLoadedElements: () => InfiniteStreamState().Updaters.Core.loadedElements((_) => OrderedMap()) }),
-        Template: {
-            loadInitial: () => InfiniteStreamState().Updaters.Core.position(StreamPosition.Updaters.Template.loadInitial()),
-            reload: (getChunk) => InfiniteStreamState()
-                .Updaters.Core.position(StreamPosition.Updaters.Template.reload())
-                .then(InfiniteStreamState().Updaters.Core.clearLoadedElements())
-                .then(InfiniteStreamState().Updaters.Core.getChunk(replaceWith(getChunk))),
-            loadMore: () => InfiniteStreamState().Updaters.Core.whenNotAlreadyLoading(InfiniteStreamState().Updaters.Core.position(StreamPosition.Updaters.Template.loadMore())),
+  },
+  Updaters: {
+    Coroutine: {
+      addLoadedChunk: (chunkIndex, newChunk) =>
+        InfiniteStreamState().Updaters.Core.loadedElements((_) =>
+          _.set(chunkIndex, newChunk),
+        ),
+    },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("getChunk")),
+          simpleUpdater()("loadingMore"),
+        ),
+        simpleUpdater()("loadedElements"),
+      ),
+      {
+        whenNotAlreadyLoading: (_) => {
+          return Updater((current) => {
+            if (InfiniteStreamState().Operations.loadNextPage(current)) {
+              return current;
+            }
+            return _(current);
+          });
         },
+        position: (positionUpdater) =>
+          Updater((current) => {
+            const newPosition = positionUpdater(current.position);
+            let newState = current;
+            if (newPosition.chunkSize != current.position.chunkSize)
+              newState =
+                InfiniteStreamState().Updaters.Core.clearLoadedElements()(
+                  newState,
+                );
+            return Object.assign(Object.assign({}, newState), {
+              position: newPosition,
+            });
+          }),
+        clearLoadedElements: () =>
+          InfiniteStreamState().Updaters.Core.loadedElements((_) =>
+            OrderedMap(),
+          ),
+      },
+    ),
+    Template: {
+      loadInitial: () =>
+        InfiniteStreamState().Updaters.Core.position(
+          StreamPosition.Updaters.Template.loadInitial(),
+        ),
+      reload: (getChunk) =>
+        InfiniteStreamState()
+          .Updaters.Core.position(StreamPosition.Updaters.Template.reload())
+          .then(InfiniteStreamState().Updaters.Core.clearLoadedElements())
+          .then(
+            InfiniteStreamState().Updaters.Core.getChunk(replaceWith(getChunk)),
+          ),
+      loadMore: () =>
+        InfiniteStreamState().Updaters.Core.whenNotAlreadyLoading(
+          InfiniteStreamState().Updaters.Core.position(
+            StreamPosition.Updaters.Template.loadMore(),
+          ),
+        ),
     },
+  },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/infinite-data-stream/template.js

@@ -1,5 +1,6 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { Template } from "../template/state";
 import { StreamDataLoader } from "./coroutines/runner";
-export const InfiniteStreamTemplate = () => Template.Default((_props) => _jsx(_Fragment, {})).any([StreamDataLoader()]);
-//# sourceMappingURL=template.js.map
+export const InfiniteStreamTemplate = () =>
+  Template.Default((_props) => _jsx(_Fragment, {})).any([StreamDataLoader()]);
+//# sourceMappingURL=template.js.map

package/bin/src/math/domains/DOMRect/state.d.ts

@@ -1,6 +1,6 @@
 export declare const DomRectRepo: {
-    Operations: {
-        rectanglesIntersect: (r1: DOMRect, r2: DOMRect) => boolean;
-    };
+  Operations: {
+    rectanglesIntersect: (r1: DOMRect, r2: DOMRect) => boolean;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/DOMRect/state.js

@@ -1,11 +1,13 @@
 export const DomRectRepo = {
-    Operations: {
-        rectanglesIntersect: (r1, r2) => {
-            return !(r2.left > r1.right ||
-                r2.right < r1.left ||
-                r2.top > r1.bottom ||
-                r2.bottom < r1.top);
-        },
+  Operations: {
+    rectanglesIntersect: (r1, r2) => {
+      return !(
+        r2.left > r1.right ||
+        r2.right < r1.left ||
+        r2.top > r1.bottom ||
+        r2.bottom < r1.top
+      );
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/math/domains/number/state.d.ts

@@ -1,7 +1,7 @@
 export declare const numberRepo: {
-    Operations: {
-        lerp: (a: number, min: number, max: number) => number;
-        clamp: (a: number, min: number, max: number) => number;
-    };
+  Operations: {
+    lerp: (a: number, min: number, max: number) => number;
+    clamp: (a: number, min: number, max: number) => number;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/number/state.js

@@ -1,7 +1,7 @@
 export const numberRepo = {
-    Operations: {
-        lerp: (a, min, max) => min + (max - min) * a,
-        clamp: (a, min, max) => Math.max(Math.min(a, max), min),
-    },
+  Operations: {
+    lerp: (a, min, max) => min + (max - min) * a,
+    clamp: (a, min, max) => Math.max(Math.min(a, max), min),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/math/domains/rect/state.d.ts

@@ -1,13 +1,13 @@
 import { Visibility } from "../../../visibility/state";
 export type Rect = {
-    top: number;
-    left: number;
-    bottom: number;
-    right: number;
+  top: number;
+  left: number;
+  bottom: number;
+  right: number;
 };
 export declare const Rect: {
-    Operations: {
-        IsElementInViewport(rect: Rect, windowRect: Rect): Visibility;
-    };
+  Operations: {
+    IsElementInViewport(rect: Rect, windowRect: Rect): Visibility;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/rect/state.js

@@ -1,18 +1,19 @@
 export const Rect = {
-    Operations: {
-        IsElementInViewport(rect, windowRect) {
-            return rect.top >= 0 &&
-                // rect.left >= 0 &&
-                rect.bottom <= windowRect.bottom // &&
-                ? // rect.right <= windowRect.right
-                    "fully-visible"
-                : !(
-                //windowRect.left > rect.right ||
-                // windowRect.right < rect.left ||
-                (windowRect.top > rect.bottom || windowRect.bottom < rect.top))
-                    ? "partially-visible"
-                    : "fully-invisible";
-        },
+  Operations: {
+    IsElementInViewport(rect, windowRect) {
+      return rect.top >= 0 &&
+        // rect.left >= 0 &&
+        rect.bottom <= windowRect.bottom // &&
+        ? // rect.right <= windowRect.right
+          "fully-visible"
+        : !(
+              //windowRect.left > rect.right ||
+              // windowRect.right < rect.left ||
+              (windowRect.top > rect.bottom || windowRect.bottom < rect.top)
+            )
+          ? "partially-visible"
+          : "fully-invisible";
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/math/domains/rgba/state.d.ts

@@ -1,22 +1,22 @@
 export type RGBAColor = {
-    readonly r: number;
-    readonly g: number;
-    readonly b: number;
-    readonly a: number;
+  readonly r: number;
+  readonly g: number;
+  readonly b: number;
+  readonly a: number;
 };
 export declare const RGBAColor: {
-    Default: ((r: number, g: number, b: number, a: number) => RGBAColor) & {
-        zero: () => RGBAColor;
-        fromHSL: (hue: number, sat: number, light: number) => RGBAColor;
-    };
-    Updaters: {};
-    Operations: {
-        toHsl: ({ r, g, b }: RGBAColor) => {
-            h: number;
-            s: number;
-            l: number;
-        };
-        hueToRgb: (t1: number, t2: number, hue: number) => number;
+  Default: ((r: number, g: number, b: number, a: number) => RGBAColor) & {
+    zero: () => RGBAColor;
+    fromHSL: (hue: number, sat: number, light: number) => RGBAColor;
+  };
+  Updaters: {};
+  Operations: {
+    toHsl: ({ r, g, b }: RGBAColor) => {
+      h: number;
+      s: number;
+      l: number;
     };
+    hueToRgb: (t1: number, t2: number, hue: number) => number;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/rgba/state.js

@@ -1,84 +1,80 @@
 export const RGBAColor = {
-    Default: Object.assign((r, g, b, a) => ({ r, g, b, a }), {
-        zero: () => RGBAColor.Default(0, 0, 0, 0),
-        fromHSL: (hue, sat, light) => {
-            let t2;
-            hue = hue / 60;
-            if (light <= 0.5) {
-                t2 = light * (sat + 1);
-            }
-            else {
-                t2 = light + sat - light * sat;
-            }
-            const t1 = light * 2 - t2;
-            const r = RGBAColor.Operations.hueToRgb(t1, t2, hue + 2) * 255;
-            const g = RGBAColor.Operations.hueToRgb(t1, t2, hue) * 255;
-            const b = RGBAColor.Operations.hueToRgb(t1, t2, hue - 2) * 255;
-            return { r: r, g: g, b: b, a: 1.0 };
-        },
-    }),
-    Updaters: {},
-    Operations: {
-        toHsl: ({ r, g, b }) => {
-            let min, max, i, s, maxcolor, h = 0;
-            const rgb = [r / 255, g / 255, b / 255];
-            min = rgb[0];
-            max = rgb[0];
-            maxcolor = 0;
-            for (i = 0; i < rgb.length - 1; i++) {
-                if (rgb[i + 1] <= min) {
-                    min = rgb[i + 1];
-                }
-                if (rgb[i + 1] >= max) {
-                    max = rgb[i + 1];
-                    maxcolor = i + 1;
-                }
-            }
-            if (maxcolor == 0) {
-                h = (rgb[1] - rgb[2]) / (max - min);
-            }
-            if (maxcolor == 1) {
-                h = 2 + (rgb[2] - rgb[0]) / (max - min);
-            }
-            if (maxcolor == 2) {
-                h = 4 + (rgb[0] - rgb[1]) / (max - min);
-            }
-            if (isNaN(h)) {
-                h = 0;
-            }
-            h = h * 60;
-            if (h < 0) {
-                h = h + 360;
-            }
-            const l = (min + max) / 2;
-            if (min == max) {
-                s = 0;
-            }
-            else {
-                if (l < 0.5) {
-                    s = (max - min) / (max + min);
-                }
-                else {
-                    s = (max - min) / (2 - max - min);
-                }
-            }
-            s = s;
-            return { h: h, s: s, l: l };
-        },
-        hueToRgb: (t1, t2, hue) => {
-            if (hue < 0)
-                hue += 6;
-            if (hue >= 6)
-                hue -= 6;
-            if (hue < 1)
-                return (t2 - t1) * hue + t1;
-            else if (hue < 3)
-                return t2;
-            else if (hue < 4)
-                return (t2 - t1) * (4 - hue) + t1;
-            else
-                return t1;
-        },
+  Default: Object.assign((r, g, b, a) => ({ r, g, b, a }), {
+    zero: () => RGBAColor.Default(0, 0, 0, 0),
+    fromHSL: (hue, sat, light) => {
+      let t2;
+      hue = hue / 60;
+      if (light <= 0.5) {
+        t2 = light * (sat + 1);
+      } else {
+        t2 = light + sat - light * sat;
+      }
+      const t1 = light * 2 - t2;
+      const r = RGBAColor.Operations.hueToRgb(t1, t2, hue + 2) * 255;
+      const g = RGBAColor.Operations.hueToRgb(t1, t2, hue) * 255;
+      const b = RGBAColor.Operations.hueToRgb(t1, t2, hue - 2) * 255;
+      return { r: r, g: g, b: b, a: 1.0 };
     },
+  }),
+  Updaters: {},
+  Operations: {
+    toHsl: ({ r, g, b }) => {
+      let min,
+        max,
+        i,
+        s,
+        maxcolor,
+        h = 0;
+      const rgb = [r / 255, g / 255, b / 255];
+      min = rgb[0];
+      max = rgb[0];
+      maxcolor = 0;
+      for (i = 0; i < rgb.length - 1; i++) {
+        if (rgb[i + 1] <= min) {
+          min = rgb[i + 1];
+        }
+        if (rgb[i + 1] >= max) {
+          max = rgb[i + 1];
+          maxcolor = i + 1;
+        }
+      }
+      if (maxcolor == 0) {
+        h = (rgb[1] - rgb[2]) / (max - min);
+      }
+      if (maxcolor == 1) {
+        h = 2 + (rgb[2] - rgb[0]) / (max - min);
+      }
+      if (maxcolor == 2) {
+        h = 4 + (rgb[0] - rgb[1]) / (max - min);
+      }
+      if (isNaN(h)) {
+        h = 0;
+      }
+      h = h * 60;
+      if (h < 0) {
+        h = h + 360;
+      }
+      const l = (min + max) / 2;
+      if (min == max) {
+        s = 0;
+      } else {
+        if (l < 0.5) {
+          s = (max - min) / (max + min);
+        } else {
+          s = (max - min) / (2 - max - min);
+        }
+      }
+      s = s;
+      return { h: h, s: s, l: l };
+    },
+    hueToRgb: (t1, t2, hue) => {
+      if (hue < 0) hue += 6;
+      if (hue >= 6) hue -= 6;
+      if (hue < 1) return (t2 - t1) * hue + t1;
+      else if (hue < 3) return t2;
+      else if (hue < 4) return (t2 - t1) * (4 - hue) + t1;
+      else return t1;
+    },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/math/domains/size2/state.d.ts

@@ -1,12 +1,12 @@
 export type Size2 = {
-    readonly width: number;
-    readonly height: number;
+  readonly width: number;
+  readonly height: number;
 };
 export declare const Size2: {
-    Default: ((width: number, height: number) => Size2) & {
-        zero: () => Size2;
-    };
-    Updaters: {};
-    Operations: {};
+  Default: ((width: number, height: number) => Size2) & {
+    zero: () => Size2;
+  };
+  Updaters: {};
+  Operations: {};
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/size2/state.js

@@ -1,8 +1,8 @@
 export const Size2 = {
-    Default: Object.assign((width, height) => ({ width, height }), {
-        zero: () => Size2.Default(0, 0),
-    }),
-    Updaters: {},
-    Operations: {},
+  Default: Object.assign((width, height) => ({ width, height }), {
+    zero: () => Size2.Default(0, 0),
+  }),
+  Updaters: {},
+  Operations: {},
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/math/domains/vector2/state.d.ts

@@ -1,14 +1,14 @@
 export type Vector2 = {
-    readonly x: number;
-    readonly y: number;
+  readonly x: number;
+  readonly y: number;
 };
 export declare const Vector2: {
-    Default: ((x: number, y: number) => Vector2) & {
-        zero: () => Vector2;
-        one_x: () => Vector2;
-        one_y: () => Vector2;
-    };
-    Updaters: {};
-    Operations: {};
+  Default: ((x: number, y: number) => Vector2) & {
+    zero: () => Vector2;
+    one_x: () => Vector2;
+    one_y: () => Vector2;
+  };
+  Updaters: {};
+  Operations: {};
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/vector2/state.js

@@ -1,10 +1,10 @@
 export const Vector2 = {
-    Default: Object.assign((x, y) => ({ x, y }), {
-        zero: () => Vector2.Default(0, 0),
-        one_x: () => Vector2.Default(1, 0),
-        one_y: () => Vector2.Default(0, 1),
-    }),
-    Updaters: {},
-    Operations: {},
+  Default: Object.assign((x, y) => ({ x, y }), {
+    zero: () => Vector2.Default(0, 0),
+    one_x: () => Vector2.Default(1, 0),
+    one_y: () => Vector2.Default(0, 1),
+  }),
+  Updaters: {},
+  Operations: {},
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/queue/state.js

@@ -1,21 +1,28 @@
 import { CoTypedFactory } from "../coroutines/builder";
 export const QueueCoroutine = (removeItem, getItemsToProcess) => {
-    const Co = CoTypedFactory();
-    return Co.Repeat(Co.GetState().then((current) => {
-        let operations = getItemsToProcess(current);
-        return Co.Seq([
-            Co.All(operations.toArray().map(([id, k]) => k.preprocess
-                .then(() => k.operation)
-                .then((_) => k.postprocess(_).then(() => {
-                if (_.kind == "should be enqueued again") {
+  const Co = CoTypedFactory();
+  return Co.Repeat(
+    Co.GetState().then((current) => {
+      let operations = getItemsToProcess(current);
+      return Co.Seq([
+        Co.All(
+          operations.toArray().map(([id, k]) =>
+            k.preprocess
+              .then(() => k.operation)
+              .then((_) =>
+                k.postprocess(_).then(() => {
+                  if (_.kind == "should be enqueued again") {
                     return k.reenqueue(_);
-                }
-                else {
+                  } else {
                     return Co.Return({});
-                }
-            }))
-                .then(() => removeItem(id)))),
-        ]);
-    }));
+                  }
+                }),
+              )
+              .then(() => removeItem(id)),
+          ),
+        ),
+      ]);
+    }),
+  );
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map