import { isFunction, asIs } from '../../internal/base' import { curryN } from '../../functional' import { TERMINATOR, isVacuo } from '../metas' import { Data, Mutation, isAtomLike } from '../atoms' import { replayWithLatest } from '../mediators' import { pipeAtom, binaryTweenPipeAtom } from '../helpers' import type { Terminator, Vacuo } from '../metas' import type { AtomLikeOfOutput } from '../atoms' type CompareBy = (target: V) => any /** * @param compareBy transform Funtion which will be applied to target value * before distinct comparison. * @param target Atom * @return Data * * @see {@link dynamicDistinctPreviousT}, {@link staticDistinctPreviousT} */ export const distinctPreviousT = ( compareBy: AtomLikeOfOutput> | CompareBy, target: AtomLikeOfOutput ): Data => { if (isFunction(compareBy)) { return staticDistinctPreviousT(compareBy, target) } else if (isAtomLike(compareBy)) { return dynamicDistinctPreviousT(compareBy, target) } else { throw (new TypeError('"compareBy" is expected to be type of "Function" or "AtomLike".')) } } interface IDistinctPreviousT_ { (compareBy: AtomLikeOfOutput> | CompareBy, target: AtomLikeOfOutput): Data (compareBy: AtomLikeOfOutput> | CompareBy): (target: AtomLikeOfOutput) => Data } /** * @see {@link distinctPreviousT} */ export const distinctPreviousT_: IDistinctPreviousT_ = curryN(2, distinctPreviousT) /** * @see {@link distinctPreviousT} */ export const dynamicDistinctPreviousT = ( compareBy: AtomLikeOfOutput>, target: AtomLikeOfOutput ): Data => { if (!isAtomLike(compareBy)) { throw (new TypeError('"compareBy" is expected to be type of "AtomLike".')) } if (!isAtomLike(target)) { throw (new TypeError('"target" is expected to be type of "AtomLike".')) } interface WrappedCompareBy { type: 'compareBy' value: Vacuo | CompareBy } const wrapCompareByM = Mutation.ofLiftLeft, WrappedCompareBy>(prev => ({ type: 'compareBy', value: prev })) const wrappedCompareByD = Data.empty() pipeAtom(wrapCompareByM, wrappedCompareByD) interface WrappedTarget { type: 'target' value: Vacuo | V } const wrapTargetM = Mutation.ofLiftLeft(prev => ({ type: 'target', value: prev })) const wrappedTargetD = Data.empty() pipeAtom(wrapTargetM, wrappedTargetD) const distinctM = Mutation.ofLiftLeft((() => { const _internalStates: { compareBy: boolean target: boolean previous: V | undefined } = { compareBy: false, target: false, previous: undefined } const _internalValues: { compareBy: CompareBy target: V | undefined } = { compareBy: asIs, target: undefined } return (prev: Vacuo | WrappedCompareBy | WrappedTarget): V | Terminator => { if (isVacuo(prev)) return TERMINATOR if (isVacuo(prev.value)) return TERMINATOR const { type } = prev _internalStates[type] = true _internalValues[type] = prev.value as any if (!_internalStates.compareBy || !_internalStates.target) { return TERMINATOR } if (type === 'compareBy') { // change of compareBy will not trigger target value emittion return TERMINATOR } else if (type === 'target') { const prevCompared = _internalValues.compareBy(_internalStates.previous as V) const compared = _internalValues.compareBy(_internalValues.target as V) if (prevCompared === compared) { return TERMINATOR } else { _internalStates.previous = _internalValues.target return _internalValues.target as V } } else { throw (new TypeError('Unexpected "type".')) } } })()) pipeAtom(wrappedTargetD, distinctM) pipeAtom(wrappedCompareByD, distinctM) const outputD = Data.empty() pipeAtom(distinctM, outputD) binaryTweenPipeAtom(compareBy, wrapCompareByM) binaryTweenPipeAtom(target, wrapTargetM) return outputD } interface IDynamicDistinctPreviousT_ { (compareBy: AtomLikeOfOutput>, target: AtomLikeOfOutput): Data (compareBy: AtomLikeOfOutput>): (target: AtomLikeOfOutput) => Data } /** * @see {@link dynamicDistinctPreviousT} */ export const dynamicDistinctPreviousT_: IDynamicDistinctPreviousT_ = curryN(2, dynamicDistinctPreviousT) /** * @see {@link distinctPreviousT} */ export const staticDistinctPreviousT = ( compareBy: CompareBy, target: AtomLikeOfOutput ): Data => { if (!isFunction(compareBy)) { throw (new TypeError('"compareBy" is expected to be type of "Function".')) } return dynamicDistinctPreviousT(replayWithLatest(1, Data.of(compareBy)), target) } interface IStaticDistinctPreviousT_ { (compareBy: CompareBy, target: AtomLikeOfOutput): Data (compareBy: CompareBy): (target: AtomLikeOfOutput) => Data } /** * @see {@link staticDistinctPreviousT} */ export const staticDistinctPreviousT_: IStaticDistinctPreviousT_ = curryN(2, staticDistinctPreviousT) type IAsIsDistinctPreviousT = (target: AtomLikeOfOutput) => Data /** * @see {@link distinctPreviousT} */ export const asIsDistinctPreviousT: IAsIsDistinctPreviousT = distinctPreviousT_(asIs)