import { curryN } from '../../functional' import { TERMINATOR, isVoid, isVacuo } from '../metas' import { Data, Mutation, isAtomLike } from '../atoms' import { replayWithLatest } from '../mediators' import { pipeAtom, binaryTweenPipeAtom } from '../helpers' import type { Vacuo, Terminator } from '../metas' import type { AtomLikeOfOutput } from '../atoms' /** * Takes a default value and a target atom as argument, * emit given default value if value of target atom isVoid. * * - dynamic version: default value must be an Atom. * - static version: default value can be any type of value. * * @param default Any | Atom * @param target Atom * @return Data * * @see {@link dynamicDefaultToT}, {@link staticDefaultToT} */ export const defaultToT = ( dft: V | AtomLikeOfOutput, target: AtomLikeOfOutput ): Data => { if (isAtomLike(dft)) { return dynamicDefaultToT(dft as AtomLikeOfOutput, target) } else { return staticDefaultToT(dft as V, target) } } interface IDefaultToT_ { (dft: V | AtomLikeOfOutput, target: AtomLikeOfOutput): Data (dft: V | AtomLikeOfOutput): (target: AtomLikeOfOutput) => Data } /** * @see {@link defaultToT} */ export const defaultToT_: IDefaultToT_ = curryN(2, defaultToT) /** * @see {@link defaultToT} */ export const dynamicDefaultToT = ( dft: AtomLikeOfOutput, target: AtomLikeOfOutput ): Data => { if (!isAtomLike(dft)) { throw (new TypeError('"dft" is expected to be type of "AtomLike".')) } if (!isAtomLike(target)) { throw (new TypeError('"target" is expected to be type of "AtomLike".')) } interface WrappedDft { type: 'dft' value: Vacuo | V } const wrapDftM = Mutation.ofLiftLeft(prev => ({ type: 'dft', value: prev })) const wrappedDftD = Data.empty() pipeAtom(wrapDftM, wrappedDftD) interface WrappedTarget { type: 'target' value: Vacuo | V } const wrapTargetM = Mutation.ofLiftLeft(prev => ({ type: 'target', value: prev })) const wrappedTargetD = Data.empty() pipeAtom(wrapTargetM, wrappedTargetD) const defaultM = Mutation.ofLiftLeft((() => { const _internalStates: { dft: boolean target: boolean } = { dft: false, target: false } const _internalValues: { dft: V | undefined target: V | undefined } = { dft: undefined, target: undefined } return (prev: Vacuo | WrappedDft | WrappedTarget): V | Terminator => { if (isVacuo(prev)) return TERMINATOR if (isVacuo(prev.value)) return TERMINATOR const { type } = prev _internalStates[type] = true _internalValues[type] = prev.value if (!_internalStates.dft || !_internalStates.target) { return TERMINATOR } if (type === 'dft') { return TERMINATOR } else if (type === 'target') { return (isVoid(_internalValues.target) ? _internalValues.dft : _internalValues.target) as V } else { throw (new TypeError('Unexpected "type".')) } } })()) pipeAtom(wrappedDftD, defaultM) pipeAtom(wrappedTargetD, defaultM) const outputD = Data.empty() pipeAtom(defaultM, outputD) binaryTweenPipeAtom(dft, wrapDftM) binaryTweenPipeAtom(target, wrapTargetM) return outputD } interface IDynamicDefaultToT_ { (dft: AtomLikeOfOutput, target: AtomLikeOfOutput): Data (dft: AtomLikeOfOutput): (target: AtomLikeOfOutput) => Data } /** * @see {@link dynamicDefaultToT} */ export const dynamicDefaultToT_: IDynamicDefaultToT_ = curryN(2, dynamicDefaultToT) /** * @see {@link defaultToT} */ export const staticDefaultToT = ( dft: V, target: AtomLikeOfOutput ): Data => { return dynamicDefaultToT(replayWithLatest(1, Data.of(dft)), target) } interface IStaticDefaultToT_ { (dft: V, target: AtomLikeOfOutput): Data (dft: V): (target: AtomLikeOfOutput) => Data } /** * @see {@link staticDefaultToT} */ export const staticDefaultToT_: IStaticDefaultToT_ = curryN(2, staticDefaultToT)