Class History<T>

constructor

• new History<T>(state, maxLen?, changed?): History<T>

• Type Parameters

  • T

  Parameters

  • state: IAtom<T>

    parent state
  • maxLen: number = 100

    max size of undo stack
  • Optional changed: Predicate2<T>

    predicate to determine changed values (default !equiv(a,b))

  Returns History<T>

changed

future

history

maxLen

state

value

• get value(): T

• Returns T

• set value(val): void

• Parameters

  • val: T

  Returns void

addListener

• addListener(id, fn, scope?): boolean

• Parameters

  • id: HistoryEventType
  • fn: Listener<HistoryEventType>
  • Optional scope: any

  Returns boolean

addWatch

• addWatch(id, fn): boolean

• IWatch.addWatch() implementation. Delegates to wrapped atom/cursor.

  Parameters

  • id: string

    watch ID
  • fn: Watch<T>

    watch function

  Returns boolean

canRedo

• canRedo(): boolean

• Returns boolean

canUndo

• canUndo(): boolean

• Returns boolean

clear

• clear(): void

• Clears history & future stacks

  Returns void

deref

• deref(): T

• Returns wrapped atom's current value.

  Returns T

notify

• notify(e): boolean

• Parameters

  • e: Event<HistoryEventType>

  Returns boolean

notifyWatches

• notifyWatches(oldState, newState): void

• IWatch.notifyWatches() implementation. Delegates to wrapped atom/cursor.

  Parameters

  • oldState: T
  • newState: T

  Returns void

record

• record(state?): void

• Records given state in history. This method is only needed when manually managing snapshots, i.e. when applying multiple swaps on the wrapped atom directly, but not wanting to create an history entry for each change.

  Parameters

  • Optional state: T

    state to record

  Returns void

  Remarks

  DO NOT call this explicitly if using History.reset / History.swap etc.

  If no state is given, uses the wrapped atom's current state value (user code SHOULD always call without arg).

  If recording succeeded, the History.EVENT_RECORD event is emitted with the recorded state provided as event value.

redo

• redo(): undefined | T

• Attempts to re-apply most recent value from future stack to atom and returns it if successful (i.e. there's a future).

  Returns undefined | T

  Remarks

  Before the switch, first records the atom's current value into the history stack (to enable History.undo feature). Returns undefined if there's no future (so sad!).

  If redo was possible, the History.EVENT_REDO event is emitted after the restoration with both the prev and curr (restored) states provided as event value (and object with these two keys). This allows for additional state handling to be executed, e.g. application of the "Command pattern". See History.addListener for registering event listeners.

release

• release(): boolean

• Returns boolean

removeListener

• removeListener(id, fn, scope?): boolean

• Parameters

  • id: HistoryEventType
  • fn: Listener<HistoryEventType>
  • Optional scope: any

  Returns boolean

removeWatch

• removeWatch(id): boolean

• IWatch.removeWatch() implementation. Delegates to wrapped atom/cursor.

  Parameters

  • id: string

    watch iD

  Returns boolean

reset

• reset(val): T

• IReset.reset() implementation. Delegates to wrapped atom/cursor, but too applies changed predicate to determine if there was a change and if the previous value should be recorded.

  Parameters

  • val: T

    replacement value

  Returns T

resetIn

• resetIn(path, val): T

• Parameters

  • path: readonly []
  • val: T

  Returns T

• resetIn<A>(path, val): T

• Type Parameters

  • A

  Parameters

  • path: Path1<T, A>
  • val: ValNReducer<T, A, []>

  Returns T

• resetIn<A, B>(path, val): T

• Type Parameters

  • A
  • B

  Parameters

  • path: Path2<T, A, B>
  • val: ValNReducer<T, A, [B]>

  Returns T

• resetIn<A, B, C>(path, val): T

• Type Parameters

  • A
  • B
  • C

  Parameters

  • path: Path3<T, A, B, C>
  • val: ValNReducer<T, A, [B, C]>

  Returns T

• resetIn<A, B, C, D>(path, val): T

• Type Parameters

  • A
  • B
  • C
  • D

  Parameters

  • path: Path4<T, A, B, C, D>
  • val: ValNReducer<T, A, [B, C, D]>

  Returns T

• resetIn<A, B, C, D, E>(path, val): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E

  Parameters

  • path: Path5<T, A, B, C, D, E>
  • val: ValNReducer<T, A, [B, C, D, E]>

  Returns T

• resetIn<A, B, C, D, E, F>(path, val): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F

  Parameters

  • path: Path6<T, A, B, C, D, E, F>
  • val: ValNReducer<T, A, [B, C, D, E, F]>

  Returns T

• resetIn<A, B, C, D, E, F, G>(path, val): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F
  • G

  Parameters

  • path: Path7<T, A, B, C, D, E, F, G>
  • val: ValNReducer<T, A, [B, C, D, E, F, G]>

  Returns T

• resetIn<A, B, C, D, E, F, G, H>(path, val): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F
  • G
  • H

  Parameters

  • path: Path8<T, A, B, C, D, E, F, G, H>
  • val: ValNReducer<T, A, [B, C, D, E, F, G, H]>

  Returns T

• resetIn<A, B, C, D, E, F, G, H>(path, val): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F
  • G
  • H

  Parameters

  • path: DeepPath<T, A, B, C, D, E, F, G, H>
  • val: any

  Returns T

resetInUnsafe

• resetInUnsafe(path, val): T

• Parameters

  • path: Path
  • val: any

  Returns T

swap

• swap(fn, ...args): T

• ISwap.swap() implementation. Delegates to wrapped atom/cursor, but too applies changed predicate to determine if there was a change and if the previous value should be recorded.

  Parameters

  • fn: SwapFn<T, T>

    update function
  • Rest ...args: any[]

    additional args passed to fn

  Returns T

swapIn

• swapIn<A>(path, fn, ...args): T

• Type Parameters

  • A

  Parameters

  • path: readonly []
  • fn: SwapFn<T, T>
  • Rest ...args: any[]

  Returns T

• swapIn<A>(path, fn, ...args): T

• Type Parameters

  • A

  Parameters

  • path: Path1<T, A>
  • fn: SwapFn<OptVal<IsOptR<T, A, []>, ValNReducer<T, A, []>>, ValNReducer<T, A, []>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B>(path, fn, ...args): T

• Type Parameters

  • A
  • B

  Parameters

  • path: Path2<T, A, B>
  • fn: SwapFn<OptVal<IsOptR<T, A, [B]>, ValNReducer<T, A, [B]>>, ValNReducer<T, A, [B]>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B, C>(path, fn, ...args): T

• Type Parameters

  • A
  • B
  • C

  Parameters

  • path: Path3<T, A, B, C>
  • fn: SwapFn<OptVal<IsOptR<T, A, [B, C]>, ValNReducer<T, A, [B, C]>>, ValNReducer<T, A, [B, C]>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B, C, D>(path, fn, ...args): T

• Type Parameters

  • A
  • B
  • C
  • D

  Parameters

  • path: Path4<T, A, B, C, D>
  • fn: SwapFn<OptVal<IsOptR<T, A, [B, C, D]>, ValNReducer<T, A, [B, C, D]>>, ValNReducer<T, A, [B, C, D]>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B, C, D, E>(path, fn, ...args): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E

  Parameters

  • path: Path5<T, A, B, C, D, E>
  • fn: SwapFn<OptVal<IsOptR<T, A, [B, C, D, E]>, ValNReducer<T, A, [B, C, D, E]>>, ValNReducer<T, A, [B, C, D, E]>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B, C, D, E, F>(path, fn, ...args): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F

  Parameters

  • path: Path6<T, A, B, C, D, E, F>
  • fn: SwapFn<OptVal<IsOptR<T, A, [B, C, D, E, F]>, ValNReducer<T, A, [B, C, D, E, F]>>, ValNReducer<T, A, [B, C, D, E, F]>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B, C, D, E, F, G>(path, fn, ...args): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F
  • G

  Parameters

  • path: Path7<T, A, B, C, D, E, F, G>
  • fn: SwapFn<OptVal<IsOptR<T, A, [B, C, D, E, F, G]>, ValNReducer<T, A, [B, C, D, E, F, G]>>, ValNReducer<T, A, [B, C, D, E, F, G]>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B, C, D, E, F, G, H>(path, fn, ...args): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F
  • G
  • H

  Parameters

  • path: Path8<T, A, B, C, D, E, F, G, H>
  • fn: SwapFn<OptVal<IsOptR<T, A, [B, C, D, E, F, G, H]>, ValNReducer<T, A, [B, C, D, E, F, G, H]>>, ValNReducer<T, A, [B, C, D, E, F, G, H]>>
  • Rest ...args: any[]

  Returns T

• swapIn<A, B, C, D, E, F, G, H>(path, fn, ...args): T

• Type Parameters

  • A
  • B
  • C
  • D
  • E
  • F
  • G
  • H

  Parameters

  • path: DeepPath<T, A, B, C, D, E, F, G, H>
  • fn: SwapFn<any, any>
  • Rest ...args: any[]

  Returns T

swapInUnsafe

• swapInUnsafe(path, fn, ...args): T

• Parameters

  • path: Path
  • fn: SwapFn<any, any>
  • Rest ...args: any[]

  Returns T

undo

• undo(): undefined | T

• Attempts to re-apply most recent historical value to atom and returns it if successful (i.e. there's a history).

  Returns undefined | T

  Remarks

  Before the switch, first records the atom's current value into the future stack (to enable History.redo feature). Returns undefined if there's no history.

  If undo was possible, the History.EVENT_UNDO event is emitted after the restoration with both the prev and curr (restored) states provided as event value (and object with these two keys). This allows for additional state handling to be executed, e.g. application of the "Command pattern". See History.addListener for registering event listeners.