ballerina-core 1.0.0

package/src/fun/domains/updater/state.ts

@@ -0,0 +1,86 @@
+import { BasicFun, Fun } from "../../state";
+
+export type BasicUpdater<e> = BasicFun<e, e>;
+
+export type Updater<e> = BasicUpdater<e> & {
+  fun: Fun<e, e>;
+  then(other: BasicUpdater<e>): Updater<e>;
+  thenMany(others: Array<BasicUpdater<e>>): Updater<e>;
+};
+
+export const Updater = <e>(u: BasicUpdater<e>): Updater<e> => {
+  return Object.assign(u, {
+    fun: Fun(u),
+    then: function (this: Updater<e>, other: BasicUpdater<e>): Updater<e> {
+      return Updater<e>(_ => other(this(_)));
+    },
+    thenMany: function (this: Updater<e>, others: Array<BasicUpdater<e>>): Updater<e> {
+      return Updater<e>(others.map(_ => Updater(_)).reduce((f, g) => f.then(g), this));
+    }
+  });
+}
+				     
+/*export const Updater = Object.assign(<e>(_: BasicUpdater<e>): Updater<e> => {
+  const u = _ as Updater<e>;
+  u.fun = Fun(u);
+  u.thenMany = function (this: Updater<e>, others: Array<BasicUpdater<e>>): Updater<e> {
+    return Updater<e>(others.map(_ => Updater(_)).reduce((f, g) => f.then(g), this));
+  };
+  u.then = function (this: Updater<e>, other: BasicUpdater<e>): Updater<e> {
+    return Updater<e>(_ => other(this(_)));
+  };
+  return u;
+}, {
+  withState:<e>(_: BasicFun<e,BasicUpdater<e>>) : Updater<e> =>
+    Updater(e => _(e)(e))
+    });
+*/
+
+/*
+// little testing playground and microsample: please do not remove
+import { simpleUpdater, simpleUpdaterWithChildren } from "./domains/simpleUpdater/state";
+type City = { name: string, population: number }
+const City = {
+  Default: (): City => ({
+    name: "Mirano", population: 25000
+  }),
+  Updaters: {
+    Core: {
+      ...simpleUpdater<City>()("name"),
+      ...simpleUpdater<City>()("population"),
+    }
+  }
+}
+type Address = { street: string, number: number, city: City}
+const Address = {
+  Default: (): Address => ({
+    street: "via Don Minzoni", number: 20, city: City.Default()
+  }),
+  Updaters: {
+    Core: {
+	...simpleUpdater<Address>()("street"),
+	...simpleUpdater<Address>()("number"),
+       ...simpleUpdaterWithChildren<Address>()(City.Updaters)("city"),
+    }
+  }
+}
+type Person = { name: string, surname: string, address: Address }
+const Person = {
+  Default: (): Person => ({
+    name: "John", surname: "Doe", address: Address.Default()
+  }),
+  Updaters: {
+    Core: {
+      ...simpleUpdater<Person>()("name"),
+      ...simpleUpdater<Person>()("surname"),
+      ...simpleUpdaterWithChildren<Person>()(Address.Updaters)("address"),
+    }
+  }
+}
+const personAndAddressUpdater:Updater<Person> =
+    Person.Updaters.Core.name(_ => `Dr. ${_}`).then(
+	Person.Updaters.Core.surname(_ => `${_}, von`)
+    ).then(
+	Person.Updaters.Core.address.children.Core.city.Core.name(_ => `${_} the Great`)
+    )
+*/

package/src/fun/state.ts

@@ -0,0 +1,33 @@
+export type BasicFun<a,b> = (_:a) => b
+
+export type Fun<a,b> = BasicFun<a,b> & { then<c>(other:BasicFun<b,c>) : Fun<a,c> }
+
+export const Fun = <a,b>(_:BasicFun<a,b>) : Fun<a,b> =>
+  Object.assign(_, {
+    then: function <c>(this:Fun<a,b>, other:BasicFun<b,c>) : Fun<a,c> {
+      return Fun(_ => other(this(_)))
+    }
+  })
+
+
+export type BasicFun2<a,b,c> = (_:a, __:b) => c
+
+export type Fun2<a,b,c> = BasicFun2<a,b,c> & { then<d>(other:BasicFun<c,d>) : Fun2<a,b,d> }
+export const Fun2 = <a,b,c>(_:BasicFun2<a,b,c>) : Fun2<a,b,c> =>
+  Object.assign(_, {
+    then: function <d>(this:Fun2<a,b,c>, other:BasicFun<c,d>) : Fun2<a,b,d> {
+      return Fun2((a,b) => other(this(a,b)))
+    }
+  })
+
+
+/*
+// samples
+const incr: Fun<number,number> = Fun(_ => _ + 1)
+const decr: Fun<number,number> = Fun(_ => _ - 1)
+const doub: Fun<number,number> = Fun(_ => _ * 2)
+const halv: Fun<number,number> = Fun(_ => _ / 2)
+
+const f = incr.then(doub).then(decr)
+console.log(f(5)) // prints 11
+*/

package/src/infinite-data-stream/coroutines/builder.ts

@@ -0,0 +1,8 @@
+import { CoTypedFactory } from "../../coroutines/builder";
+import { InfiniteStreamReadonlyState, InfiniteStreamWritableState } from "../state";
+
+export const StreamCo = <Element extends { id: string }>() =>
+  CoTypedFactory<
+    InfiniteStreamReadonlyState,
+    InfiniteStreamWritableState<Element>
+  >();

package/src/infinite-data-stream/coroutines/infiniteLoader.ts

@@ -0,0 +1,51 @@
+import { AsyncState } from "../../async/state";
+import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state";
+import { InfiniteStreamState, StreamPosition } from "../state";
+import { StreamCo } from "./builder";
+
+export const InfiniteStreamLoader = <Element extends { id: string }>() => {
+  const Co = StreamCo<Element>();
+  const updaters = InfiniteStreamState<Element>().Updaters;
+  // const operations = InfiniteStreamState<Element>().Operations;
+
+  return Co.Seq([
+    Co.SetState(
+      updaters.Core.loadingMore(
+        replaceWith(AsyncState.Default.loading())
+      )
+    ),
+    Co.While(
+      ([current]) => current.loadingMore.kind != "loaded",
+      Co.GetState().then((current) => {
+        return Co.Await(
+          () => current.getChunk([current.position]),
+          () => "error" as const
+        ).then((apiResult) => {
+          if (apiResult.kind == "l") {
+            return Co.SetState(
+              updaters.Core.loadingMore(
+                replaceWith(AsyncState.Default.loaded({}))
+              ).then(
+                updaters.Coroutine.addLoadedChunk(
+                  current.position.chunkIndex,
+                  apiResult.value
+                ).then(
+                  updaters.Core.position(
+                    StreamPosition.Updaters.Core.shouldLoad(
+                      replaceWith<StreamPosition["shouldLoad"]>(false)
+                    )
+                  )
+                )
+              )
+            );
+          } else {
+            return Co.Wait(500);
+          }
+        })
+      }
+      )
+    )
+  ])
+};
+
+export const Loader = InfiniteStreamLoader

package/src/infinite-data-stream/coroutines/runner.ts

@@ -0,0 +1,12 @@
+import { InfiniteStreamReadonlyState, InfiniteStreamWritableState, InfiniteStreamState } from "../state";
+import { StreamCo } from "./builder";
+import { Loader } from "./infiniteLoader";
+
+export const StreamDataLoader =
+  <Element extends { id: string }, foreignMutations>() => {
+    const operations = InfiniteStreamState<Element>().Operations;
+    const LoaderTemplate = StreamCo<Element>().Template<foreignMutations>(Loader<Element>(), { 
+      runFilter:props => operations.shouldCoroutineRun(props.context) 
+    })
+    return LoaderTemplate.mapContext<InfiniteStreamReadonlyState & InfiniteStreamWritableState<Element>>(_ => _)
+  }

package/src/infinite-data-stream/state.ts

@@ -0,0 +1,175 @@
+import { OrderedMap } from "immutable";
+import { BasicUpdater, Updater } from "../fun/domains/updater/state";
+import { replaceWith } from "../fun/domains/updater/domains/replaceWith/state";
+import { simpleUpdater } from "../fun/domains/updater/domains/simpleUpdater/state";
+import { AsyncState } from "../async/state";
+import { Unit } from "../fun/domains/unit/state";
+import { BasicFun } from "../fun/state";
+
+export type StreamingStatus = "reload" | "loadMore" | false;
+
+type Identifiable = { id: string };
+
+export type StreamPosition = {
+  chunkSize: number;
+  chunkIndex: number;
+  shouldLoad: StreamingStatus;
+  lastModifiedTime: number;
+};
+
+export const StreamPosition = {
+  Default: (
+    initialChunkSize: number,
+    shouldLoad: StreamingStatus = false
+  ): StreamPosition => ({
+    chunkSize: initialChunkSize,
+    chunkIndex: 0,
+    shouldLoad,
+    lastModifiedTime: Date.now(),
+  }),
+  Updaters: {
+    Template: {
+      changeChunkSize: (chunkSize: number): Updater<StreamPosition> =>
+        StreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(
+          StreamPosition.Updaters.Template.reload()
+        ),
+      reload: (): Updater<StreamPosition> =>
+        StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
+          .then(
+            StreamPosition.Updaters.Core.shouldLoad(
+              replaceWith<StreamPosition["shouldLoad"]>("reload")
+            )
+          )
+          .then(
+            StreamPosition.Updaters.Core.chunkIndex(
+              replaceWith<StreamPosition["chunkIndex"]>(0)
+            )
+          ),
+      loadMore: (): Updater<StreamPosition> =>
+        StreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(
+          StreamPosition.Updaters.Core.lastModifiedTime(
+            replaceWith(Date.now())
+          ).then(
+            StreamPosition.Updaters.Core.shouldLoad(
+              replaceWith<StreamPosition["shouldLoad"]>("loadMore")
+            )
+          )
+        ),
+    },
+    Core: {
+      ...simpleUpdater<StreamPosition>()("lastModifiedTime"),
+      ...simpleUpdater<StreamPosition>()("shouldLoad"),
+      ...simpleUpdater<StreamPosition>()("chunkIndex"),
+      ...simpleUpdater<StreamPosition>()("chunkSize"),
+    },
+    Coroutine: {},
+  },
+};
+
+export type Chunk<Element extends Identifiable> = {
+  hasMoreValues: boolean;
+  data: OrderedMap<Element["id"], Element>;
+};
+export const Chunk = <Element extends Identifiable>() => ({
+  Default:(
+    hasMoreValues: boolean,
+    data: OrderedMap<Element["id"], Element>,
+  ) : Chunk<Element> => ({
+    hasMoreValues, data
+  })
+})
+
+export type InfiniteStreamState<Element extends Identifiable> = {
+  loadingMore: AsyncState<Unit>;
+  loadedElements: OrderedMap<StreamPosition["chunkIndex"], Chunk<Element>>;
+  position: StreamPosition;
+  getChunk: BasicFun<[StreamPosition], Promise<Chunk<Element>>>;
+};
+
+export const InfiniteStreamState = <Element extends Identifiable>() => ({
+  Default: (
+    initialChunkSize: number,
+    getChunk: InfiniteStreamState<Element>["getChunk"],
+    shouldLoad?: StreamingStatus
+  ): InfiniteStreamState<Element> => ({
+    loadingMore: AsyncState.Default.unloaded(),
+    loadedElements: OrderedMap(),
+    position: StreamPosition.Default(initialChunkSize, shouldLoad),
+    getChunk,
+  }),
+  Operations: {
+    shouldCoroutineRun: (current: InfiniteStreamState<Element>): boolean =>
+      current.position.shouldLoad != false,
+    loadNextPage: (current: InfiniteStreamState<Element>): boolean =>
+      current.position.shouldLoad !== false &&
+      current.loadedElements.last()?.hasMoreValues !== false,
+  },
+  Updaters: {
+    Coroutine: {
+      addLoadedChunk: (
+        chunkIndex: number,
+        newChunk: Chunk<Element>
+      ): Updater<InfiniteStreamState<Element>> =>
+        InfiniteStreamState<Element>().Updaters.Core.loadedElements((_) =>
+          _.set(chunkIndex, newChunk)
+        ),
+    },
+    Core: {
+      ...simpleUpdater<InfiniteStreamState<Element>>()("getChunk"),
+      ...simpleUpdater<InfiniteStreamState<Element>>()("loadingMore"),
+      ...simpleUpdater<InfiniteStreamState<Element>>()("loadedElements"),
+      whenNotAlreadyLoading: (
+        _: BasicUpdater<InfiniteStreamState<Element>>
+      ): Updater<InfiniteStreamState<Element>> => {
+        return Updater((current) => {
+          if (InfiniteStreamState<Element>().Operations.loadNextPage(current)) {
+            return current;
+          }
+          return _(current);
+        });
+      },
+      position: (
+        positionUpdater: Updater<InfiniteStreamState<Element>["position"]>
+      ): Updater<InfiniteStreamState<Element>> =>
+        Updater((current) => {
+          const newPosition = positionUpdater(current.position);
+          let newState = current;
+          if (newPosition.chunkSize != current.position.chunkSize)
+            newState =
+              InfiniteStreamState<Element>().Updaters.Core.clearLoadedElements()(
+                newState
+              );
+          return { ...newState, position: newPosition };
+        }),
+      clearLoadedElements: (): Updater<InfiniteStreamState<Element>> =>
+        InfiniteStreamState<Element>().Updaters.Core.loadedElements((_) =>
+          OrderedMap()
+        ),
+    },
+    Template: {
+      reload: (
+        getChunk: InfiniteStreamState<Element>["getChunk"]
+      ): Updater<InfiniteStreamState<Element>> =>
+        InfiniteStreamState<Element>()
+          .Updaters.Core.position(StreamPosition.Updaters.Template.reload())
+          .then(
+            InfiniteStreamState<Element>().Updaters.Core.clearLoadedElements()
+          )
+          .then(
+            InfiniteStreamState<Element>().Updaters.Core.getChunk(
+              replaceWith(getChunk)
+            )
+          ),
+      loadMore: (): Updater<InfiniteStreamState<Element>> =>
+        InfiniteStreamState<Element>().Updaters.Core.whenNotAlreadyLoading(
+          InfiniteStreamState<Element>().Updaters.Core.position(
+            StreamPosition.Updaters.Template.loadMore()
+          )
+        ),
+    },
+  },
+});
+
+export type InfiniteStreamReadonlyState = Unit;
+export type InfiniteStreamWritableState<Element extends { id: string }> =
+  InfiniteStreamState<Element>;

package/src/infinite-data-stream/template.tsx

@@ -0,0 +1,16 @@
+import { Unit } from "../fun/domains/unit/state";
+import { Template } from "../template/state";
+import { StreamDataLoader } from "./coroutines/runner";
+import { InfiniteStreamReadonlyState, InfiniteStreamWritableState } from "./state";
+
+export const InfiniteStreamTemplate =
+  <Element extends { id: string }>() => Template.Default<
+    InfiniteStreamReadonlyState,
+    InfiniteStreamWritableState<Element>,
+    Unit
+  >((_props) =>
+    <>{
+    }</>
+  ).any([
+    StreamDataLoader<Element, Unit>()
+  ])

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

@@ -0,0 +1,12 @@
+export const DomRectRepo = {
+  Operations:{
+    rectanglesIntersect:(r1: DOMRect, r2: DOMRect) => {
+      return !(
+        r2.left > r1.right ||
+        r2.right < r1.left ||
+        r2.top > r1.bottom ||
+        r2.bottom < r1.top
+      );
+    }
+  }
+} 

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

@@ -0,0 +1,9 @@
+export const numberRepo = {
+  Operations:
+  {
+    lerp: (a: number, min: number, max: number) =>
+      min + (max - min) * a,
+    clamp: (a: number, min: number, max: number) =>
+      Math.max(Math.min(a, max), min),
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Visibility } from "../../../visibility/state";
+
+export type Rect = { top: number; left: number; bottom: number; right: number; };
+export const Rect = {
+  Operations:{
+    IsElementInViewport(rect: Rect, windowRect: Rect): Visibility {
+      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";
+    }
+    
+  }
+}

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

@@ -0,0 +1,87 @@
+export type RGBAColor = { readonly r: number, readonly g: number, readonly b: number, readonly a: number }
+export const RGBAColor = {
+  Default:
+    Object.assign((r: number, g: number, b: number, a: number): RGBAColor => ({ r, g, b, a }),
+      {
+        zero: (): RGBAColor => RGBAColor.Default(0, 0, 0, 0),
+        fromHSL: (hue: number, sat: number, light: number): RGBAColor => {
+          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 }: RGBAColor) => {
+      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: number, t2: number, hue: number) => {
+      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;
+    }
+  }
+}

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

@@ -0,0 +1,14 @@
+export type Size2 = { readonly width:number, readonly height:number }
+export const Size2 = {
+  Default:
+    Object.assign((width:number,height:number) : Size2 => ({ width, height }),
+    {
+      zero:() : Size2 => Size2.Default(0,0),
+    }),
+    Updaters:{
+
+    },
+    Operations:{
+
+    }
+}

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

@@ -0,0 +1,16 @@
+export type Vector2 = { readonly x:number, readonly y:number }
+export const Vector2 = {
+  Default:
+    Object.assign((x:number,y:number) : Vector2 => ({ x, y }),
+    {
+      zero:() : Vector2 => Vector2.Default(0,0),
+      one_x:() : Vector2 => Vector2.Default(1,0),
+      one_y:() : Vector2 => Vector2.Default(0,1),
+    }),
+    Updaters:{
+
+    },
+    Operations:{
+
+    }
+}

package/src/queue/state.ts

@@ -0,0 +1,42 @@
+import { OrderedMap } from "immutable";
+import { Guid, Unit, SynchronizationResult } from "../../main";
+import { CoTypedFactory } from "../coroutines/builder";
+import { Coroutine } from "../coroutines/state";
+import { BasicFun } from "../fun/state";
+
+
+export const QueueCoroutine = <Context, State>(
+  removeItem: BasicFun<Guid, Coroutine<Context & State, State, Unit>>,
+  getItemsToProcess: BasicFun<Context & State, OrderedMap<Guid, {
+    preprocess: Coroutine<Context & State, State, Unit>;
+    operation: Coroutine<Context & State, State, SynchronizationResult>;
+    postprocess: BasicFun<SynchronizationResult, Coroutine<Context & State, State, Unit>>;
+    reenqueue: Coroutine<Context & State, State, Unit>;
+  }>>
+): Coroutine<Context & State, State, Unit> => {
+  const Co = CoTypedFactory<Context, State>();
+
+  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(_ =>
+                // alert(`${JSON.stringify(k)} => ${_}\n`)
+                k.postprocess(_).then(() => {
+                  if (_ == "completed") {
+                    return Co.Return({});
+                  } else {
+                    return k.reenqueue;
+                  }
+                })
+              ).then(() => removeItem(id))
+            )
+        ),
+      ]);
+    })
+  );
+};

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

@@ -0,0 +1,14 @@
+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;
+}
+
+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>;
+};