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
}
}