import { Get } from './Get' import { Extension } from './Extension'; import { Debug } from './Debug'; import * as DeepEqual from 'fast-deep-equal' import { Subtract, combine } from './util'; import { Update } from './Update'; export type SetSignature = ((b: B) => Update) & ({} extends Params ? (a: A, b: B) => A : (a: A, p: Params, b: B) => A) export type Set = SetSignature & { type: "set" _underlying: (a: A, params: Params, b: B) => A extend: (ext: Extension) => Set compose: (get: Get) => Set mapParams: (map: (p2: P2) => Params) => Set withParams: >(params: P2) => Set> debug: () => Set } export namespace Set { const normaliseArgs = (set: (a: A, p: P, b: B) => A) => function(a: A, p: P, b: B) { switch (arguments.length) { case 1: { const b = a as any as B return Update.create((aa, pp) => set(aa, pp, b)) } case 2: return set(a, undefined as any, p as any) default: return set(a, p, b) } } export const create = (set: (a: A, p: Params, b: B) => A, ext: Extension = Extension.none): Set => { const clone: any = (...args: any[]) => clone._underlying(...args) clone.type = "set" clone._equality = DeepEqual clone._underlying = normaliseArgs((a: A, p: Params, b: B) => { const result = set(a, p, b) // if the update had no effect, don't change the object reference return clone._equality(a, result) ? a : result }) clone.extend = (newExtension: Extension) => create(set, Extension.combine(ext, newExtension)) clone.compose = (get: Get) => create((a, p, c) => clone._underlying(a, p, get._underlying(c, p)), ext) clone.mapParams = (map: (p2: P2) => Params) => create((a, p, b) => clone(a, map(p), b)) clone.withParams = >(params: P2): Set> => create>((a, p, b) => clone(a, combine(p, params), b)) clone.debug = () => clone.extend(Debug()) ext.apply(clone) return clone as Set } }