ballerina-core 1.0.258 → 1.0.260

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

@@ -4,137 +4,73 @@ 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")),
-          ),
-        ),
+    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: {},
     },
-    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
-      );
-    },
-  },
-  Updaters: {
-    Coroutine: {
-      addLoadedChunk: (chunkIndex, newChunk) =>
-        InfiniteStreamState().Updaters.Core.loadedElements((_) =>
-          _.set(chunkIndex, newChunk),
-        ),
+    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;
+        },
     },
-    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);
-          });
+    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())),
         },
-        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,6 +1,5 @@
 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,13 +1,11 @@
 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,19 +1,18 @@
 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;
+    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;
     };
-    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,80 +1,84 @@
 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 };
+    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;
+        },
     },
-  }),
-  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,28 +1,21 @@
 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