calmm-js / atom.undo Goto Github PK

import {acyclicEqualsU, curry} from "infestines"
import {lens} from "partial.lenses"

//

const viewGetter = ({index, values}) => values[index]

const viewSetter = curry((toAct, next, {time, index, values}) => {
  const prev = values[index]
  const {delta, time: t} = toAct({time, prev, next})
  if (void 0 === delta)
    return {time: t, index, values}
  const i = index + delta
  const nextValues = values.slice(0, i)
  nextValues.push(next)
  return {time: t, index: i, values: nextValues}
})

//

export const init = ({time = Date.now(), value}) => ({
  time,
  index: 0,
  values: [value]
})

export const initial = history => history.values[0]

export const count = history => history.values.length

export const index = history => history.index
export const setIndex = curry((index, {time, values}) =>
  ({time, index: Math.max(0, Math.min(index, values.length-1)), values}))

export const undoCount = index
export const redoCount = history => count(history) - 1 - index(history)

export const shift = curry((delta, history) =>
  setIndex(index(history) + delta, history))

export const undo = shift(-1)
export const redo = shift(+1)

export const undoForget = ({time, index, values}) =>
  ({time, index: 0, values: values.slice(index)})
export const redoForget = ({time, index, values}) =>
  ({time, index, values: values.slice(0, index + 1)})

export const Push    = time => ({delta: 1, time})
export const Replace = time => ({delta: 0, time})
export const Ignore  = time => ({time})

export const ignoreEquals = ({time, prev, next}) =>
  acyclicEqualsU(prev, next) ? Ignore(time) : Push(time)

export const replaceYounger = curry((ms, {time, prev, next}) => {
  const now = Date.now()
  if (acyclicEqualsU(prev, next))
    return Ignore(now)
  return now - time < ms ? Replace(now) : Push(now)
})

export const viewAnd = toAct => lens(viewGetter, viewSetter(toAct))