@planet-matrix/mobius-model 0.1.3 → 0.3.0

package/src/reactor/reactor-operators/index.ts

@@ -0,0 +1,7 @@
+export * from "./utility.ts"
+export * from "./convert.ts"
+export * from "./create.ts"
+export * from "./join.ts"
+export * from "./branch.ts"
+export * from "./map.ts"
+export * from "./filter.ts"

package/src/reactor/reactor-operators/join.ts

@@ -0,0 +1,174 @@
+import type { AnyValueReactorArray, AnyValueReactorObject, GetValuesInArray, GetValuesInObject } from "./utility.ts"
+import type { Effect, Signal, ValueReactor } from "../reactor-core/index.ts"
+
+import { castValueInitializer, getValuesInArray, getValuesInObject } from "./utility.ts"
+import { effect, signal } from "../reactor-core/index.ts"
+
+export type CombineLatestArray<T extends AnyValueReactorArray> = Signal<GetValuesInArray<T>>;
+export interface CombineLatestArrayOptions<T extends AnyValueReactorArray> {
+  target: T;
+}
+/**
+ * Combines multiple ValueReactors into a Signal that emits the latest values
+ * from each ValueReactor whenever any of them updates.
+ */
+export const combineLatestArray = <T extends AnyValueReactorArray>(
+  options: CombineLatestArrayOptions<T>
+): CombineLatestArray<T> => {
+  const { target } = options;
+
+  const result = signal(castValueInitializer<GetValuesInArray<T>>(), {
+    onDispose: () => {
+      e.dispose()
+    }
+  })
+
+  const e = effect(() => {
+    result.set(getValuesInArray({ target }))
+  })
+
+  return result
+}
+
+export type CombineLatestObject<T extends AnyValueReactorObject> = Signal<GetValuesInObject<T>>;
+export interface CombineLatestObjectOptions<T extends AnyValueReactorObject> {
+  target: T;
+}
+/**
+ * Combines multiple ValueReactors in an object into a Signal that emits the latest values
+ * from each ValueReactor whenever any of them updates.
+ */
+export const combineLatestObject = <T extends AnyValueReactorObject>(
+  options: CombineLatestObjectOptions<T>
+): CombineLatestObject<T> => {
+  const { target } = options;
+
+  const result = signal(castValueInitializer<GetValuesInObject<T>>(), {
+    onDispose: () => {
+      e.dispose()
+    }
+  })
+
+  const e = effect(() => {
+    result.set(getValuesInObject({ target }))
+  })
+
+  return result
+}
+
+export type MergeArray<T extends AnyValueReactorArray> = Signal<GetValuesInArray<T>[number]>;
+export interface MergeArrayOptions<T extends AnyValueReactorArray> {
+  target: T;
+}
+/**
+ * Merges multiple ValueReactors into a Signal that emits values
+ * from any of the ValueReactors as they update.
+ */
+export const mergeArray = <T extends AnyValueReactorArray>(
+  options: MergeArrayOptions<T>
+): MergeArray<T> => {
+  const { target } = options;
+
+  const result = signal(castValueInitializer<GetValuesInArray<T>[number]>(), {
+    onDispose: () => {
+      for (const e of effects) {
+        e.dispose()
+      }
+    }
+  });
+
+  const effects: Effect[] = [];
+  for (const valueReactor of target) {
+    const e = effect(() => {
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      const value = valueReactor.get() as GetValuesInArray<T>[number];
+      result.set(value)
+    })
+    effects.push(e)
+  }
+
+  return result
+}
+
+export interface WithLatestFromOptions<T, U> {
+  target: ValueReactor<T>;
+  other: ValueReactor<U>;
+}
+/**
+ * Combines two ValueReactors into a Signal that emits the latest values
+ * from the source ValueReactor along with the latest value from the other ValueReactor.
+ */
+export const withLatestFrom = <T, U>(
+  options: WithLatestFromOptions<T, U>
+): Signal<[T, U]> => {
+  const { target, other } = options;
+
+  const result = signal(castValueInitializer<[T, U]>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eOther.dispose()
+    }
+  })
+
+  let lastOther = other.get()
+  const eOther = effect(() => {
+    const b = other.get()
+    lastOther = b
+  })
+  const eTarget = effect(() => {
+    const a = target.get()
+    result.set([a, lastOther])
+  })
+
+  return result
+}
+
+export interface ZipOptions<VA, VB> {
+  a: ValueReactor<VA>;
+  b: ValueReactor<VB>;
+}
+/**
+ * Zips two ValueReactors into a Signal that emits pairs of values.
+ * Each time both ValueReactors have new values, a new pair is emitted.
+ */
+export const zip = <VA, VB>(
+  options: ZipOptions<VA, VB>
+): Signal<[VA, VB]> => {
+  const valueReactorA = options.a;
+  const valueReactorB = options.b;
+
+  let lastA = valueReactorA.getWithoutTrack()
+  let lastB = valueReactorB.getWithoutTrack()
+
+  const result = signal<[VA, VB]>(() => [lastA, lastB], {
+    onDispose: () => {
+      e.dispose()
+    }
+  })
+
+  const queueA: VA[] = []
+  const queueB: VB[] = []
+
+  const e = effect(() => {
+    const a = valueReactorA.get()
+    const b = valueReactorB.get()
+
+    if (a !== lastA) {
+      queueA.push(a)
+      lastA = a
+    }
+    if (b !== lastB) {
+      queueB.push(b)
+      lastB = b
+    }
+
+    if (queueA.length !== 0 && queueB.length !== 0) {
+      const va = queueA.shift()
+      const vb = queueB.shift()
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      result.set([va, vb] as [VA, VB])
+    }
+  })
+
+  return result
+}