@planet-matrix/mobius-model 0.1.3 → 0.3.0

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

@@ -0,0 +1,988 @@
+import type { Signal, SignalValueInitializer, ValueReactor } from "../reactor-core/index.ts"
+
+import { castValueInitializer } from "./utility.ts"
+import { effect, signal } from "../reactor-core/index.ts"
+
+export interface CurrentOptions<V> {
+  target: ValueReactor<V>;
+}
+/**
+ * Returns a Signal that holds the current value of the target ValueReactor.
+ */
+export const current = <V>(
+  options: CurrentOptions<V>
+): Signal<V> => {
+  const { target } = options;
+
+  const result = signal<V>(() => {
+    return target.get()
+  })
+
+  return result
+}
+
+export interface NextOptions<V> {
+  target: ValueReactor<V>;
+  valueInitializer: SignalValueInitializer<V>
+}
+/**
+ * Returns a Signal that holds the next value of the target ValueReactor
+ * after the initial value.
+ *
+ * The Signal will update its value only once, upon the next change of
+ * the target ValueReactor, and then it will not update anymore.
+ */
+export const next = <V>(
+  options: NextOptions<V>
+): Signal<V> => {
+  const { target, valueInitializer } = options;
+
+  const result = signal(valueInitializer, {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect((context) => {
+    const { isInitializingRun } = context
+
+    const value = target.get()
+    if (isInitializingRun === false) {
+      result.set(value)
+      eTarget.dispose()
+    }
+  })
+
+  return result
+}
+
+export interface FilterInitializingFalsyValueGetterContext<V> {
+  isInitializingRun: true;
+  targetValue: V
+}
+export interface FilterUpdatingFalsyValueGetterContext<V> {
+  isInitializingRun: false;
+  targetValue: V
+  previousValue: V
+}
+export type FilterFalsyValueGetterContextOf<V> =
+  | FilterInitializingFalsyValueGetterContext<V>
+  | FilterUpdatingFalsyValueGetterContext<V>
+export interface FilterOptions<V> {
+  target: ValueReactor<V>;
+  truthyPredicate: (value: V) => boolean;
+  falsyValueGetter: (context: FilterFalsyValueGetterContextOf<V>) => V;
+}
+/**
+ * Returns a Signal that only updates its value from the target
+ * ValueReactor when the predicate function returns true.
+ */
+export const filter = <V>(
+  options: FilterOptions<V>
+): Signal<V> => {
+  const { target, truthyPredicate, falsyValueGetter } = options;
+
+  const result = signal<V>(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect((context) => {
+    const value = target.get()
+    if (truthyPredicate(value) === true) {
+      result.set(value)
+    } else {
+      const { isInitializingRun } = context
+      if (isInitializingRun === true) {
+        const fallbackValue = falsyValueGetter({
+          isInitializingRun,
+          targetValue: value
+        })
+        result.set(fallbackValue)
+      } else {
+        const fallbackValue = falsyValueGetter({
+          isInitializingRun,
+          targetValue: value,
+          previousValue: result.getWithoutTrack()
+        })
+        result.set(fallbackValue)
+      }
+    }
+  })
+
+  return result
+}
+
+export interface AuditByCountOptions<V> {
+  target: ValueReactor<V>;
+  count: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor after every specified count of emissions.
+ */
+export const auditByCount = <V>(
+  options: AuditByCountOptions<V>
+): Signal<V> => {
+  const { target, count } = options;
+
+  if (count <= 0) {
+    throw new Error("auditByCount operator requires count to be greater than 0")
+  }
+
+
+  const result = signal(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  let emissionCount = 0
+  const eTarget = effect((context) => {
+    const latestValue = target.get()
+
+    if (context.isInitializingRun === true) {
+      result.set(latestValue)
+    } else {
+      emissionCount = emissionCount + 1
+      if (emissionCount >= count) {
+        result.set(latestValue)
+        emissionCount = 0
+      }
+    }
+  })
+
+  return result
+}
+
+export interface AuditByTimeOptions<V> {
+  target: ValueReactor<V>;
+  time: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor at specified time intervals.
+ */
+export const auditByTime = <V>(
+  options: AuditByTimeOptions<V>
+): Signal<V> => {
+  const { target, time } = options;
+
+  if (time <= 0) {
+    throw new Error("auditByTime operator requires timeInMilliseconds to be greater than 0")
+  }
+
+  const result = signal<V>(() => target.getWithoutTrack(), {
+    onDispose: () => {
+      clearInterval(intervalId)
+    }
+  })
+
+  const intervalId = setInterval(() => {
+    result.set(target.getWithoutTrack())
+  }, time)
+
+  return result
+}
+
+export interface AuditByTriggerOptions<VTarget, VTrigger> {
+  target: ValueReactor<VTarget>;
+  trigger: ValueReactor<VTrigger>;
+}
+/**
+ * Returns a Signal that only updates its value when the trigger
+ * ValueReactor emits a value, using the latest value from the target
+ * ValueReactor.
+ */
+export const auditByTrigger = <VTarget, VTrigger>(
+  options: AuditByTriggerOptions<VTarget, VTrigger>
+): Signal<VTarget> => {
+  const { target, trigger } = options;
+
+  const result = signal<VTarget>(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTrigger.dispose()
+    }
+  })
+
+  const eTrigger = effect(() => {
+    trigger.get()
+    result.set(target.getWithoutTrack())
+  })
+
+  return result
+}
+
+export interface AuditByToggleOptions<VTarget, VOpen, VClose> {
+  target: ValueReactor<VTarget>;
+  open: ValueReactor<VOpen>;
+  close: ValueReactor<VClose>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor when the close ValueReactor emits, but only
+ * if auditing was started by the open ValueReactor.
+ */
+export const auditByToggle = <VTarget, VOpen, VClose>(
+  options: AuditByToggleOptions<VTarget, VOpen, VClose>
+): Signal<VTarget> => {
+  const { target, open, close } = options;
+
+  const result = signal(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eOpen.dispose()
+      eClose.dispose()
+    }
+  })
+
+  let auditValue: VTarget | undefined = undefined
+  let auditing = false
+
+  const eOpen = effect(() => {
+    open.get()
+    auditing = true
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    if (auditing === true) {
+      auditValue = value
+    }
+  })
+
+  const eClose = effect(() => {
+    close.get()
+    if (auditing === true) {
+      if (auditValue !== undefined) {
+        result.set(auditValue)
+      }
+      auditing = false
+      auditValue = undefined
+    }
+  })
+
+  return result
+}
+
+export interface AuditByDynamicOptions<VTarget, VDynamic> {
+  target: ValueReactor<VTarget>;
+  dynamic: (value: VTarget) => ValueReactor<VDynamic>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor when the ValueReactor returned by the `dynamic`
+ * function emits. The `dynamic` function is called each time after emitting
+ * to get a new ValueReactor for the next audit period.
+ */
+export const auditByDynamic = <VTarget, VDynamic>(
+  options: AuditByDynamicOptions<VTarget, VDynamic>
+): Signal<VTarget> => {
+  const { target, dynamic } = options;
+
+  const result = signal(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eDynamic.dispose()
+    }
+  })
+
+  let trigger: ValueReactor<VDynamic> | undefined = undefined
+  const eDynamic = effect(() => {
+    trigger?.dispose()
+    const targetValue = target.getWithoutTrack()
+    trigger = dynamic(targetValue)
+    trigger.get()
+    result.set(targetValue)
+  })
+
+  return result
+}
+
+export interface DebounceByCountOptions<V> {
+  target: ValueReactor<V>;
+  count: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor after the specified count of emissions
+ * without being updated.
+ */
+export const debounceByCount = <V>(
+  options: DebounceByCountOptions<V>
+): Signal<V> => {
+  const { target, count } = options;
+
+  if (count <= 0) {
+    throw new Error("debounceByCount operator requires count to be greater than 0")
+  }
+
+  const result = signal(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  let emissionCount = 0
+  const eTarget = effect((context) => {
+    const latestValue = target.get()
+
+    if (context.isInitializingRun === true) {
+      result.set(latestValue)
+    } else {
+      emissionCount = emissionCount + 1
+      if (emissionCount >= count) {
+        result.set(latestValue)
+        emissionCount = 0
+      }
+    }
+  })
+
+  return result
+}
+
+export interface DebounceByTimeOptions<V> {
+  target: ValueReactor<V>;
+  time: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor after the specified time in milliseconds
+ * has passed since the last update.
+ */
+export const debounceByTime = <V>(
+  options: DebounceByTimeOptions<V>
+): Signal<V> => {
+  const { target, time } = options;
+
+  if (time <= 0) {
+    throw new Error("debounceTime operator requires timeInMilliseconds to be greater than 0")
+  }
+
+  let timeoutId: ReturnType<typeof setTimeout> | undefined = undefined
+
+  const result = signal<V>(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      clearTimeout(timeoutId)
+    }
+  })
+
+  const eTarget = effect((context) => {
+    const latestValue = target.get()
+
+    if (context.isInitializingRun === true) {
+      result.set(latestValue)
+    } else {
+      clearTimeout(timeoutId)
+      timeoutId = setTimeout(() => {
+        result.set(latestValue)
+        timeoutId = undefined
+      }, time)
+    }
+  })
+
+  return result
+}
+
+export interface DebounceByTriggerOptions<VTarget, VTrigger> {
+  target: ValueReactor<VTarget>;
+  trigger: ValueReactor<VTrigger>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor whenever the trigger ValueReactor
+ * emits a value.
+ */
+export const debounceByTrigger = <VTarget, VTrigger>(
+  options: DebounceByTriggerOptions<VTarget, VTrigger>
+): Signal<VTarget> => {
+  const { target, trigger } = options;
+
+  const result = signal<VTarget>(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTrigger.dispose()
+    }
+  })
+
+  const eTrigger = effect(() => {
+    trigger.get()
+    result.set(target.getWithoutTrack())
+  })
+
+  return result
+}
+
+export interface DebounceByToggleOptions<VTarget, VOpen, VClose> {
+  target: ValueReactor<VTarget>;
+  open: ValueReactor<VOpen>;
+  close: ValueReactor<VClose>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor when the close ValueReactor emits, but only
+ * if debouncing was started by the open ValueReactor.
+ */
+export const debounceByToggle = <VTarget, VOpen, VClose>(
+  options: DebounceByToggleOptions<VTarget, VOpen, VClose>
+): Signal<VTarget> => {
+  const { target, open, close } = options;
+
+  const result = signal(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eOpen.dispose()
+      eClose.dispose()
+    }
+  })
+
+  let debounceValue: VTarget | undefined = undefined
+  let debouncing = false
+
+  const eOpen = effect(() => {
+    open.get()
+    debouncing = true
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    if (debouncing === true) {
+      debounceValue = value
+    }
+  })
+
+  const eClose = effect(() => {
+    close.get()
+    if (debouncing === true) {
+      if (debounceValue !== undefined) {
+        result.set(debounceValue)
+      }
+      debouncing = false
+      debounceValue = undefined
+    }
+  })
+
+  return result
+}
+
+export interface DebounceByDynamicOptions<VTarget, VDynamic> {
+  target: ValueReactor<VTarget>;
+  dynamic: (value: VTarget) => ValueReactor<VDynamic>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor when the ValueReactor returned by the `dynamic`
+ * function emits. The `dynamic` function is called each time after emitting
+ * to get a new ValueReactor for the next debounce period.
+ */
+export const debounceByDynamic = <VTarget, VDynamic>(
+  options: DebounceByDynamicOptions<VTarget, VDynamic>
+): Signal<VTarget> => {
+  const { target, dynamic } = options;
+
+  const result = signal(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eDynamic.dispose()
+    }
+  })
+
+  let trigger: ValueReactor<VDynamic> | undefined = undefined
+  const eDynamic = effect(() => {
+    trigger?.dispose()
+    const targetValue = target.getWithoutTrack()
+    trigger = dynamic(targetValue)
+    trigger.get()
+    result.set(targetValue)
+  })
+
+  return result
+}
+
+export interface ThrottleByCountOptions<V> {
+  target: ValueReactor<V>;
+  count: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor at most once every specified count of emissions.
+ */
+export const throttleByCount = <V>(
+  options: ThrottleByCountOptions<V>
+): Signal<V> => {
+  const { target, count } = options;
+
+  if (count <= 0) {
+    throw new Error("throttleByCount operator requires count to be greater than 0")
+  }
+
+  const result = signal(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  let emissionCount = 0
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+    if (emissionCount === 0) {
+      result.set(latestValue)
+    }
+    emissionCount = emissionCount + 1
+    if (emissionCount >= count) {
+      emissionCount = 0
+    }
+  })
+
+  return result
+}
+
+export interface ThrottleByTimeOptions<V> {
+  target: ValueReactor<V>;
+  time: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor at most once every specified time in milliseconds.
+ */
+export const throttleByTime = <V>(
+  options: ThrottleByTimeOptions<V>
+): Signal<V> => {
+  const { target, time } = options;
+
+  if (time <= 0) {
+    throw new Error("throttleByTime operator requires timeInMilliseconds to be greater than 0")
+  }
+
+  const result = signal<V>(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  let canEmit = true
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+
+    if (canEmit === true) {
+      result.set(latestValue)
+      canEmit = false
+      setTimeout(() => {
+        canEmit = true
+      }, time)
+    }
+  })
+
+  return result
+}
+
+export interface ThrottleByTriggerOptions<VTarget, VTrigger> {
+  target: ValueReactor<VTarget>;
+  trigger: ValueReactor<VTrigger>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor at most once whenever the trigger
+ * ValueReactor emits.
+ */
+export const throttleByTrigger = <VTarget, VTrigger>(
+  options: ThrottleByTriggerOptions<VTarget, VTrigger>
+): Signal<VTarget> => {
+  const { target, trigger } = options;
+
+  const result = signal<VTarget>(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTrigger.dispose()
+      eTarget.dispose()
+    }
+  })
+
+  let canEmit = false
+  const eTrigger = effect(() => {
+    trigger.get()
+    canEmit = true
+  })
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+    if (canEmit === true) {
+      result.set(latestValue)
+      canEmit = false
+    }
+  })
+
+  return result
+}
+
+export interface ThrottleByToggleOptions<VTarget, VOpen, VClose> {
+  target: ValueReactor<VTarget>;
+  open: ValueReactor<VOpen>;
+  close: ValueReactor<VClose>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor when the close ValueReactor emits, but only
+ * if throttling was started by the open ValueReactor.
+ */
+export const throttleByToggle = <VTarget, VOpen, VClose>(
+  options: ThrottleByToggleOptions<VTarget, VOpen, VClose>
+): Signal<VTarget> => {
+  const { target, open, close } = options;
+
+  const result = signal(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eOpen.dispose()
+      eClose.dispose()
+    }
+  })
+
+  let throttling = false
+
+  const eOpen = effect(() => {
+    open.get()
+    throttling = true
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    if (throttling === true) {
+      result.set(value)
+      throttling = false
+    }
+  })
+
+  const eClose = effect(() => {
+    close.get()
+    throttling = false
+  })
+
+  return result
+}
+
+export interface ThrottleByDynamicOptions<VTarget, VDynamic> {
+  target: ValueReactor<VTarget>;
+  dynamic: (value: VTarget) => ValueReactor<VDynamic>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor when the ValueReactor returned by the `dynamic`
+ * function emits. The `dynamic` function is called each time after emitting
+ * to get a new ValueReactor for the next throttle period.
+ */
+export const throttleByDynamic = <VTarget, VDynamic>(
+  options: ThrottleByDynamicOptions<VTarget, VDynamic>
+): Signal<VTarget> => {
+  const { target, dynamic } = options;
+
+  const result = signal(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTrigger.dispose()
+      eTarget.dispose()
+    }
+  })
+
+  let trigger: ValueReactor<VDynamic> | undefined = undefined
+  let canEmit = true
+  const eTrigger = effect(() => {
+    trigger?.dispose()
+    const targetValue = target.getWithoutTrack()
+    trigger = dynamic(targetValue)
+    trigger.get()
+    canEmit = true
+  })
+
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+    if (canEmit === true) {
+      result.set(latestValue)
+      canEmit = false
+    }
+  })
+
+  return result
+}
+
+export interface DistinctOptions<V, K> {
+  target: ValueReactor<V>;
+  keyGetter?: (value: V) => K;
+}
+/**
+ * Returns a Signal that only updates its value with unique values
+ * from the target ValueReactor, determined by the key returned from
+ * the keyGetter function.
+ */
+export const distinct = <V, K>(
+  options: DistinctOptions<V, K>
+): Signal<V> => {
+  const { target, keyGetter } = options;
+
+  const result = signal<V>(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  const preparedKeyGetter = keyGetter ?? ((value: V): K => (value as unknown) as K)
+
+  const keySet = new Set<K>()
+  const eTarget = effect(() => {
+    const newValue = target.get()
+    const key = preparedKeyGetter(newValue);
+    if (keySet.has(key) === false) {
+      result.set(newValue)
+      keySet.add(key)
+    }
+  })
+
+  return result
+}
+
+export interface DistinctUntilChangedOptions<V, K> {
+  target: ValueReactor<V>;
+  keyGetter?: (value: V) => K;
+}
+/**
+ * Returns a Signal that only updates its value when the key returned
+ * from the keyGetter function changes between emissions.
+ */
+export const distinctUntilChanged = <V, K>(
+  options: DistinctUntilChangedOptions<V, K>
+): Signal<V> => {
+  const { target, keyGetter } = options;
+
+  const result = signal<V>(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  const preparedKeyGetter = keyGetter ?? ((value: V): K => (value as unknown) as K)
+
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  let lastKey: K = Symbol("initial-key-for-distinct-until-changed") as unknown as K
+  const eTarget = effect(() => {
+    const newValue = target.get()
+    const key = preparedKeyGetter(newValue);
+    if (key !== lastKey) {
+      result.set(newValue)
+      lastKey = key
+    }
+  })
+
+  return result
+}
+
+export interface TakeByPredicateOptions<V> {
+  target: ValueReactor<V>;
+  predicate: (value: V) => boolean;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor, but only while the predicate function
+ * returns true.
+ */
+export const takeByPredicate = <V>(
+  options: TakeByPredicateOptions<V>
+): Signal<V> => {
+  const { target, predicate } = options;
+
+  const result = signal<V>(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+    if (predicate(latestValue) === true) {
+      result.set(latestValue)
+    } else {
+      eTarget.dispose()
+    }
+  })
+
+  return result
+}
+
+export interface TakeByCountOptions<V> {
+  target: ValueReactor<V>;
+  count: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor, but only for the first `count` emissions.
+ */
+export const takeByCount = <V>(
+  options: TakeByCountOptions<V>
+): Signal<V> => {
+  const { target, count } = options;
+
+  if (count <= 0) {
+    throw new Error("takeByCount operator requires count to be greater than 0")
+  }
+
+  const result = signal<V>(castValueInitializer<V>(), {
+    onDispose: () => {
+      eTarget.dispose()
+    }
+  })
+
+  let takenCount = 0
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+    if (takenCount < count) {
+      result.set(latestValue)
+      takenCount = takenCount + 1
+    }
+    if (takenCount >= count) {
+      eTarget.dispose()
+    }
+  })
+
+  return result
+}
+
+export interface TakeByTimeOptions<T> {
+  target: ValueReactor<T>;
+  time: number;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor, but only for the specified time in milliseconds.
+ */
+export const takeByTime = <T>(
+  options: TakeByTimeOptions<T>
+): Signal<T> => {
+  const { target, time } = options;
+
+  if (time <= 0) {
+    throw new Error("takeByTime operator requires timeInMilliseconds to be greater than 0")
+  }
+
+  const result = signal<T>(castValueInitializer<T>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      clearTimeout(timeoutId)
+    }
+  })
+
+  const timeoutId = setTimeout(() => {
+    eTarget.dispose()
+  }, time)
+
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+    result.set(latestValue)
+  })
+
+  return result
+}
+
+export interface TakeByTriggerOptions<VTarget, VTrigger> {
+  target: ValueReactor<VTarget>;
+  trigger: ValueReactor<VTrigger>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor whenever the trigger ValueReactor emits a value.
+ */
+export const takeByTrigger = <VTarget, VTrigger>(
+  options: TakeByTriggerOptions<VTarget, VTrigger>
+): Signal<VTarget> => {
+  const { target, trigger } = options;
+
+  const result = signal<VTarget>(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTrigger.dispose()
+    }
+  })
+
+  const eTrigger = effect(() => {
+    trigger.get()
+    result.set(target.getWithoutTrack())
+  })
+
+  return result
+}
+
+export interface TakeByToggleOptions<VTarget, VOpen, VClose> {
+  target: ValueReactor<VTarget>;
+  open: ValueReactor<VOpen>;
+  close: ValueReactor<VClose>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor when the close ValueReactor emits, but only
+ * if taking was started by the open ValueReactor.
+ */
+export const takeByToggle = <VTarget, VOpen, VClose>(
+  options: TakeByToggleOptions<VTarget, VOpen, VClose>
+): Signal<VTarget> => {
+  const { target, open, close } = options;
+
+  const result = signal<VTarget>(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eOpen.dispose()
+      eClose.dispose()
+    }
+  })
+
+  let taking = false
+
+  const eOpen = effect(() => {
+    open.get()
+    taking = true
+  })
+
+  const eTarget = effect(() => {
+    const value = target.get()
+    if (taking === true) {
+      result.set(value)
+    }
+  })
+
+  const eClose = effect(() => {
+    close.get()
+    taking = false
+  })
+
+  return result
+}
+
+export interface TakeUntilTriggerOptions<VTarget, VTrigger> {
+  target: ValueReactor<VTarget>;
+  trigger: ValueReactor<VTrigger>;
+}
+/**
+ * Returns a Signal that updates its value with the latest value from
+ * the target ValueReactor until the trigger ValueReactor emits a value.
+ */
+export const takeUntilTrigger = <VTarget, VTrigger>(
+  options: TakeUntilTriggerOptions<VTarget, VTrigger>
+): Signal<VTarget> => {
+  const { target, trigger } = options;
+
+  const result = signal<VTarget>(castValueInitializer<VTarget>(), {
+    onDispose: () => {
+      eTarget.dispose()
+      eTrigger.dispose()
+    }
+  })
+
+  const eTarget = effect(() => {
+    const latestValue = target.get()
+    result.set(latestValue)
+  })
+
+  const eTrigger = effect((context) => {
+    trigger.get()
+    if (context.isInitializingRun === false) {
+      eTarget.dispose()
+      eTrigger.dispose()
+    }
+  })
+
+  return result
+}