@planet-matrix/mobius-model 0.1.3 → 0.3.0

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

@@ -0,0 +1,599 @@
+import type { AnyValueReactor, Signal, ValueOfValueReactor, ValueReactor } from "../reactor-core/index.ts"
+
+import { castValueInitializer } from "./utility.ts"
+import { effect, signal } from "../reactor-core/index.ts"
+
+export interface TapOptions<R extends AnyValueReactor> {
+  target: R;
+  tapper?: ((value: ValueOfValueReactor<R>) => void) | undefined;
+}
+/**
+ * Taps into the value changes of a ValueReactor without modifying its value.
+ */
+export const tap = <R extends AnyValueReactor>(
+  options: TapOptions<R>
+): R => {
+  const { target, tapper = (value: ValueOfValueReactor<R>): void => console.log(value) } = options;
+
+  effect(() => {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    const value = target.get() as ValueOfValueReactor<R>
+    tapper(value)
+  })
+
+  return target
+}
+
+export interface WithHistoryOptions<V> {
+  target: ValueReactor<V>;
+}
+/**
+ * Creates a signal that maintains a history of values from a ValueReactor.
+ * The history is stored in an array, with each new value appended to the end.
+ *
+ * Note: This implementation does not limit the size of the history array. Use
+ * with caution to avoid excessive memory usage.
+ */
+export const withHistory = <V>(
+  options: WithHistoryOptions<V>
+): Signal<V[]> => {
+  const { target } = options;
+
+  const result = signal(castValueInitializer<V[]>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const history: V[] = []
+  const eTarget = effect(() => {
+    history.push(target.get())
+    result.set([...history])
+  })
+
+  return result
+}
+
+export interface BufferByCountOptions<V> {
+  target: ValueReactor<V>;
+  count: number;
+}
+/**
+ * Buffers values from a ValueReactor and emits them as an array
+ * when the number of buffered values reaches the specified count.
+ */
+export const bufferByCount = <V>(
+  options: BufferByCountOptions<V>
+): Signal<V[]> => {
+  const { target, count } = options;
+
+  if (count <= 0) {
+    throw new Error("bufferByCount operator requires count to be greater than 0")
+  }
+
+  const result = signal<V[]>(() => [], {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const bufferedValues: V[] = []
+  const eTarget = effect(() => {
+    bufferedValues.push(target.get())
+    if (bufferedValues.length >= count) {
+      result.set([...bufferedValues])
+      bufferedValues.length = 0
+    }
+  })
+
+  return result
+}
+
+export interface BufferByTimeOptions<V> {
+  target: ValueReactor<V>;
+  time: number;
+}
+/**
+ * Buffers values from a ValueReactor and emits them as an array
+ * at specified time intervals.
+ */
+export const bufferByTime = <V>(
+  options: BufferByTimeOptions<V>
+): Signal<V[]> => {
+  const { target, time } = options;
+
+  if (time <= 0) {
+    throw new Error("bufferByTime operator requires timeInMilliseconds to be greater than 0")
+  }
+
+  const result = signal<V[]>(() => [], {
+    onDispose: () => {
+      eTarget.dispose()
+      clearInterval(intervalId)
+    }
+  })
+
+  const bufferedValues: V[] = []
+  const eTarget = effect(() => {
+    bufferedValues.push(target.get())
+  })
+
+  const intervalId = setInterval(() => {
+    result.set([...bufferedValues])
+    bufferedValues.length = 0
+  }, time)
+
+  return result
+}
+
+export interface BufferByTriggerOptions<VTarget, VTrigger> {
+  target: ValueReactor<VTarget>;
+  trigger: ValueReactor<VTrigger>;
+}
+/**
+ * Buffers values from a ValueReactor and emits them as an array when the trigger ValueReactor changes.
+ */
+export const bufferByTrigger = <VTarget, VTrigger>(
+  options: BufferByTriggerOptions<VTarget, VTrigger>
+): Signal<VTarget[]> => {
+  const { target, trigger } = options;
+
+  const result = signal(castValueInitializer<VTarget[]>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eTrigger.dispose()
+    }
+  })
+
+  const bufferedValues: VTarget[] = []
+  const eTarget = effect(() => {
+    bufferedValues.push(target.get())
+  })
+
+  const eTrigger = effect(() => {
+    trigger.get()
+    result.set([...bufferedValues])
+    bufferedValues.length = 0
+  })
+
+  return result
+}
+
+export interface BufferByToggleOptions<VTarget, VOpen, VClose> {
+  target: ValueReactor<VTarget>;
+  open: ValueReactor<VOpen>;
+  close: ValueReactor<VClose>;
+}
+/**
+ * Buffers values from a ValueReactor and emits them as an array
+ * when the open ValueReactor emits a value, and stops buffering
+ * when the close ValueReactor emits a value.
+ */
+export const bufferByToggle = <VTarget, VOpen, VClose>(
+  options: BufferByToggleOptions<VTarget, VOpen, VClose>
+): Signal<VTarget[]> => {
+  const { target, open, close } = options;
+
+  const result = signal(castValueInitializer<VTarget[]>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eOpen.dispose()
+      eClose.dispose()
+    }
+  })
+
+  const bufferedValues: VTarget[] = []
+  let buffering = false
+
+  const eOpen = effect(() => {
+    open.get()
+    buffering = true
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    if (buffering === true) {
+      bufferedValues.push(value)
+    }
+  })
+
+  const eClose = effect(() => {
+    close.get()
+    if (buffering === true) {
+      result.set([...bufferedValues])
+      bufferedValues.length = 0
+      buffering = false
+    }
+  })
+
+  return result
+}
+
+export interface BufferByDynamicOptions<VTarget, VDynamic> {
+  target: ValueReactor<VTarget>;
+  dynamic: (value: VTarget) => ValueReactor<VDynamic>;
+}
+/**
+ * Buffers values from a ValueReactor and emits them as an array
+ * when the ValueReactor returned by the `dynamic` function emits a value.
+ * The `dynamic` function is called each time the buffer is emitted
+ * to get a new ValueReactor for the next buffer.
+ */
+export const bufferByDynamic = <VTarget, VDynamic>(
+  options: BufferByDynamicOptions<VTarget, VDynamic>
+): Signal<VTarget[]> => {
+  const { target, dynamic } = options;
+
+  const result = signal(castValueInitializer<VTarget[]>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eDynamic.dispose()
+    }
+  })
+
+  const bufferedValues: VTarget[] = []
+  const eTarget = effect(() => {
+    const value = target.get()
+    bufferedValues.push(value)
+  })
+
+  let trigger: ValueReactor<VDynamic> | undefined = undefined
+  const eDynamic = effect(() => {
+    trigger?.dispose()
+    const targetValue = target.getWithoutTrack()
+    trigger = dynamic(targetValue)
+    trigger.get()
+    result.set([...bufferedValues])
+    bufferedValues.length = 0
+  })
+
+  return result
+}
+
+export interface GroupToArrayByOptions<V, K> {
+  target: ValueReactor<V>;
+  keyGetter: (value: V) => K;
+}
+/**
+ * Groups values from a ValueReactor into an array of arrays based on a key
+ * extracted by the keyGetter function.
+ */
+export const groupToArrayBy = <V, K>(
+  options: GroupToArrayByOptions<V, K>
+): Signal<V[][]> => {
+  const { target, keyGetter } = options;
+
+  const result = signal<V[][]>(() => [], {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const groups = new Map<K, V[]>()
+  const eTarget = effect(() => {
+    const value = target.get()
+    const key = keyGetter(value)
+    if (groups.has(key) === false) {
+      groups.set(key, [])
+      result.set([...groups.values()])
+    }
+    const groupedArray = groups.get(key)!
+    groupedArray.push(value)
+  })
+
+  return result
+}
+
+export interface GroupToObjectByOptions<V, K extends string | number | symbol> {
+  target: ValueReactor<V>;
+  keyGetter: (value: V) => K;
+}
+/**
+ * Groups values from a ValueReactor into an object where each key maps to an array
+ * of values corresponding to that key.
+ */
+export const groupToObjectBy = <V, K extends string | number | symbol>(
+  options: GroupToObjectByOptions<V, K>
+): Signal<Record<K, V[]>> => {
+  const { target, keyGetter } = options;
+
+  const result = signal<Record<K, V[]>>(() => {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return {} as Record<K, V[]>
+  }, {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const groups = new Map<K, V[]>()
+  const eTarget = effect(() => {
+    const value = target.get()
+    const key = keyGetter(value)
+    if (groups.has(key) === false) {
+      groups.set(key, [])
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      result.set(Object.fromEntries(groups.entries()) as Record<K, V[]>)
+    }
+    const groupedArray = groups.get(key)!
+    groupedArray.push(value)
+  })
+
+  return result
+}
+
+/**
+ * Groups values from a ValueReactor into an array of Signals based on a key
+ * extracted by the keyGetter function.
+ */
+export const groupToSignalArrayBy = <V, K>(
+  target: ValueReactor<V>, keyGetter: (value: V) => K
+): Signal<Array<Signal<V[]>>> => {
+  const result = signal<Array<Signal<V[]>>>(() => [], {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const groups = new Map<K, Signal<V[]>>()
+  const eTarget = effect(() => {
+    const value = target.get()
+    const key = keyGetter(value)
+    if (groups.has(key) === false) {
+      const newGroup = signal<V[]>(() => [])
+      groups.set(key, newGroup)
+      result.set([...groups.values()])
+    }
+    const groupedSignal = groups.get(key)!
+    const currentArray = groupedSignal.get()
+    groupedSignal.set([...currentArray, value])
+  })
+
+  return result
+}
+
+export interface GroupToSignalObjectByOptions<V, K extends string | number | symbol> {
+  target: ValueReactor<V>;
+  keyGetter: (value: V) => K;
+}
+/**
+ * Groups values from a ValueReactor into a Signal of an object where each key maps to a Signal
+ * of an array of values corresponding to that key.
+ */
+export const groupToSignalObjectBy = <V, K extends string | number | symbol>(
+  options: GroupToSignalObjectByOptions<V, K>
+): Signal<Record<K, Signal<V[]>>> => {
+  const { target, keyGetter } = options;
+
+  const result = signal<Record<K, Signal<V[]>>>(() => {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return {} as Record<K, Signal<V[]>>
+  }, {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const groups = new Map<K, Signal<V[]>>()
+  const eTarget = effect(() => {
+    const value = target.get()
+    const key = keyGetter(value)
+    if (groups.has(key) === false) {
+      const newGroup = signal<V[]>(() => [])
+      groups.set(key, newGroup)
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      result.set(Object.fromEntries(groups.entries()) as Record<K, Signal<V[]>>)
+    }
+    const groupedSignal = groups.get(key)!
+    const currentArray = groupedSignal.get()
+    groupedSignal.set([...currentArray, value])
+  })
+
+  return result
+}
+
+export interface MapOptions<VTarget, VMapped> {
+  target: ValueReactor<VTarget>;
+  mapper: (value: VTarget) => VMapped;
+}
+/**
+ * Maps values from a ValueReactor using the provided mapper function and
+ * emits the mapped values as a new Signal.
+ */
+export const map = <VTarget, VMapped>(
+  options: MapOptions<VTarget, VMapped>
+): Signal<VMapped> => {
+  const { target, mapper } = options;
+
+  const result = signal(castValueInitializer<VMapped>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    const newValue = mapper(value)
+    result.set(newValue)
+  })
+
+  return result
+}
+
+export interface ContextualMapInitializingMapperContext<VTarget> {
+  isInitializingRun: true;
+  targetValue: VTarget
+}
+export interface ContextualMapUpdatingMapperContext<VTarget, VMapped> {
+  isInitializingRun: false;
+  targetValue: VTarget
+  previousMappedValue: VMapped
+}
+export type ContextualMapMapperContextOf<VTarget, VMapped> =
+  | ContextualMapInitializingMapperContext<VTarget>
+  | ContextualMapUpdatingMapperContext<VTarget, VMapped>;
+
+export interface ContextualMapOptions<VTarget, VMapped> {
+  target: ValueReactor<VTarget>;
+  mapper: (context: ContextualMapMapperContextOf<VTarget, VMapped>) => VMapped;
+}
+/**
+ * Maps values from a ValueReactor using the provided contextual mapper function and
+ * emits the mapped values as a new Signal.
+ */
+export const contextualMap = <VTarget, VMapped>(
+  options: ContextualMapOptions<VTarget, VMapped>
+): Signal<VMapped> => {
+  const { target, mapper } = options;
+
+  const result = signal(castValueInitializer<VMapped>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect((context) => {
+    const targetValue = target.get()
+    const { isInitializingRun } = context
+    if (isInitializingRun === true) {
+      const newValue = mapper({
+        isInitializingRun,
+        targetValue
+      })
+      result.set(newValue)
+    } else {
+      const previousMappedValue = result.getWithoutTrack()
+      const newValue = mapper({
+        isInitializingRun,
+        targetValue,
+        previousMappedValue
+      })
+      result.set(newValue)
+    }
+  })
+
+  return result
+}
+
+export interface MergeMapOptions<VTarget, VMapped> {
+  target: ValueReactor<VTarget>;
+  mapper: (value: VTarget) => ValueReactor<VMapped>;
+}
+/**
+ * Maps each value from a ValueReactor<T> to a ValueReactor<R> using the provided `mapper`,
+ * subscribes to every mapped reactor, and merges their emitted values into a single `Signal<R>`.
+ */
+export const mergeMap = <VTarget, VMapped>(
+  options: MergeMapOptions<VTarget, VMapped>
+): Signal<VMapped> => {
+  const { target, mapper } = options;
+
+  const result = signal(castValueInitializer<VMapped>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    const currentMappedReactor = mapper(value);
+
+    effect(() => {
+      const mappedValue = currentMappedReactor.get()
+      result.set(mappedValue)
+    })
+  })
+
+  return result
+}
+
+export interface SwitchMapOptions<VTarget, VMapped> {
+  target: ValueReactor<VTarget>;
+  mapper: (value: VTarget) => ValueReactor<VMapped>;
+}
+/**
+ * Maps each value from a ValueReactor<T> to a ValueReactor<R> using the provided `mapper`,
+ * subscribes only to the latest mapped reactor, and emits its values as a `Signal<R>`.
+ */
+export const switchMap = <VTarget, VMapped>(
+  options: SwitchMapOptions<VTarget, VMapped>
+): Signal<VMapped> => {
+  const { target, mapper } = options;
+
+  const result = signal(castValueInitializer<VMapped>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  let lastMappedReactor: ValueReactor<VMapped> | undefined = undefined
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    lastMappedReactor?.dispose()
+    lastMappedReactor = mapper(value);
+    effect(() => {
+      const mappedValue = lastMappedReactor!.get()
+      result.set(mappedValue)
+    })
+  })
+
+  return result
+}
+
+export interface ScanOptions<VTarget, VAccumulated> {
+  target: ValueReactor<VTarget>;
+  accumulator: (acc: VAccumulated, value: VTarget) => VAccumulated;
+  seed: VAccumulated;
+}
+/**
+ * Accumulates values from a ValueReactor using the provided accumulator function
+ * and emits the accumulated value as a Signal.
+ */
+export const scan = <VTarget, VAccumulated>(
+  options: ScanOptions<VTarget, VAccumulated>
+): Signal<VAccumulated> => {
+  const { target, accumulator, seed } = options;
+
+  const result = signal(() => seed, {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    const newValue = accumulator(result.getWithoutTrack(), value)
+    result.set(newValue)
+  })
+
+  return result
+}
+
+export interface PairwiseOptions<V> {
+  target: ValueReactor<V>;
+}
+/**
+ * Emits the previous and current values from a ValueReactor as a tuple.
+ * The first emitted tuple will have `undefined` as the previous value.
+ */
+export const pairwise = <V>(
+  options: PairwiseOptions<V>
+): Signal<[V | undefined, V]> => {
+  const { target } = options;
+
+  const result = signal<[V | undefined, V]>(() => [undefined, target.get()], {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  let previousValue: V | undefined = undefined
+  const eTarget = effect(() => {
+    const currentValue = target.get()
+    result.set([previousValue, currentValue])
+    previousValue = currentValue
+  })
+
+  return result
+}

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

@@ -0,0 +1,102 @@
+import type { ValueReactor } from "../reactor-core/index.ts"
+
+import { effect } from "../reactor-core/index.ts"
+
+export type ValueInitializer<V> = () => V;
+/**
+ * This initializer can be used to create a Signal with an undefined initial value which
+ * is casted to the desired type T. So the real value getter function will not be called
+ * until the Signal is actually used.
+ *
+ * Every signal should always have a valid value (or value getter which returns a valid value).
+ * When using the castValueInitializer, the real value should be set as soon as possible.
+ */
+export const castValueInitializer = <V>(): ValueInitializer<V> => {
+  return (): V => {
+    // oxlint-disable-next-line no-unsafe-return no-unsafe-type-assertion
+    return undefined as unknown as V
+  }
+}
+
+export type Unsubscribe = () => void
+export interface SubscribeOptions<V> {
+  target: ValueReactor<V>;
+  subscriber: (value: V) => void;
+}
+/**
+ * Subscribes to a ValueReactor and invokes the subscriber when the reactor's value
+ * changes.
+ *
+ * The initial value is skipped; the subscriber is called only on subsequent updates.
+ */
+export const subscribe = <V>(
+  options: SubscribeOptions<V>
+): Unsubscribe => {
+  const { target, subscriber } = options
+
+  const e = effect((context) => {
+    const { isInitializingRun } = context
+    const value = target.get()
+    if (isInitializingRun === false) {
+      subscriber(value)
+    }
+  })
+  const unsubscribe = (): void => {
+    e.dispose()
+  }
+  return unsubscribe
+}
+
+// oxlint-disable-next-line no-explicit-any
+export type AnyValueReactorArray = Array<ValueReactor<any>>;
+export type GetValuesInArray<T extends AnyValueReactorArray> = {
+  [K in keyof T]: T[K] extends ValueReactor<infer U> ? U : never
+}
+export interface GetValuesInArrayOptions<T extends AnyValueReactorArray> {
+  target: T;
+  withoutTrack?: boolean;
+}
+/**
+ * Gets the current values from an array of ValueReactors.
+ */
+export const getValuesInArray = <T extends AnyValueReactorArray>(
+  options: GetValuesInArrayOptions<T>
+): GetValuesInArray<T> => {
+  const valueReactors = options.target;
+  const withoutTrack = options?.withoutTrack ?? false;
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  const values = valueReactors.map((vr) => {
+    // oxlint-disable-next-line no-unsafe-return
+    return withoutTrack ? vr.getWithoutTrack() : vr.get()
+  }) as unknown as GetValuesInArray<T>
+  return values
+}
+
+// oxlint-disable-next-line no-explicit-any
+export type AnyValueReactorObject = Record<string, ValueReactor<any>>;
+export type GetValuesInObject<T extends AnyValueReactorObject> = {
+  [K in keyof T]: T[K] extends ValueReactor<infer U> ? U : never
+}
+export interface GetValueInObjectOptions<T extends AnyValueReactorObject> {
+  target: T;
+  withoutTrack?: boolean;
+}
+/**
+ * Gets the current values from an object of ValueReactors.
+ */
+export const getValuesInObject = <T extends AnyValueReactorObject>(
+  options: GetValueInObjectOptions<T>
+): GetValuesInObject<T> => {
+  const valueReactors = options.target;
+  const withoutTrack = options?.withoutTrack ?? false;
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  const values = {} as GetValuesInObject<T>
+  for (const key of Object.keys(valueReactors)) {
+    const valueReactor = valueReactors[key]!
+    // oxlint-disable-next-line no-unsafe-assignment
+    const value = withoutTrack ? valueReactor.getWithoutTrack() : valueReactor.get()
+    // oxlint-disable-next-line no-unsafe-assignment no-unsafe-member-access no-unsafe-type-assertion
+    values[key as unknown as keyof GetValuesInObject<T>] = value
+  }
+  return values
+}