@planet-matrix/mobius-model 0.1.3 → 0.3.0

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

@@ -0,0 +1,66 @@
+import type { Signal, ValueReactor } from "../reactor-core/index.ts"
+
+import { castValueInitializer } from "./utility.ts"
+import { effect, signal } from "../reactor-core/index.ts"
+
+export interface CloneOptions<V> {
+  target: ValueReactor<V>;
+}
+/**
+ * Creates a Signal that mirrors the value of the target ValueReactor.
+ */
+export const clone = <V>(
+  options: CloneOptions<V>
+): Signal<V> => {
+  const { target } = options;
+
+  const result = signal(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    result.set(value)
+  })
+
+  return result
+}
+
+export interface PartitionOptions<V> {
+  target: ValueReactor<V>;
+  predicate: (value: V) => boolean;
+}
+/**
+ * Partitions values from a ValueReactor into two Signals based on a predicate function.
+ * The first Signal emits values that satisfy the predicate, while the second Signal
+ * emits values that do not satisfy the predicate.
+ */
+export const partition = <V>(
+  options: PartitionOptions<V>
+): [Signal<V | undefined>, Signal<V | undefined>] => {
+  const { target, predicate } = options;
+
+  const trueSignal = signal(castValueInitializer<V | undefined>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+  const falseSignal = signal(castValueInitializer<V | undefined>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    if (predicate(value) === true) {
+      trueSignal.set(value)
+    } else {
+      falseSignal.set(value)
+    }
+  })
+
+  return [trueSignal, falseSignal]
+}

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

@@ -0,0 +1,70 @@
+import type { Signal, ValueReactor } from "../reactor-core/index.ts"
+
+import { signal } from "../reactor-core/index.ts"
+import { subscribe } from "./utility.ts"
+
+export interface FromPromiseSyncOptions<V> {
+  target: Promise<V>;
+}
+/**
+ * Converts a Promise into a Signal that updates its value
+ * when the Promise resolves.
+ *
+ * @see {@link fromPromiseAsync} for an async version.
+ */
+export const fromPromiseSync = <V>(
+  options: FromPromiseSyncOptions<V>
+): Signal<V | undefined> => {
+  const { target } = options
+
+  const result = signal<V | undefined>(() => undefined)
+  void target.then((value) => {
+    return result.set(value)
+  })
+  return result
+}
+
+export interface FromPromiseAsyncOptions<V> {
+  target: Promise<V>;
+}
+/**
+ * Converts a Promise into a Signal that is initialized
+ * with the resolved value of the Promise.
+ *
+ * @see {@link fromPromiseSync} for a sync version.
+ */
+export const fromPromiseAsync = async <V>(
+  options: FromPromiseAsyncOptions<V>
+): Promise<Signal<V>> => {
+  const { target } = options
+
+  const value = await target
+  const result = signal<V>(() => value)
+  return result
+}
+
+export interface ToPromiseOptions<V> {
+  target: ValueReactor<V>;
+}
+/**
+ * Converts a ValueReactor into a Promise that resolves
+ * with the next value emitted by the ValueReactor.
+ */
+export const toPromise = async <V>(
+  options: ToPromiseOptions<V>
+): Promise<V> => {
+  const { target } = options
+
+  let _resolve: (value: V) => void
+  const promise = new Promise<V>((resolve) => {
+    _resolve = resolve
+  })
+  const unsubscribe = subscribe({
+    target,
+    subscriber: (value) => {
+      unsubscribe()
+      _resolve(value)
+    }
+  })
+  return await promise
+}

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

@@ -0,0 +1,66 @@
+import type { Signal } from "../reactor-core/index.ts"
+
+import { signal } from "../reactor-core/index.ts"
+
+export interface TimerOptions {
+  delay: number
+  interval: number
+  initialValue?: number
+  step?: number
+}
+/**
+ * Creates a signal that starts emitting values after a specified delay,
+ * and continues to emit incremented values at specified intervals.
+ *
+ * The value starts at 0, becomes 1 after the delay, and increments by 1.
+ */
+export const timer = (
+  options: TimerOptions
+): Signal<number> => {
+  const { delay, interval, initialValue = 0, step = 1 } = options
+
+  const result = signal<number>(() => initialValue, {
+    onDispose: () => {
+      clearTimeout(timeoutId)
+      clearInterval(intervalId)
+    }
+  })
+
+  let intervalId: ReturnType<typeof setInterval> | undefined = undefined
+  const timeoutId = setTimeout(() => {
+    result.set(result.getWithoutTrack() + step)
+    intervalId = setInterval(() => {
+      result.set(result.getWithoutTrack() + step)
+    }, interval)
+  }, delay)
+
+  return result
+}
+
+export interface IntervalOptions {
+  interval: number
+  initialValue?: number
+  step?: number
+}
+/**
+ * Creates a signal that increments its value at specified intervals.
+ *
+ * The value starts at 0 and increments by 1 every interval.
+ */
+export const interval = (
+  options: IntervalOptions
+): Signal<number> => {
+  const { interval, initialValue = 0, step = 1 } = options
+
+  const result = signal<number>(() => initialValue, {
+    onDispose: () => {
+      clearInterval(intervalId)
+    }
+  })
+
+  const intervalId = setInterval(() => {
+    result.set(result.getWithoutTrack() + step)
+  }, interval)
+
+  return result
+}