@politie/sherlock-utils 3.4.15 → 3.4.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@politie/sherlock-utils",
-    "version": "3.4.15",
+    "version": "3.4.17",
     "description": "Utility functions that are designed to work with Sherlock. His toolbelt.",
     "main": "sherlock-utils.cjs.js",
     "module": "sherlock-utils.esm.js",
@@ -37,6 +37,6 @@
         "tslib": "^2.2.0"
     },
     "peerDependencies": {
-        "@politie/sherlock": "3.4.15"
+        "@politie/sherlock": "3.4.17"
     }
 }

package/sherlock-utils.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-utils.cjs.js","sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"names":["_internal","isSettableDerivable","lens","atom","isDerivable","__extends","PullDataSource","ErrorWrapper","unresolved","derive","unwrap","utils"],"mappings":"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"}
+{"version":3,"file":"sherlock-utils.cjs.js","sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"names":["_internal","isSettableDerivable","lens","atom","isDerivable","__extends","PullDataSource","ErrorWrapper","unresolved","derive","unwrap","utils"],"mappings":"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"}

package/sherlock-utils.cjs.min.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var r=require("@politie/sherlock"),n=require("tslib");function t(){return new Map}var e=function(r){function t(n){var t=r.call(this)||this;return t.fn=n,t}return n.__extends(t,r),t.prototype.calculateCurrentValue=function(){return this.fn()},t.prototype.changed=function(){r.prototype.checkForChanges.call(this)},t}(r.PullDataSource);function u(r){return o(r.getState())}function o(n){return n===r.unresolved?{errored:!1,resolved:!1}:n instanceof r.ErrorWrapper?{error:n.error,errored:!0,resolved:!0}:{value:n,errored:!1,resolved:!0}}function i(n){return n.errored?new r.ErrorWrapper(n.error):n.resolved?n.value:r.unresolved}function f(r){return r.mapState(o)}function c(r,n){n.resolved?n.errored?r.setError(n.error):r.set(n.value):r.unset()}var s=p((function(r){return!r})),a=p((function(r){return!!r})),v=p((function(r){return null!=r}));function p(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return r.derive((function(){for(var e,u=0,o=t;u<o.length;u++){var i=o[u];if(e=r.unwrap(i),n(e))break}return e}))}}function x(n){if(r.isDerivable(n))return n.get();if(Array.isArray(n))return n.map(x);if(r.utils.isPlainObject(n)){for(var t={},e=0,u=Object.keys(n);e<u.length;e++){var o=u[e];t[o]=x(n[o])}return t}return n}exports.FunctionDataSource=e,exports.and=s,exports.copyState=function(r,n){c(n,u(r))},exports.dematerialize=function(r){return r.map(i)},exports.derivableCache=function(n){var e=(n.mapFactory||t)(),u=n.delayedEviction,o=n.derivableFactory,i={get:function(n){var t=e.get(n);if(t)return t.getState();var i=r._internal.independentTracking((function(){return o(n)})),f=r.isSettableDerivable(i)?r.lens({get:function(){return i.get()},set:function(r){return i.set(r)}},r.atom(0)):r.atom(0).derive((function(){return i.get()}));u&&f.autoCache();var c=f.getState();return f.connected&&(f.__cachedProxy=this,e.set(n,f),f.connected$.react((function(){return e.delete(n)}),{skipFirst:!0,once:!0})),c},set:function(n,t){var u=e.get(t)||o(t);if(!r.isSettableDerivable(u))throw r._internal.augmentStack(Error("Cached derivable is not settable"),u);u.set(n)}};return function(n){if(!r.isDerivable(n)){var t=e.get(n);if(t)return t.__cachedProxy}return r.lens(i,n)}},exports.firstNotNull=v,exports.fromPromise=function(n){var t=r.atom.unresolved();return n.then((function(r){return t.setFinal(r)}),(function(n){return t.setFinal(new r.ErrorWrapper(n))})),t},exports.fromStateObject=i,exports.getStateObject=u,exports.lift=function(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return new r._internal.Derivation(n,t)}},exports.materialize=f,exports.or=a,exports.pairwise=function(r,n){var t=n;return function(n){var e=r.call(this,n,t);return t=n,e}},exports.peek=function(n){return r._internal.independentTracking((function(){return n.get()}))},exports.peekState=function(n){return r._internal.independentTracking((function(){return n.getState()}))},exports.peekValue=function(n){return r._internal.independentTracking((function(){return n.value}))},exports.scan=function(r,n){var t=n;return function(n){return t=r.call(this,t,n)}},exports.setStateObject=c,exports.struct=function(n){if(r.isDerivable(n))return n;if(!Array.isArray(n)&&!r.utils.isPlainObject(n))throw Error('"struct" only accepts Derivables, plain Objects and Arrays');return r.derive(x,n)},exports.syncState=function(r,n,t){return f(r).react((function(r){return c(n,r)}),t)},exports.template=function(n){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return r.derive((function(){for(var e="",u=0;u<n.length;u++)e+=n[u],u<t.length&&(e+=r.unwrap(t[u]));return e}))},exports.toStateObject=o;
+Object.defineProperty(exports,"__esModule",{value:!0});var r=require("@politie/sherlock"),n=require("tslib");function t(){return new Map}var e="__cachedProxy",u=function(r){function t(n){var t=r.call(this)||this;return t.fn=n,t}return n.__extends(t,r),t.prototype.calculateCurrentValue=function(){return this.fn()},t.prototype.changed=function(){r.prototype.checkForChanges.call(this)},t}(r.PullDataSource);function o(r){return i(r.getState())}function i(n){return n===r.unresolved?{errored:!1,resolved:!1}:n instanceof r.ErrorWrapper?{error:n.error,errored:!0,resolved:!0}:{value:n,errored:!1,resolved:!0}}function f(n){return n.errored?new r.ErrorWrapper(n.error):n.resolved?n.value:r.unresolved}function c(r){return r.mapState(i)}function s(r,n){n.resolved?n.errored?r.setError(n.error):r.set(n.value):r.unset()}var a=x((function(r){return!r})),v=x((function(r){return!!r})),p=x((function(r){return null!=r}));function x(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return r.derive((function(){for(var e,u=0,o=t;u<o.length;u++){var i=o[u];if(e=r.unwrap(i),n(e))break}return e}))}}function l(n){if(r.isDerivable(n))return n.get();if(Array.isArray(n))return n.map(l);if(r.utils.isPlainObject(n)){for(var t={},e=0,u=Object.keys(n);e<u.length;e++){var o=u[e];t[o]=l(n[o])}return t}return n}exports.FunctionDataSource=u,exports.and=a,exports.copyState=function(r,n){s(n,o(r))},exports.dematerialize=function(r){return r.map(f)},exports.derivableCache=function(n){var u=(n.mapFactory||t)(),o=n.delayedEviction,i=n.derivableFactory,f={get:function(n){var t=u.get(n);if(t)return t.getState();var f=r._internal.independentTracking((function(){return i(n)})),c=r.isSettableDerivable(f)?r.lens({get:function(){return f.get()},set:function(r){return f.set(r)}},r.atom(0)):r.atom(0).derive((function(){return f.get()}));o&&c.autoCache();var s=c.getState();return c.connected&&(c[e]=this,u.set(n,c),c.connected$.react((function(){return u.delete(n)}),{skipFirst:!0,once:!0})),s},set:function(n,t){var e=u.get(t)||i(t);if(!r.isSettableDerivable(e))throw r._internal.augmentStack(Error("Cached derivable is not settable"),e);e.set(n)}};return function(n){if(!r.isDerivable(n)){var t=u.get(n);if(t)return t[e]}return r.lens(f,n)}},exports.firstNotNull=p,exports.fromPromise=function(n){var t=r.atom.unresolved();return n.then((function(r){return t.setFinal(r)}),(function(n){return t.setFinal(new r.ErrorWrapper(n))})),t},exports.fromStateObject=f,exports.getStateObject=o,exports.lift=function(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return new r._internal.Derivation(n,t)}},exports.materialize=c,exports.or=v,exports.pairwise=function(r,n){var t=n;return function(n){var e=r.call(this,n,t);return t=n,e}},exports.peek=function(n){return r._internal.independentTracking((function(){return n.get()}))},exports.peekState=function(n){return r._internal.independentTracking((function(){return n.getState()}))},exports.peekValue=function(n){return r._internal.independentTracking((function(){return n.value}))},exports.scan=function(r,n){var t=n;return function(n){return t=r.call(this,t,n)}},exports.setStateObject=s,exports.struct=function(n){if(r.isDerivable(n))return n;if(!Array.isArray(n)&&!r.utils.isPlainObject(n))throw Error('"struct" only accepts Derivables, plain Objects and Arrays');return r.derive(l,n)},exports.syncState=function(r,n,t){return c(r).react((function(r){return s(n,r)}),t)},exports.template=function(n){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return r.derive((function(){for(var e="",u=0;u<n.length;u++)e+=n[u],u<t.length&&(e+=r.unwrap(t[u]));return e}))},exports.toStateObject=i;
 //# sourceMappingURL=sherlock-utils.cjs.min.js.map

package/sherlock-utils.cjs.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-utils.cjs.min.js","names":["defaultMapFactory","Map","FunctionDataSource","fn","_this","_super","call","this","__extends","prototype","calculateCurrentValue","changed","checkForChanges","PullDataSource","getStateObject","from","toStateObject","getState","state","unresolved","errored","resolved","ErrorWrapper","error","value","fromStateObject","materialize","derivable","mapState","setStateObject","to","setError","set","unset","and","andOrImpl","v","or","firstNotNull","breakOn","args","_i","arguments","length","derive","args_1","arg","unwrap","deepUnwrap","obj","isDerivable","get","Array","isArray","map","utils","isPlainObject","result","_a","Object","keys","key","opts","cache","mapFactory","delayedEviction","derivableFactory","descriptor","cachedDerivable","newDerivable","_internal","independentTracking","isSettableDerivable","lens","atom","autoCache","connected","connected$","react","delete","skipFirst","once","newValue","augmentStack","Error","cacheItem","prom","atom$","then","setFinal","e","f","ps","Derivation","init","oldValue","d","seed","acc","parts","s","i"],"sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"mappings":"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"}
+{"version":3,"file":"sherlock-utils.cjs.min.js","names":["defaultMapFactory","Map","CACHED_PROXY","FunctionDataSource","_super","fn","_this","call","this","__extends","prototype","calculateCurrentValue","changed","checkForChanges","PullDataSource","getStateObject","from","toStateObject","getState","state","unresolved","errored","resolved","ErrorWrapper","error","value","fromStateObject","materialize","derivable","mapState","setStateObject","to","setError","set","unset","and","andOrImpl","v","or","firstNotNull","breakOn","args","_i","arguments","length","derive","args_1","arg","unwrap","deepUnwrap","obj","isDerivable","get","Array","isArray","map","utils","isPlainObject","result","_a","Object","keys","key","opts","cache","mapFactory","delayedEviction","derivableFactory","descriptor","cachedDerivable","newDerivable","_internal","independentTracking","isSettableDerivable","lens","atom","autoCache","connected","connected$","react","delete","skipFirst","once","newValue","augmentStack","Error","cacheItem","prom","atom$","then","setFinal","e","f","ps","Derivation","init","oldValue","d","seed","acc","parts","s","i"],"sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"mappings":"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","ignoreList":[]}

package/sherlock-utils.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-utils.esm.js","sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"names":[],"mappings":";;;AAgBA,SAAS,iBAAiB,KAAoC,OAAO,IAAI,GAAG,CAAC,EAAE;AAE/E,IAAM,YAAY,GAAG,eAAe,CAAC;SAErB,cAAc,CAAO,IAAiC;IAClE,IAAM,KAAK,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,iBAAiB,GAAG,CAAC;IAE/C,IAAA,eAAe,GAAuB,IAAI,gBAA3B,EAAE,gBAAgB,GAAK,IAAI,iBAAT,CAAU;IACnD,IAAM,UAAU,GAAyB;QACrC,GAAG,YAAC,GAAG;YACH,IAAM,eAAe,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;;YAEvC,IAAI,eAAe,EAAE;gBACjB,OAAO,eAAe,CAAC,QAAQ,EAAE,CAAC;aACrC;;YAGD,IAAM,YAAY,GAAG,SAAS,CAAC,mBAAmB,CAAC,cAAM,OAAA,gBAAgB,CAAC,GAAG,CAAC,GAAA,CAAC,CAAC;;;;YAIhF,IAAM,SAAS,GAAG,mBAAmB,CAAC,YAAY,CAAC;kBAC7C,IAAI,CAAC,EAAE,GAAG,EAAE,cAAM,OAAA,YAAY,CAAC,GAAG,EAAE,GAAA,EAAE,GAAG,EAAE,UAAA,CAAC,IAAI,OAAA,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,GAAA,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;kBAC/E,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,cAAM,OAAA,YAAY,CAAC,GAAG,EAAE,GAAA,CAAC,CAAC;YAE/C,IAAI,eAAe,EAAE;gBACjB,SAAS,CAAC,SAAS,EAAE,CAAC;aACzB;;YAGD,IAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;YACnC,IAAI,SAAS,CAAC,SAAS,EAAE;gBACrB,SAAS,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;gBAC/B,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;gBAC1B,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,cAAM,OAAA,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,GAAA,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;aACxF;YACD,OAAO,KAAK,CAAC;SAChB;QACD,GAAG,YAAC,QAAQ,EAAE,GAAG;YACb,IAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,CAAC;YAC1D,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,EAAE;gBACjC,MAAM,SAAS,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,kCAAkC,CAAC,EAAE,SAAS,CAAC,CAAC;aAC1F;YACD,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;SAC3B;KACJ,CAAC;IAEF,OAAO,UAAA,GAAG;QACN,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE;YACnB,IAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACjC,IAAI,SAAS,EAAE;gBACX,OAAO,SAAS,CAAC,YAAY,CAAC,CAAC;aAClC;SACJ;QAED,OAAO,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;KAChC,CAAC;AACN;;ACvEA;;;;;IAI2C,sCAAiB;;;IAGxD,4BAA6B,EAAW;QAAxC,YACI,iBAAO,SACV;QAF4B,QAAE,GAAF,EAAE,CAAS;;KAEvC;;;;;;IAOD,kDAAqB,GAArB;QACI,OAAO,IAAI,CAAC,EAAE,EAAE,CAAC;KACpB;;;;IAKD,oCAAO,GAAP;QACI,iBAAM,eAAe,WAAE,CAAC;KAC3B;IACL,yBAAC;AAAD,CAtBA,CAA2C,cAAc;;SCJzC,WAAW,CAAI,IAAgB;IAC3C,IAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAK,CAAC;IACnC,IAAI,CAAC,IAAI,CAAC,UAAA,CAAC,IAAI,OAAA,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAA,EAAE,UAAA,CAAC,IAAI,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,GAAA,CAAC,CAAC;IAC5E,OAAO,KAAK,CAAC;AACjB;;SCWgB,IAAI,CAAO,CAAoB;IAC3C,OAAO;QAAC,YAA8B;aAA9B,UAA8B,EAA9B,qBAA8B,EAA9B,IAA8B;YAA9B,uBAA8B;;QAAK,OAAA,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC;KAAA,CAAC;AAC/E;;SCAgB,QAAQ,CAAU,CAAuD,EAAE,IAAQ;IAC/F,IAAI,QAAQ,GAAG,IAAI,CAAC;IACpB,OAAO,SAAS,OAAO,CAAC,QAAQ;QAC5B,IAAM,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAChD,QAAQ,GAAG,QAAQ,CAAC;QACpB,OAAO,MAAM,CAAC;KACjB,CAAC;AACN;;ACxBA;;;SAGgB,SAAS,CAAI,CAAe;IACxC,OAAO,SAAS,CAAC,mBAAmB,CAAC,cAAM,OAAA,CAAC,CAAC,QAAQ,EAAE,GAAA,CAAC,CAAC;AAC7D,CAAC;AAED;;;SAGgB,IAAI,CAAI,CAAe;IACnC,OAAO,SAAS,CAAC,mBAAmB,CAAC,cAAM,OAAA,CAAC,CAAC,GAAG,EAAE,GAAA,CAAC,CAAC;AACxD,CAAC;AAED;;;SAGgB,SAAS,CAAI,CAAe;IACxC,OAAO,SAAS,CAAC,mBAAmB,CAAC,cAAM,OAAA,CAAC,CAAC,KAAK,GAAA,CAAC,CAAC;AACxD;;SCAgB,IAAI,CAAU,CAA+C,EAAE,IAAQ;IACnF,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,OAAO,SAAS,OAAO,CAAC,KAAK;QACzB,OAAO,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;KACzC,CAAC;AACN;;SCnBgB,cAAc,CAAI,IAAkB;IAChD,OAAO,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC1C,CAAC;SAEe,aAAa,CAAI,KAAe;IAC5C,IAAI,KAAK,KAAK,UAAU,EAAE;QACtB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;KAC9C;IACD,IAAI,KAAK,YAAY,YAAY,EAAE;QACvB,IAAA,KAAK,GAAK,KAAK,MAAV,CAAW;QACxB,OAAO,EAAE,KAAK,OAAA,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;KACnD;IACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5D,CAAC;SAEe,eAAe,CAAI,KAAqB;IACpD,IAAI,KAAK,CAAC,OAAO,EAAE;QACf,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;KACxC;IACD,IAAI,KAAK,CAAC,QAAQ,EAAE;QAChB,OAAO,KAAK,CAAC,KAAK,CAAC;KACtB;IACD,OAAO,UAAU,CAAC;AACtB,CAAC;SAEe,WAAW,CAAI,SAAuB;IAClD,OAAO,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;AAC7C,CAAC;SAEe,aAAa,CAAI,SAAoC;IACjE,OAAO,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAC1C,CAAC;SAEe,cAAc,CAAI,EAAoB,EAAE,KAAqB;IACzE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE;QACjB,EAAE,CAAC,KAAK,EAAE,CAAC;KACd;SAAM,IAAI,KAAK,CAAC,OAAO,EAAE;QACtB,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;KAC5B;SAAM;QACH,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;KACvB;AACL,CAAC;SAEe,SAAS,CAAI,IAAkB,EAAE,EAAoB,EAAE,IAA8C;IACjH,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,UAAA,KAAK,IAAI,OAAA,cAAc,CAAC,EAAE,EAAE,KAAK,CAAC,GAAA,EAAE,IAAI,CAAC,CAAC;AAC7E,CAAC;SAEe,SAAS,CAAI,IAAkB,EAAE,EAAoB;IACjE,cAAc,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7C;;ACtDA;;;;;IAKa,GAAG,GAAG,SAAS,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,GAAA,EAAE;AAEtC;;;;;IAKa,EAAE,GAAG,SAAS,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,GAAA,EAAE;AAEtC;;;;;IAKa,YAAY,GAAG,SAAS,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,IAAI,IAAI,GAAA,EAAE;AAEtD,SAAS,SAAS,CAAC,OAA4B;IAC3C,OAAO;QAAI,cAAgC;aAAhC,UAAgC,EAAhC,qBAAgC,EAAhC,IAAgC;YAAhC,yBAAgC;;QAAK,OAAA,MAAM,CAAC;YACnD,IAAI,KAAoB,CAAC;YACzB,KAAkB,UAAI,EAAJ,aAAI,EAAJ,kBAAI,EAAJ,IAAI,EAAE;gBAAnB,IAAM,GAAG,aAAA;gBACV,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBACpB,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;oBAChB,MAAM;iBACT;aACJ;YACD,OAAO,KAAM,CAAC;SACjB,CAAC;KAAA,CAAC;AACP;;SCdgB,MAAM,CAAC,GAAQ;IAC3B,IAAI,WAAW,CAAC,GAAG,CAAC,EAAE;QAClB,OAAO,GAAG,CAAC;KACd;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE;QAClD,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;KACjF;IACD,OAAO,MAAM,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,UAAU,CAAC,GAAQ;IACxB,IAAI,WAAW,CAAC,GAAG,CAAC,EAAE;QAClB,OAAO,GAAG,CAAC,GAAG,EAAE,CAAC;KACpB;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;QACpB,OAAO,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;KAC9B;IACD,IAAI,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE;QAC1B,IAAM,MAAM,GAAG,EAAE,CAAC;QAClB,KAAkB,UAAgB,EAAhB,KAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAhB,cAAgB,EAAhB,IAAgB,EAAE;YAA/B,IAAM,GAAG,SAAA;YACV,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;SACtC;QACD,OAAO,MAAM,CAAC;KACjB;IACD,OAAO,GAAG,CAAC;AACf;;AC3CA;;;;;;;;;;;;;;;SAegB,QAAQ,CAAC,KAA2B;IAAE,cAAc;SAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;QAAd,6BAAc;;IAChE,OAAO,MAAM,CAAC;QACV,IAAI,CAAC,GAAG,EAAE,CAAC;QACX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;YACd,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE;gBACjB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;aACxB;SACJ;QACD,OAAO,CAAC,CAAC;KACZ,CAAC,CAAC;AACP;;;;"}
+{"version":3,"file":"sherlock-utils.esm.js","sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"names":[],"mappings":";;;AAgBA,SAAS,iBAAiB,GAAoC,EAAA,OAAO,IAAI,GAAG,CAAC,EAAE;AAE/E,IAAM,YAAY,GAAG,eAAe,CAAC;AAE/B,SAAU,cAAc,CAAO,IAAiC,EAAA;IAClE,IAAM,KAAK,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,iBAAiB,GAAG,CAAC;IAE/C,IAAA,eAAe,GAAuB,IAAI,CAAA,eAA3B,EAAE,gBAAgB,GAAK,IAAI,CAAA,gBAAT,CAAU;AACnD,IAAA,IAAM,UAAU,GAAyB;AACrC,QAAA,GAAG,YAAC,GAAG,EAAA;YACH,IAAM,eAAe,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;;AAEvC,YAAA,IAAI,eAAe,EAAE;AACjB,gBAAA,OAAO,eAAe,CAAC,QAAQ,EAAE,CAAC;AACrC,aAAA;;AAGD,YAAA,IAAM,YAAY,GAAG,SAAS,CAAC,mBAAmB,CAAC,YAAA,EAAM,OAAA,gBAAgB,CAAC,GAAG,CAAC,CAArB,EAAqB,CAAC,CAAC;;;;AAIhF,YAAA,IAAM,SAAS,GAAG,mBAAmB,CAAC,YAAY,CAAC;AAC/C,kBAAE,IAAI,CAAC,EAAE,GAAG,EAAE,YAAA,EAAM,OAAA,YAAY,CAAC,GAAG,EAAE,CAAlB,EAAkB,EAAE,GAAG,EAAE,UAAA,CAAC,IAAI,OAAA,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAnB,EAAmB,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;AACjF,kBAAE,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,YAAM,EAAA,OAAA,YAAY,CAAC,GAAG,EAAE,CAAlB,EAAkB,CAAC,CAAC;AAE/C,YAAA,IAAI,eAAe,EAAE;gBACjB,SAAS,CAAC,SAAS,EAAE,CAAC;AACzB,aAAA;;AAGD,YAAA,IAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;YACnC,IAAI,SAAS,CAAC,SAAS,EAAE;AACrB,gBAAA,SAAS,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;AAC/B,gBAAA,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;gBAC1B,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,YAAM,EAAA,OAAA,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,GAAA,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AACxF,aAAA;AACD,YAAA,OAAO,KAAK,CAAC;SAChB;QACD,GAAG,EAAA,UAAC,QAAQ,EAAE,GAAG,EAAA;AACb,YAAA,IAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,CAAC;AAC1D,YAAA,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,EAAE;AACjC,gBAAA,MAAM,SAAS,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,kCAAkC,CAAC,EAAE,SAAS,CAAC,CAAC;AAC1F,aAAA;AACD,YAAA,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;SAC3B;KACJ,CAAC;AAEF,IAAA,OAAO,UAAA,GAAG,EAAA;AACN,QAAA,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE;YACnB,IAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACjC,YAAA,IAAI,SAAS,EAAE;AACX,gBAAA,OAAO,SAAS,CAAC,YAAY,CAAC,CAAC;AAClC,aAAA;AACJ,SAAA;AAED,QAAA,OAAO,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;AACjC,KAAC,CAAC;AACN;;ACvEA;;;AAGG;AACH,IAAA,kBAAA,kBAAA,UAAA,MAAA,EAAA;IAA2C,SAAiB,CAAA,kBAAA,EAAA,MAAA,CAAA,CAAA;;;AAGxD,IAAA,SAAA,kBAAA,CAA6B,EAAW,EAAA;AAAxC,QAAA,IAAA,KAAA,GACI,iBAAO,IACV,IAAA,CAAA;QAF4B,KAAE,CAAA,EAAA,GAAF,EAAE,CAAS;;KAEvC;AAED;;;;AAIG;AACH,IAAA,kBAAA,CAAA,SAAA,CAAA,qBAAqB,GAArB,YAAA;AACI,QAAA,OAAO,IAAI,CAAC,EAAE,EAAE,CAAC;KACpB,CAAA;AAED;;AAEG;AACH,IAAA,kBAAA,CAAA,SAAA,CAAA,OAAO,GAAP,YAAA;QACI,MAAM,CAAA,SAAA,CAAA,eAAe,WAAE,CAAC;KAC3B,CAAA;IACL,OAAC,kBAAA,CAAA;AAAD,CAtBA,CAA2C,cAAc,CAsBxD;;AC1BK,SAAU,WAAW,CAAI,IAAgB,EAAA;AAC3C,IAAA,IAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAK,CAAC;AACnC,IAAA,IAAI,CAAC,IAAI,CAAC,UAAA,CAAC,EAAI,EAAA,OAAA,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAA,EAAE,UAAA,CAAC,EAAI,EAAA,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAnC,EAAmC,CAAC,CAAC;AAC5E,IAAA,OAAO,KAAK,CAAC;AACjB;;ACWM,SAAU,IAAI,CAAO,CAAoB,EAAA;IAC3C,OAAO,YAAA;QAAC,IAA8B,EAAA,GAAA,EAAA,CAAA;aAA9B,IAA8B,EAAA,GAAA,CAAA,EAA9B,EAA8B,GAAA,SAAA,CAAA,MAAA,EAA9B,EAA8B,EAAA,EAAA;YAA9B,EAA8B,CAAA,EAAA,CAAA,GAAA,SAAA,CAAA,EAAA,CAAA,CAAA;;QAAK,OAAA,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;AAA/B,KAA+B,CAAC;AAC/E;;ACAgB,SAAA,QAAQ,CAAU,CAAuD,EAAE,IAAQ,EAAA;IAC/F,IAAI,QAAQ,GAAG,IAAI,CAAC;IACpB,OAAO,SAAS,OAAO,CAAC,QAAQ,EAAA;AAC5B,QAAA,IAAM,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAChD,QAAQ,GAAG,QAAQ,CAAC;AACpB,QAAA,OAAO,MAAM,CAAC;AAClB,KAAC,CAAC;AACN;;ACxBA;;AAEG;AACG,SAAU,SAAS,CAAI,CAAe,EAAA;AACxC,IAAA,OAAO,SAAS,CAAC,mBAAmB,CAAC,YAAM,EAAA,OAAA,CAAC,CAAC,QAAQ,EAAE,CAAZ,EAAY,CAAC,CAAC;AAC7D,CAAC;AAED;;AAEG;AACG,SAAU,IAAI,CAAI,CAAe,EAAA;AACnC,IAAA,OAAO,SAAS,CAAC,mBAAmB,CAAC,YAAM,EAAA,OAAA,CAAC,CAAC,GAAG,EAAE,CAAP,EAAO,CAAC,CAAC;AACxD,CAAC;AAED;;AAEG;AACG,SAAU,SAAS,CAAI,CAAe,EAAA;AACxC,IAAA,OAAO,SAAS,CAAC,mBAAmB,CAAC,YAAM,EAAA,OAAA,CAAC,CAAC,KAAK,CAAA,EAAA,CAAC,CAAC;AACxD;;ACAgB,SAAA,IAAI,CAAU,CAA+C,EAAE,IAAQ,EAAA;IACnF,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,OAAO,SAAS,OAAO,CAAC,KAAK,EAAA;AACzB,QAAA,OAAO,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAC1C,KAAC,CAAC;AACN;;ACnBM,SAAU,cAAc,CAAI,IAAkB,EAAA;AAChD,IAAA,OAAO,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC1C,CAAC;AAEK,SAAU,aAAa,CAAI,KAAe,EAAA;IAC5C,IAAI,KAAK,KAAK,UAAU,EAAE;QACtB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAC9C,KAAA;IACD,IAAI,KAAK,YAAY,YAAY,EAAE;AACvB,QAAA,IAAA,KAAK,GAAK,KAAK,CAAA,KAAV,CAAW;AACxB,QAAA,OAAO,EAAE,KAAK,EAAA,KAAA,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AACnD,KAAA;AACD,IAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5D,CAAC;AAEK,SAAU,eAAe,CAAI,KAAqB,EAAA;IACpD,IAAI,KAAK,CAAC,OAAO,EAAE;AACf,QAAA,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACxC,KAAA;IACD,IAAI,KAAK,CAAC,QAAQ,EAAE;QAChB,OAAO,KAAK,CAAC,KAAK,CAAC;AACtB,KAAA;AACD,IAAA,OAAO,UAAU,CAAC;AACtB,CAAC;AAEK,SAAU,WAAW,CAAI,SAAuB,EAAA;AAClD,IAAA,OAAO,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;AAC7C,CAAC;AAEK,SAAU,aAAa,CAAI,SAAoC,EAAA;AACjE,IAAA,OAAO,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAC1C,CAAC;AAEe,SAAA,cAAc,CAAI,EAAoB,EAAE,KAAqB,EAAA;AACzE,IAAA,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE;QACjB,EAAE,CAAC,KAAK,EAAE,CAAC;AACd,KAAA;SAAM,IAAI,KAAK,CAAC,OAAO,EAAE;AACtB,QAAA,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC5B,KAAA;AAAM,SAAA;AACH,QAAA,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACvB,KAAA;AACL,CAAC;SAEe,SAAS,CAAI,IAAkB,EAAE,EAAoB,EAAE,IAA8C,EAAA;IACjH,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,UAAA,KAAK,EAAI,EAAA,OAAA,cAAc,CAAC,EAAE,EAAE,KAAK,CAAC,GAAA,EAAE,IAAI,CAAC,CAAC;AAC7E,CAAC;AAEe,SAAA,SAAS,CAAI,IAAkB,EAAE,EAAoB,EAAA;IACjE,cAAc,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7C;;ACtDA;;;;AAIG;AACI,IAAM,GAAG,GAAG,SAAS,CAAC,UAAA,CAAC,EAAA,EAAI,OAAA,CAAC,CAAC,CAAF,EAAE,EAAE;AAEtC;;;;AAIG;AACU,IAAA,EAAE,GAAG,SAAS,CAAC,UAAA,CAAC,EAAI,EAAA,OAAA,CAAC,CAAC,CAAC,CAAH,EAAG,EAAE;AAEtC;;;;AAIG;AACU,IAAA,YAAY,GAAG,SAAS,CAAC,UAAA,CAAC,EAAI,EAAA,OAAA,CAAC,IAAI,IAAI,CAAT,EAAS,EAAE;AAEtD,SAAS,SAAS,CAAC,OAA4B,EAAA;IAC3C,OAAO,YAAA;QAAI,IAAgC,IAAA,GAAA,EAAA,CAAA;aAAhC,IAAgC,EAAA,GAAA,CAAA,EAAhC,EAAgC,GAAA,SAAA,CAAA,MAAA,EAAhC,EAAgC,EAAA,EAAA;YAAhC,IAAgC,CAAA,EAAA,CAAA,GAAA,SAAA,CAAA,EAAA,CAAA,CAAA;;AAAK,QAAA,OAAA,MAAM,CAAC,YAAA;AACnD,YAAA,IAAI,KAAoB,CAAC;AACzB,YAAA,KAAkB,UAAI,EAAJ,MAAA,GAAA,IAAI,EAAJ,EAAI,GAAA,MAAA,CAAA,MAAA,EAAJ,IAAI,EAAE;AAAnB,gBAAA,IAAM,GAAG,GAAA,MAAA,CAAA,EAAA,CAAA,CAAA;AACV,gBAAA,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AACpB,gBAAA,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;oBAChB,MAAM;AACT,iBAAA;AACJ,aAAA;AACD,YAAA,OAAO,KAAM,CAAC;AAClB,SAAC,CAAC,CAAA;AAT8C,KAS9C,CAAC;AACP;;ACdM,SAAU,MAAM,CAAC,GAAQ,EAAA;AAC3B,IAAA,IAAI,WAAW,CAAC,GAAG,CAAC,EAAE;AAClB,QAAA,OAAO,GAAG,CAAC;AACd,KAAA;AACD,IAAA,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE;AAClD,QAAA,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;AACjF,KAAA;AACD,IAAA,OAAO,MAAM,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,UAAU,CAAC,GAAQ,EAAA;AACxB,IAAA,IAAI,WAAW,CAAC,GAAG,CAAC,EAAE;AAClB,QAAA,OAAO,GAAG,CAAC,GAAG,EAAE,CAAC;AACpB,KAAA;AACD,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;AACpB,QAAA,OAAO,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAC9B,KAAA;AACD,IAAA,IAAI,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE;QAC1B,IAAM,MAAM,GAAG,EAAE,CAAC;AAClB,QAAA,KAAkB,IAAgB,EAAA,GAAA,CAAA,EAAhB,EAAA,GAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAhB,EAAgB,GAAA,EAAA,CAAA,MAAA,EAAhB,IAAgB,EAAE;AAA/B,YAAA,IAAM,GAAG,GAAA,EAAA,CAAA,EAAA,CAAA,CAAA;YACV,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AACtC,SAAA;AACD,QAAA,OAAO,MAAM,CAAC;AACjB,KAAA;AACD,IAAA,OAAO,GAAG,CAAC;AACf;;AC3CA;;;;;;;;;;;;;;AAcG;AACG,SAAU,QAAQ,CAAC,KAA2B,EAAA;IAAE,IAAc,IAAA,GAAA,EAAA,CAAA;SAAd,IAAc,EAAA,GAAA,CAAA,EAAd,EAAc,GAAA,SAAA,CAAA,MAAA,EAAd,EAAc,EAAA,EAAA;QAAd,IAAc,CAAA,EAAA,GAAA,CAAA,CAAA,GAAA,SAAA,CAAA,EAAA,CAAA,CAAA;;AAChE,IAAA,OAAO,MAAM,CAAC,YAAA;QACV,IAAI,CAAC,GAAG,EAAE,CAAC;AACX,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACnC,YAAA,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;AACd,YAAA,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE;gBACjB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACxB,aAAA;AACJ,SAAA;AACD,QAAA,OAAO,CAAC,CAAC;AACb,KAAC,CAAC,CAAC;AACP;;;;"}

package/sherlock-utils.esm.min.js

@@ -1,2 +1,2 @@
-import{isDerivable as r,lens as n,_internal as t,isSettableDerivable as u,atom as e,PullDataSource as i,ErrorWrapper as o,unresolved as f,derive as c,unwrap as a,utils as v}from"@politie/sherlock";import{__extends as s}from"tslib";function l(){return new Map}function h(i){var o=(i.mapFactory||l)(),f=i.delayedEviction,c=i.derivableFactory,a={get:function(r){var i=o.get(r);if(i)return i.getState();var a=t.independentTracking((function(){return c(r)})),v=u(a)?n({get:function(){return a.get()},set:function(r){return a.set(r)}},e(0)):e(0).derive((function(){return a.get()}));f&&v.autoCache();var s=v.getState();return v.connected&&(v.__cachedProxy=this,o.set(r,v),v.connected$.react((function(){return o.delete(r)}),{skipFirst:!0,once:!0})),s},set:function(r,n){var e=o.get(n)||c(n);if(!u(e))throw t.augmentStack(Error("Cached derivable is not settable"),e);e.set(r)}};return function(t){if(!r(t)){var u=o.get(t);if(u)return u.__cachedProxy}return n(a,t)}}var d=function(r){function n(n){var t=r.call(this)||this;return t.fn=n,t}return s(n,r),n.prototype.calculateCurrentValue=function(){return this.fn()},n.prototype.changed=function(){r.prototype.checkForChanges.call(this)},n}(i);function p(r){var n=e.unresolved();return r.then((function(r){return n.setFinal(r)}),(function(r){return n.setFinal(new o(r))})),n}function b(r){return function(){for(var n=[],u=0;u<arguments.length;u++)n[u]=arguments[u];return new t.Derivation(r,n)}}function w(r,n){var t=n;return function(n){var u=r.call(this,n,t);return t=n,u}}function m(r){return t.independentTracking((function(){return r.getState()}))}function y(r){return t.independentTracking((function(){return r.get()}))}function k(r){return t.independentTracking((function(){return r.value}))}function A(r,n){var t=n;return function(n){return t=r.call(this,t,n)}}function g(r){return j(r.getState())}function j(r){return r===f?{errored:!1,resolved:!1}:r instanceof o?{error:r.error,errored:!0,resolved:!0}:{value:r,errored:!1,resolved:!0}}function E(r){return r.errored?new o(r.error):r.resolved?r.value:f}function O(r){return r.mapState(j)}function x(r){return r.map(E)}function C(r,n){n.resolved?n.errored?r.setError(n.error):r.set(n.value):r.unset()}function D(r,n,t){return O(r).react((function(r){return C(n,r)}),t)}function F(r,n){C(n,g(r))}var M=B((function(r){return!r})),q=B((function(r){return!!r})),z=B((function(r){return null!=r}));function B(r){return function(){for(var n=[],t=0;t<arguments.length;t++)n[t]=arguments[t];return c((function(){for(var t,u=0,e=n;u<e.length;u++){var i=e[u];if(t=a(i),r(t))break}return t}))}}function G(n){if(r(n))return n;if(!Array.isArray(n)&&!v.isPlainObject(n))throw Error('"struct" only accepts Derivables, plain Objects and Arrays');return c(H,n)}function H(n){if(r(n))return n.get();if(Array.isArray(n))return n.map(H);if(v.isPlainObject(n)){for(var t={},u=0,e=Object.keys(n);u<e.length;u++){var i=e[u];t[i]=H(n[i])}return t}return n}function I(r){for(var n=[],t=1;t<arguments.length;t++)n[t-1]=arguments[t];return c((function(){for(var t="",u=0;u<r.length;u++)t+=r[u],u<n.length&&(t+=a(n[u]));return t}))}export{d as FunctionDataSource,M as and,F as copyState,x as dematerialize,h as derivableCache,z as firstNotNull,p as fromPromise,E as fromStateObject,g as getStateObject,b as lift,O as materialize,q as or,w as pairwise,y as peek,m as peekState,k as peekValue,A as scan,C as setStateObject,G as struct,D as syncState,I as template,j as toStateObject};
+import{isDerivable as r,lens as n,_internal as t,isSettableDerivable as u,atom as e,PullDataSource as i,ErrorWrapper as o,unresolved as f,derive as c,unwrap as a,utils as v}from"@politie/sherlock";import{__extends as s}from"tslib";function l(){return new Map}var h="__cachedProxy";function d(i){var o=(i.mapFactory||l)(),f=i.delayedEviction,c=i.derivableFactory,a={get:function(r){var i=o.get(r);if(i)return i.getState();var a=t.independentTracking((function(){return c(r)})),v=u(a)?n({get:function(){return a.get()},set:function(r){return a.set(r)}},e(0)):e(0).derive((function(){return a.get()}));f&&v.autoCache();var s=v.getState();return v.connected&&(v[h]=this,o.set(r,v),v.connected$.react((function(){return o.delete(r)}),{skipFirst:!0,once:!0})),s},set:function(r,n){var e=o.get(n)||c(n);if(!u(e))throw t.augmentStack(Error("Cached derivable is not settable"),e);e.set(r)}};return function(t){if(!r(t)){var u=o.get(t);if(u)return u[h]}return n(a,t)}}var p=function(r){function n(n){var t=r.call(this)||this;return t.fn=n,t}return s(n,r),n.prototype.calculateCurrentValue=function(){return this.fn()},n.prototype.changed=function(){r.prototype.checkForChanges.call(this)},n}(i);function b(r){var n=e.unresolved();return r.then((function(r){return n.setFinal(r)}),(function(r){return n.setFinal(new o(r))})),n}function w(r){return function(){for(var n=[],u=0;u<arguments.length;u++)n[u]=arguments[u];return new t.Derivation(r,n)}}function y(r,n){var t=n;return function(n){var u=r.call(this,n,t);return t=n,u}}function m(r){return t.independentTracking((function(){return r.getState()}))}function k(r){return t.independentTracking((function(){return r.get()}))}function A(r){return t.independentTracking((function(){return r.value}))}function g(r,n){var t=n;return function(n){return t=r.call(this,t,n)}}function j(r){return x(r.getState())}function x(r){return r===f?{errored:!1,resolved:!1}:r instanceof o?{error:r.error,errored:!0,resolved:!0}:{value:r,errored:!1,resolved:!0}}function E(r){return r.errored?new o(r.error):r.resolved?r.value:f}function O(r){return r.mapState(x)}function _(r){return r.map(E)}function C(r,n){n.resolved?n.errored?r.setError(n.error):r.set(n.value):r.unset()}function D(r,n,t){return O(r).react((function(r){return C(n,r)}),t)}function F(r,n){C(n,j(r))}var M=z((function(r){return!r})),P=z((function(r){return!!r})),q=z((function(r){return null!=r}));function z(r){return function(){for(var n=[],t=0;t<arguments.length;t++)n[t]=arguments[t];return c((function(){for(var t,u=0,e=n;u<e.length;u++){var i=e[u];if(t=a(i),r(t))break}return t}))}}function B(n){if(r(n))return n;if(!Array.isArray(n)&&!v.isPlainObject(n))throw Error('"struct" only accepts Derivables, plain Objects and Arrays');return c(G,n)}function G(n){if(r(n))return n.get();if(Array.isArray(n))return n.map(G);if(v.isPlainObject(n)){for(var t={},u=0,e=Object.keys(n);u<e.length;u++){var i=e[u];t[i]=G(n[i])}return t}return n}function H(r){for(var n=[],t=1;t<arguments.length;t++)n[t-1]=arguments[t];return c((function(){for(var t="",u=0;u<r.length;u++)t+=r[u],u<n.length&&(t+=a(n[u]));return t}))}export{p as FunctionDataSource,M as and,F as copyState,_ as dematerialize,d as derivableCache,q as firstNotNull,b as fromPromise,E as fromStateObject,j as getStateObject,w as lift,O as materialize,P as or,y as pairwise,k as peek,m as peekState,A as peekValue,g as scan,C as setStateObject,B as struct,D as syncState,H as template,x as toStateObject};
 //# sourceMappingURL=sherlock-utils.esm.min.js.map

package/sherlock-utils.esm.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-utils.esm.min.js","names":["defaultMapFactory","Map","derivableCache","opts","cache","mapFactory","delayedEviction","derivableFactory","descriptor","get","key","cachedDerivable","getState","newDerivable","_internal","independentTracking","derivable","isSettableDerivable","lens","set","v","atom","derive","autoCache","state","connected","this","connected$","react","delete","skipFirst","once","newValue","augmentStack","Error","isDerivable","cacheItem","FunctionDataSource","fn","_this","_super","call","__extends","prototype","calculateCurrentValue","changed","checkForChanges","PullDataSource","fromPromise","prom","atom$","unresolved","then","setFinal","e","ErrorWrapper","lift","f","ps","_i","arguments","length","Derivation","pairwise","init","oldValue","result","peekState","d","peek","peekValue","value","scan","seed","acc","getStateObject","from","toStateObject","errored","resolved","error","fromStateObject","materialize","mapState","dematerialize","map","setStateObject","to","setError","unset","syncState","copyState","and","andOrImpl","or","firstNotNull","breakOn","args","args_1","arg","unwrap","struct","obj","Array","isArray","utils","isPlainObject","deepUnwrap","_a","Object","keys","template","parts","s","i"],"sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"mappings":"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"}
+{"version":3,"file":"sherlock-utils.esm.min.js","names":["defaultMapFactory","Map","CACHED_PROXY","derivableCache","opts","cache","mapFactory","delayedEviction","derivableFactory","descriptor","get","key","cachedDerivable","getState","newDerivable","_internal","independentTracking","derivable","isSettableDerivable","lens","set","v","atom","derive","autoCache","state","connected","this","connected$","react","delete","skipFirst","once","newValue","augmentStack","Error","isDerivable","cacheItem","FunctionDataSource","_super","fn","_this","call","__extends","prototype","calculateCurrentValue","changed","checkForChanges","PullDataSource","fromPromise","prom","atom$","unresolved","then","setFinal","e","ErrorWrapper","lift","f","ps","_i","arguments","length","Derivation","pairwise","init","oldValue","result","peekState","d","peek","peekValue","value","scan","seed","acc","getStateObject","from","toStateObject","errored","resolved","error","fromStateObject","materialize","mapState","dematerialize","map","setStateObject","to","setError","unset","syncState","copyState","and","andOrImpl","or","firstNotNull","breakOn","args","args_1","arg","unwrap","struct","obj","Array","isArray","utils","isPlainObject","deepUnwrap","_a","Object","keys","template","parts","s","i"],"sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"mappings":"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","ignoreList":[]}

package/sherlock-utils.umd.js

@@ -55,37 +55,42 @@
         };
     }
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-
-    var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol */
+
+    var extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+      return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+      if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+      extendStatics(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     }
 
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
     /**
      * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this
      * datasource.

package/sherlock-utils.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-utils.umd.js","sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../node_modules/tslib/tslib.es6.js","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"names":["_internal","isSettableDerivable","lens","atom","isDerivable","PullDataSource","ErrorWrapper","unresolved","derive","unwrap","utils"],"mappings":"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"}
+{"version":3,"file":"sherlock-utils.umd.js","sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../node_modules/tslib/tslib.es6.mjs","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n  return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose;\n    if (async) {\n        if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n        dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n        if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n        dispose = value[Symbol.dispose];\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  function next() {\n    while (env.stack.length) {\n      var rec = env.stack.pop();\n      try {\n        var result = rec.dispose && rec.dispose.call(rec.value);\n        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n      }\n      catch (e) {\n          fail(e);\n      }\n    }\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n};\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"names":["_internal","isSettableDerivable","lens","atom","isDerivable","PullDataSource","ErrorWrapper","unresolved","derive","unwrap","utils"],"mappings":"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"}

package/sherlock-utils.umd.min.js

@@ -1,17 +1,2 @@
-!function(n,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@politie/sherlock")):"function"==typeof define&&define.amd?define(["exports","@politie/sherlock"],r):r((n="undefined"!=typeof globalThis?globalThis:n||self).SherlockUtils={},n.Sherlock)}(this,(function(n,r){"use strict";function t(){return new Map}
-/*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-var e=function(n,r){return e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,r){n.__proto__=r}||function(n,r){for(var t in r)Object.prototype.hasOwnProperty.call(r,t)&&(n[t]=r[t])},e(n,r)},u=function(n){function r(r){var t=n.call(this)||this;return t.fn=r,t}return function(n,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+r+" is not a constructor or null");function t(){this.constructor=n}e(n,r),n.prototype=null===r?Object.create(r):(t.prototype=r.prototype,new t)}(r,n),r.prototype.calculateCurrentValue=function(){return this.fn()},r.prototype.changed=function(){n.prototype.checkForChanges.call(this)},r}(r.PullDataSource);function o(n){return i(n.getState())}function i(n){return n===r.unresolved?{errored:!1,resolved:!1}:n instanceof r.ErrorWrapper?{error:n.error,errored:!0,resolved:!0}:{value:n,errored:!1,resolved:!0}}function f(n){return n.errored?new r.ErrorWrapper(n.error):n.resolved?n.value:r.unresolved}function c(n){return n.mapState(i)}function a(n,r){r.resolved?r.errored?n.setError(r.error):n.set(r.value):n.unset()}var s=d((function(n){return!n})),l=d((function(n){return!!n})),v=d((function(n){return null!=n}));function d(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return r.derive((function(){for(var e,u=0,o=t;u<o.length;u++){var i=o[u];if(e=r.unwrap(i),n(e))break}return e}))}}function h(n){if(r.isDerivable(n))return n.get();if(Array.isArray(n))return n.map(h);if(r.utils.isPlainObject(n)){for(var t={},e=0,u=Object.keys(n);e<u.length;e++){var o=u[e];t[o]=h(n[o])}return t}return n}n.FunctionDataSource=u,n.and=s,n.copyState=function(n,r){a(r,o(n))},n.dematerialize=function(n){return n.map(f)},n.derivableCache=function(n){var e=(n.mapFactory||t)(),u=n.delayedEviction,o=n.derivableFactory,i={get:function(n){var t=e.get(n);if(t)return t.getState();var i=r._internal.independentTracking((function(){return o(n)})),f=r.isSettableDerivable(i)?r.lens({get:function(){return i.get()},set:function(n){return i.set(n)}},r.atom(0)):r.atom(0).derive((function(){return i.get()}));u&&f.autoCache();var c=f.getState();return f.connected&&(f.__cachedProxy=this,e.set(n,f),f.connected$.react((function(){return e.delete(n)}),{skipFirst:!0,once:!0})),c},set:function(n,t){var u=e.get(t)||o(t);if(!r.isSettableDerivable(u))throw r._internal.augmentStack(Error("Cached derivable is not settable"),u);u.set(n)}};return function(n){if(!r.isDerivable(n)){var t=e.get(n);if(t)return t.__cachedProxy}return r.lens(i,n)}},n.firstNotNull=v,n.fromPromise=function(n){var t=r.atom.unresolved();return n.then((function(n){return t.setFinal(n)}),(function(n){return t.setFinal(new r.ErrorWrapper(n))})),t},n.fromStateObject=f,n.getStateObject=o,n.lift=function(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return new r._internal.Derivation(n,t)}},n.materialize=c,n.or=l,n.pairwise=function(n,r){var t=r;return function(r){var e=n.call(this,r,t);return t=r,e}},n.peek=function(n){return r._internal.independentTracking((function(){return n.get()}))},n.peekState=function(n){return r._internal.independentTracking((function(){return n.getState()}))},n.peekValue=function(n){return r._internal.independentTracking((function(){return n.value}))},n.scan=function(n,r){var t=r;return function(r){return t=n.call(this,t,r)}},n.setStateObject=a,n.struct=function(n){if(r.isDerivable(n))return n;if(!Array.isArray(n)&&!r.utils.isPlainObject(n))throw Error('"struct" only accepts Derivables, plain Objects and Arrays');return r.derive(h,n)},n.syncState=function(n,r,t){return c(n).react((function(n){return a(r,n)}),t)},n.template=function(n){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return r.derive((function(){for(var e="",u=0;u<n.length;u++)e+=n[u],u<t.length&&(e+=r.unwrap(t[u]));return e}))},n.toStateObject=i,Object.defineProperty(n,"__esModule",{value:!0})}));
+!function(n,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@politie/sherlock")):"function"==typeof define&&define.amd?define(["exports","@politie/sherlock"],r):r((n="undefined"!=typeof globalThis?globalThis:n||self).SherlockUtils={},n.Sherlock)}(this,(function(n,r){"use strict";function t(){return new Map}var e="__cachedProxy",u=function(n,r){return u=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,r){n.__proto__=r}||function(n,r){for(var t in r)Object.prototype.hasOwnProperty.call(r,t)&&(n[t]=r[t])},u(n,r)};"function"==typeof SuppressedError&&SuppressedError;var o=function(n){function r(r){var t=n.call(this)||this;return t.fn=r,t}return function(n,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+r+" is not a constructor or null");function t(){this.constructor=n}u(n,r),n.prototype=null===r?Object.create(r):(t.prototype=r.prototype,new t)}(r,n),r.prototype.calculateCurrentValue=function(){return this.fn()},r.prototype.changed=function(){n.prototype.checkForChanges.call(this)},r}(r.PullDataSource);function i(n){return f(n.getState())}function f(n){return n===r.unresolved?{errored:!1,resolved:!1}:n instanceof r.ErrorWrapper?{error:n.error,errored:!0,resolved:!0}:{value:n,errored:!1,resolved:!0}}function c(n){return n.errored?new r.ErrorWrapper(n.error):n.resolved?n.value:r.unresolved}function a(n){return n.mapState(f)}function s(n,r){r.resolved?r.errored?n.setError(r.error):n.set(r.value):n.unset()}var l=p((function(n){return!n})),v=p((function(n){return!!n})),d=p((function(n){return null!=n}));function p(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return r.derive((function(){for(var e,u=0,o=t;u<o.length;u++){var i=o[u];if(e=r.unwrap(i),n(e))break}return e}))}}function h(n){if(r.isDerivable(n))return n.get();if(Array.isArray(n))return n.map(h);if(r.utils.isPlainObject(n)){for(var t={},e=0,u=Object.keys(n);e<u.length;e++){var o=u[e];t[o]=h(n[o])}return t}return n}n.FunctionDataSource=o,n.and=l,n.copyState=function(n,r){s(r,i(n))},n.dematerialize=function(n){return n.map(c)},n.derivableCache=function(n){var u=(n.mapFactory||t)(),o=n.delayedEviction,i=n.derivableFactory,f={get:function(n){var t=u.get(n);if(t)return t.getState();var f=r._internal.independentTracking((function(){return i(n)})),c=r.isSettableDerivable(f)?r.lens({get:function(){return f.get()},set:function(n){return f.set(n)}},r.atom(0)):r.atom(0).derive((function(){return f.get()}));o&&c.autoCache();var a=c.getState();return c.connected&&(c[e]=this,u.set(n,c),c.connected$.react((function(){return u.delete(n)}),{skipFirst:!0,once:!0})),a},set:function(n,t){var e=u.get(t)||i(t);if(!r.isSettableDerivable(e))throw r._internal.augmentStack(Error("Cached derivable is not settable"),e);e.set(n)}};return function(n){if(!r.isDerivable(n)){var t=u.get(n);if(t)return t[e]}return r.lens(f,n)}},n.firstNotNull=d,n.fromPromise=function(n){var t=r.atom.unresolved();return n.then((function(n){return t.setFinal(n)}),(function(n){return t.setFinal(new r.ErrorWrapper(n))})),t},n.fromStateObject=c,n.getStateObject=i,n.lift=function(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return new r._internal.Derivation(n,t)}},n.materialize=a,n.or=v,n.pairwise=function(n,r){var t=r;return function(r){var e=n.call(this,r,t);return t=r,e}},n.peek=function(n){return r._internal.independentTracking((function(){return n.get()}))},n.peekState=function(n){return r._internal.independentTracking((function(){return n.getState()}))},n.peekValue=function(n){return r._internal.independentTracking((function(){return n.value}))},n.scan=function(n,r){var t=r;return function(r){return t=n.call(this,t,r)}},n.setStateObject=s,n.struct=function(n){if(r.isDerivable(n))return n;if(!Array.isArray(n)&&!r.utils.isPlainObject(n))throw Error('"struct" only accepts Derivables, plain Objects and Arrays');return r.derive(h,n)},n.syncState=function(n,r,t){return a(n).react((function(n){return s(r,n)}),t)},n.template=function(n){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return r.derive((function(){for(var e="",u=0;u<n.length;u++)e+=n[u],u<t.length&&(e+=r.unwrap(t[u]));return e}))},n.toStateObject=f,Object.defineProperty(n,"__esModule",{value:!0})}));
 //# sourceMappingURL=sherlock-utils.umd.min.js.map

package/sherlock-utils.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-utils.umd.min.js","names":["defaultMapFactory","Map","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","FunctionDataSource","fn","_this","_super","this","TypeError","__","constructor","create","__extends","calculateCurrentValue","changed","checkForChanges","PullDataSource","getStateObject","from","toStateObject","getState","state","unresolved","errored","resolved","ErrorWrapper","error","value","fromStateObject","materialize","derivable","mapState","setStateObject","to","setError","set","unset","and","andOrImpl","v","or","firstNotNull","breakOn","args","_i","arguments","length","derive","args_1","arg","unwrap","deepUnwrap","obj","isDerivable","get","isArray","map","utils","isPlainObject","result","_a","keys","key","opts","cache","mapFactory","delayedEviction","derivableFactory","descriptor","cachedDerivable","newDerivable","_internal","independentTracking","isSettableDerivable","lens","atom","autoCache","connected","connected$","react","delete","skipFirst","once","newValue","augmentStack","Error","cacheItem","prom","atom$","then","setFinal","e","f","ps","Derivation","init","oldValue","seed","acc","parts","s","i"],"sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../node_modules/tslib/tslib.es6.js","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"mappings":"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"}
+{"version":3,"file":"sherlock-utils.umd.min.js","names":["defaultMapFactory","Map","CACHED_PROXY","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","SuppressedError","FunctionDataSource","_super","fn","_this","this","TypeError","__","constructor","create","__extends","calculateCurrentValue","changed","checkForChanges","PullDataSource","getStateObject","from","toStateObject","getState","state","unresolved","errored","resolved","ErrorWrapper","error","value","fromStateObject","materialize","derivable","mapState","setStateObject","to","setError","set","unset","and","andOrImpl","v","or","firstNotNull","breakOn","args","_i","arguments","length","derive","args_1","arg","unwrap","deepUnwrap","obj","isDerivable","get","isArray","map","utils","isPlainObject","result","_a","keys","key","opts","cache","mapFactory","delayedEviction","derivableFactory","descriptor","cachedDerivable","newDerivable","_internal","independentTracking","isSettableDerivable","lens","atom","autoCache","connected","connected$","react","delete","skipFirst","once","newValue","augmentStack","Error","cacheItem","prom","atom$","then","setFinal","e","f","ps","Derivation","init","oldValue","seed","acc","parts","s","i"],"sources":["../../extensions/sherlock-utils/src/derivable-cache.ts","../../node_modules/tslib/tslib.es6.mjs","../../extensions/sherlock-utils/src/function-data-source.ts","../../extensions/sherlock-utils/src/state.ts","../../extensions/sherlock-utils/src/static-boolean-funcs.ts","../../extensions/sherlock-utils/src/struct.ts","../../extensions/sherlock-utils/src/from-promise.ts","../../extensions/sherlock-utils/src/lift.ts","../../extensions/sherlock-utils/src/pairwise.ts","../../extensions/sherlock-utils/src/peek.ts","../../extensions/sherlock-utils/src/scan.ts","../../extensions/sherlock-utils/src/template.ts"],"sourcesContent":["import { _internal, atom, Derivable, isDerivable, isSettableDerivable, lens, LensDescriptor, SettableDerivable, Unwrappable } from '@politie/sherlock';\n\nexport interface MapImplementation<K, V> {\n    set(key: K, value: V): void;\n    delete(key: K): void;\n    get(key: K): V | undefined;\n}\n\nexport interface DerivableCacheOptions<K, V> {\n    derivableFactory(key: K): Derivable<V>;\n    mapFactory?(): MapImplementation<K, Derivable<V>>;\n    delayedEviction?: boolean;\n}\n\nexport type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;\n\nfunction defaultMapFactory<K, V>(): MapImplementation<K, V> { return new Map; }\n\nconst CACHED_PROXY = '__cachedProxy';\n\nexport function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V> {\n    const cache = (opts.mapFactory || defaultMapFactory)();\n\n    const { delayedEviction, derivableFactory } = opts;\n    const descriptor: LensDescriptor<V, K> = {\n        get(key) {\n            const cachedDerivable = cache.get(key);\n            // If the cache has a hit for the current key, we know it is already connected (through another proxy).\n            if (cachedDerivable) {\n                return cachedDerivable.getState();\n            }\n\n            // A cache miss means no other proxy is currently connected.\n            const newDerivable = _internal.independentTracking(() => derivableFactory(key));\n            // We don't want final-value-optimalization, because that defeats the purpose of the cache. A final value\n            // is not registered as an observed value, which means we cannot track the usage of our newly created derivable.\n            // Therefore introduce a non-final atom (`atom(0)`) in the derivation:\n            const derivable = isSettableDerivable(newDerivable)\n                ? lens({ get: () => newDerivable.get(), set: v => newDerivable.set(v) }, atom(0))\n                : atom(0).derive(() => newDerivable.get());\n\n            if (delayedEviction) {\n                derivable.autoCache();\n            }\n\n            // Get the state of our derivable early so it connects when needed.\n            const state = derivable.getState();\n            if (derivable.connected) {\n                derivable[CACHED_PROXY] = this;\n                cache.set(key, derivable);\n                derivable.connected$.react(() => cache.delete(key), { skipFirst: true, once: true });\n            }\n            return state;\n        },\n        set(newValue, key) {\n            const derivable = cache.get(key) || derivableFactory(key);\n            if (!isSettableDerivable(derivable)) {\n                throw _internal.augmentStack(new Error('Cached derivable is not settable'), derivable);\n            }\n            derivable.set(newValue);\n        },\n    };\n\n    return key => {\n        if (!isDerivable(key)) {\n            const cacheItem = cache.get(key);\n            if (cacheItem) {\n                return cacheItem[CACHED_PROXY];\n            }\n        }\n\n        return lens(descriptor, key);\n    };\n}\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n  return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose;\n    if (async) {\n        if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n        dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n        if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n        dispose = value[Symbol.dispose];\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  function next() {\n    while (env.stack.length) {\n      var rec = env.stack.pop();\n      try {\n        var result = rec.dispose && rec.dispose.call(rec.value);\n        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n      }\n      catch (e) {\n          fail(e);\n      }\n    }\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n};\n","import { PullDataSource } from '@politie/sherlock';\n\n/**\n * Lazy PullDataSource that is based on a plain javascript function that has to supply the value when someone subscribes to this\n * datasource.\n */\nexport class FunctionDataSource<T> extends PullDataSource<T> {\n    /* istanbul ignore next: transpiled code for constructor cannot be fully covered */\n    /* More info: https://github.com/Microsoft/TypeScript/issues/13029 */\n    constructor(private readonly fn: () => T) {\n        super();\n    }\n\n    /**\n     * Required function that calculates the current value for this datasource. Will be called once everytime\n     * `get()` is called when not connected. When connected, it will be called once and then only whenever `checkForChanges()`\n     * was called.\n     */\n    calculateCurrentValue() {\n        return this.fn();\n    }\n\n    /**\n     * Update the currently cached value of this datasource (only when connected) and notify observers when neccessary.\n     */\n    changed() {\n        super.checkForChanges();\n    }\n}\n","import { Derivable, DerivableAtom, ErrorWrapper, ReactorOptions, State, unresolved } from '@politie/sherlock';\n\nexport type StateObject<V> =\n    { value: V, errored: false, resolved: true } |\n    { error: any, errored: true, resolved: true } |\n    { errored: false, resolved: false };\n\nexport function getStateObject<V>(from: Derivable<V>): StateObject<V> {\n    return toStateObject(from.getState());\n}\n\nexport function toStateObject<V>(state: State<V>): StateObject<V> {\n    if (state === unresolved) {\n        return { errored: false, resolved: false };\n    }\n    if (state instanceof ErrorWrapper) {\n        const { error } = state;\n        return { error, errored: true, resolved: true };\n    }\n    return { value: state, errored: false, resolved: true };\n}\n\nexport function fromStateObject<V>(state: StateObject<V>): State<V> {\n    if (state.errored) {\n        return new ErrorWrapper(state.error);\n    }\n    if (state.resolved) {\n        return state.value;\n    }\n    return unresolved;\n}\n\nexport function materialize<V>(derivable: Derivable<V>): Derivable<StateObject<V>> {\n    return derivable.mapState(toStateObject);\n}\n\nexport function dematerialize<V>(derivable: Derivable<StateObject<V>>): Derivable<V> {\n    return derivable.map(fromStateObject);\n}\n\nexport function setStateObject<V>(to: DerivableAtom<V>, state: StateObject<V>) {\n    if (!state.resolved) {\n        to.unset();\n    } else if (state.errored) {\n        to.setError(state.error);\n    } else {\n        to.set(state.value);\n    }\n}\n\nexport function syncState<V>(from: Derivable<V>, to: DerivableAtom<V>, opts?: Partial<ReactorOptions<StateObject<V>>>) {\n    return materialize(from).react(state => setStateObject(to, state), opts);\n}\n\nexport function copyState<V>(from: Derivable<V>, to: DerivableAtom<V>) {\n    setStateObject(to, getStateObject(from));\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * Performs JavaScript `&&` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const and = andOrImpl(v => !v);\n\n/**\n * Performs JavaScript `||` operation on the provided arguments after unwrapping.\n *\n * @method\n */\nexport const or = andOrImpl(v => !!v);\n\n/**\n * Returns the first operand that is not `null` or `undefined` after unwrapping.\n *\n * @method\n */\nexport const firstNotNull = andOrImpl(v => v != null);\n\nfunction andOrImpl(breakOn: (v: any) => boolean) {\n    return <V>(...args: Array<Derivable<V> | V>) => derive(() => {\n        let value: V | undefined;\n        for (const arg of args) {\n            value = unwrap(arg);\n            if (breakOn(value)) {\n                break;\n            }\n        }\n        return value!;\n    });\n}\n","import { Derivable, derive, isDerivable, utils } from '@politie/sherlock';\n\n/**\n * Converts a map or array of Derivables or any nested structure containing maps, arrays and Derivables into a single\n * Derivable with all nested Derivables unwrapped into it.\n *\n *     const obj = { key1: atom(123), key2: atom(456) };\n *     const obj$ = struct<typeof obj, number>(obj);\n *     expect(obj$.get()).to.deep.equal({ key1: 123, key2: 456 });\n *\n * It only touches Arrays, plain Objects and Derivables, the rest is simply returned inside the Derivable as-is.\n *\n * @param obj the object to deepunwrap into a derivable\n */\nexport function struct<V>(obj: Derivable<V>): Derivable<V>;\nexport function struct<I extends Record<string, Derivable<V>>, V>(obj: I): Derivable<{ [P in keyof I]: V }>;\nexport function struct<I extends Array<Derivable<V>>, V>(obj: I): Derivable<V[]>;\nexport function struct<I extends any[]>(obj: I): Derivable<any[]>;\nexport function struct<I extends object | any[]>(obj: I): Derivable<{ [P in keyof I]: any }>;\n\nexport function struct(obj: any) {\n    if (isDerivable(obj)) {\n        return obj;\n    }\n    if (!Array.isArray(obj) && !utils.isPlainObject(obj)) {\n        throw new Error('\"struct\" only accepts Derivables, plain Objects and Arrays');\n    }\n    return derive(deepUnwrap, obj);\n}\n\nfunction deepUnwrap(obj: any): any {\n    if (isDerivable(obj)) {\n        return obj.get();\n    }\n    if (Array.isArray(obj)) {\n        return obj.map(deepUnwrap);\n    }\n    if (utils.isPlainObject(obj)) {\n        const result = {};\n        for (const key of Object.keys(obj)) {\n            result[key] = deepUnwrap(obj[key]);\n        }\n        return result;\n    }\n    return obj;\n}\n","import { atom, Derivable, ErrorWrapper } from '@politie/sherlock';\n\nexport function fromPromise<V>(prom: Promise<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n    prom.then(v => atom$.setFinal(v), e => atom$.setFinal(new ErrorWrapper(e)));\n    return atom$;\n}\n","import { _internal, Derivable } from '@politie/sherlock';\n\n/**\n * Lifts the function f into a function over Derivables returning a Derivable, for example:\n *\n *     const minLength = lift((s: string) => s.length > 3);\n *     const s$ = atom('abcd');\n *     const hasMinLength$ = minLength(s$);\n *     console.log(hasMinLength$.get()) // true\n *\n * @param f the function to lift into a function over Derivables\n */\nexport function lift<R>(f: () => R): () => Derivable<R>;\nexport function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;\nexport function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;\nexport function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;\n\nexport function lift<P, R>(f: (...ps: P[]) => R): (...ps: Array<P | Derivable<P>>) => Derivable<R> {\n    return (...ps: Array<P | Derivable<P>>) => new _internal.Derivation(f, ps);\n}\n\nexport type MD<P> = P | Derivable<P>;\n","/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue?: V) => R): (value: V) => R;\n\n/**\n * Calls the provided dyadic function with respectively the current and previous value that was received by the returned monadic function.\n * In other words, when you wrap a function with wrapPreviousState you not only get the current value, but also the previous one (as a\n * second parameter).\n *\n * @param f the function to wrap\n * @param init the value to use the first time as second argument to `f`.\n */\nexport function pairwise<V, R>(f: (newValue: V, oldValue: V) => R, init: V): (value: V) => R;\n\nexport function pairwise<C, V, R>(f: (this: C, newValue: V, oldValue: V | undefined) => R, init?: V): (this: C, value: V) => R {\n    let oldValue = init;\n    return function wrapped(newValue) {\n        const result = f.call(this, newValue, oldValue);\n        oldValue = newValue;\n        return result;\n    };\n}\n","import { _internal, Derivable, State } from '@politie/sherlock';\n\n/**\n * Returns the current state of the provided Derivable without registering any dependencies while in a derivation. Comparable to #getState().\n */\nexport function peekState<T>(d: Derivable<T>): State<T> {\n    return _internal.independentTracking(() => d.getState());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #get().\n */\nexport function peek<T>(d: Derivable<T>): T {\n    return _internal.independentTracking(() => d.get());\n}\n\n/**\n * Returns the current value of the provided Derivable without registering any dependencies while in a derivation. Comparable to #value.\n */\nexport function peekValue<T>(d: Derivable<T>): T | undefined {\n    return _internal.independentTracking(() => d.value);\n}\n","/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n */\nexport function scan<V, R>(f: (acc: R | undefined, value: V) => R): (value: V) => R;\n\n/**\n * Converts an accumulator function into a monadic function. On each call to the returned monadic function, the accumulator function is\n * called with the value that was passed to the monadic function and the result of the last invocation of the accumulator function. It\n * works similar to {@link Array#reduce}, but returns each intermediate result. If the seed is specified, then that value will be used\n * as the initial value for the accumulator.\n *\n * @param f the function to wrap\n * @param seed the value to use the first time as second argument to `f`.\n */\nexport function scan<V, R>(f: (acc: R, value: V) => R, seed: R): (value: V) => R;\n\nexport function scan<C, V, R>(f: (this: C, acc: R | undefined, value: V) => R, seed?: R): (this: C, value: V) => R {\n    let acc = seed;\n    return function wrapped(value) {\n        return acc = f.call(this, acc, value);\n    };\n}\n","import { Derivable, derive, unwrap } from '@politie/sherlock';\n\n/**\n * A template literal tag to create a string derivation using a template literal.\n *\n * For example:\n *\n * ```\n * const name$ = atom('Pete');\n * const age$ = atom(24);\n * const nameAndAge$ = template`${name$} is ${age$} years old`;\n * nameAndAge$.get(); // -> Pete is 24 years old\n * ```\n *\n * @param parts the string parts\n * @param args the results of the expressions inside the template literal\n */\nexport function template(parts: TemplateStringsArray, ...args: any[]): Derivable<string> {\n    return derive(() => {\n        let s = '';\n        for (let i = 0; i < parts.length; i++) {\n            s += parts[i];\n            if (i < args.length) {\n                s += unwrap(args[i]);\n            }\n        }\n        return s;\n    });\n}\n"],"mappings":"mTAgBA,SAASA,IAAqD,OAAO,IAAIC,GAAI,CAE7E,IAAMC,EAAe,gBCFjBC,EAAgB,SAASC,EAAGC,GAI9B,OAHAF,EAAgBG,OAAOC,gBAClB,CAAEC,UAAW,cAAgBC,OAAS,SAAUL,EAAGC,GAAKD,EAAEI,UAAYH,CAAE,GACzE,SAAUD,EAAGC,GAAK,IAAK,IAAIK,KAAKL,EAAOC,OAAOK,UAAUC,eAAeC,KAAKR,EAAGK,KAAIN,EAAEM,GAAKL,EAAEK,GAAG,EAC5FP,EAAcC,EAAGC,EAC1B,EAsSkD,mBAApBS,iBAAiCA,gBCrT/D,IAAAC,EAAA,SAAAC,GAGI,SAAAD,EAA6BE,GAA7B,IAAAC,EACIF,EAAAH,KAAAM,OACHA,K,OAF4BD,EAAED,GAAFA,E,EAmBjC,ODLO,SAAmBb,EAAGC,GAC3B,GAAiB,mBAANA,GAA0B,OAANA,EAC3B,MAAM,IAAIe,UAAU,uBAAgCf,EAAK,iCAE7D,SAASgB,IAAOF,KAAKG,YAAclB,CAAE,CADrCD,EAAcC,EAAGC,GAEjBD,EAAEO,UAAkB,OAANN,EAAaC,OAAOiB,OAAOlB,IAAMgB,EAAGV,UAAYN,EAAEM,UAAW,IAAIU,EACjF,CCvB2CG,CAAiBT,EAAAC,GAYxDD,EAAAJ,UAAAc,sBAAA,WACI,OAAON,KAAKF,I,EAMhBF,EAAAJ,UAAAe,QAAA,WACIV,EAAML,UAAAgB,gBAAed,KAAAM,K,EAE5BJ,CAAD,CAtBA,CAA2Ca,kBCCrC,SAAUC,EAAkBC,GAC9B,OAAOC,EAAcD,EAAKE,WAC9B,CAEM,SAAUD,EAAiBE,GAC7B,OAAIA,IAAUC,aACH,CAAEC,SAAS,EAAOC,UAAU,GAEnCH,aAAiBI,eAEV,CAAEC,MADSL,EAAKK,MACPH,SAAS,EAAMC,UAAU,GAEtC,CAAEG,MAAON,EAAOE,SAAS,EAAOC,UAAU,EACrD,CAEM,SAAUI,EAAmBP,GAC/B,OAAIA,EAAME,QACC,IAAIE,eAAaJ,EAAMK,OAE9BL,EAAMG,SACCH,EAAMM,MAEVL,YACX,CAEM,SAAUO,EAAeC,GAC3B,OAAOA,EAAUC,SAASZ,EAC9B,CAMgB,SAAAa,EAAkBC,EAAsBZ,GAC/CA,EAAMG,SAEAH,EAAME,QACbU,EAAGC,SAASb,EAAMK,OAElBO,EAAGE,IAAId,EAAMM,OAJbM,EAAGG,OAMX,CCzCO,IAAMC,EAAMC,GAAU,SAAAC,GAAK,OAACA,CAAD,IAOrBC,EAAKF,GAAU,SAAAC,GAAK,QAAEA,CAAF,IAOpBE,EAAeH,GAAU,SAAAC,GAAK,OAAK,MAALA,CAAA,IAE3C,SAASD,EAAUI,GACf,OAAO,W,IAAI,IAAgCC,EAAA,GAAAC,EAAA,EAAhCA,EAAgCC,UAAAC,OAAhCF,IAAAD,EAAgCC,GAAAC,UAAAD,GAAK,OAAAG,UAAO,WAEnD,IADA,IAAIpB,EACciB,EAAA,EAAAI,EAAAL,EAAAC,EAAII,EAAAF,OAAJF,IAAM,CAAnB,IAAMK,EAAGD,EAAAJ,GAEV,GADAjB,EAAQuB,SAAOD,GACXP,EAAQf,GACR,KAEP,CACD,OAAOA,CACX,GATgD,CAUpD,CCJA,SAASwB,EAAWC,GAChB,GAAIC,cAAYD,GACZ,OAAOA,EAAIE,MAEf,GAAIzD,MAAM0D,QAAQH,GACd,OAAOA,EAAII,IAAIL,GAEnB,GAAIM,QAAMC,cAAcN,GAAM,CAE1B,IADA,IAAMO,EAAS,GACmBf,EAAA,EAAhBgB,EAAAlE,OAAOmE,KAAKT,GAAZR,EAAgBgB,EAAAd,OAAhBF,IAAkB,CAA/B,IAAMkB,EAAGF,EAAAhB,GACVe,EAAOG,GAAOX,EAAWC,EAAIU,GAChC,CACD,OAAOH,CACV,CACD,OAAOP,CACX,C,2CFSgB,SAAalC,EAAoBe,GAC7CD,EAAeC,EAAIhB,EAAeC,GACtC,E,gBApBM,SAA2BY,GAC7B,OAAOA,EAAU0B,IAAI5B,EACzB,E,iBHlBM,SAA+BmC,GACjC,IAAMC,GAASD,EAAKE,YAAc7E,KAE1B8E,EAAsCH,EAAIG,gBAAzBC,EAAqBJ,EAAII,iBAC5CC,EAAmC,CACrCd,IAAG,SAACQ,GACA,IAAMO,EAAkBL,EAAMV,IAAIQ,GAElC,GAAIO,EACA,OAAOA,EAAgBjD,WAI3B,IAAMkD,EAAeC,YAAUC,qBAAoB,WAAM,OAAAL,EAAiBL,EAAjB,IAInDhC,EAAY2C,sBAAoBH,GAChCI,OAAK,CAAEpB,IAAK,WAAM,OAAAgB,EAAahB,KAAb,EAAoBnB,IAAK,SAAAI,GAAK,OAAA+B,EAAanC,IAAII,EAAjB,GAAuBoC,OAAK,IAC5EA,OAAK,GAAG5B,QAAO,WAAM,OAAAuB,EAAahB,KAAb,IAEvBY,GACApC,EAAU8C,YAId,IAAMvD,EAAQS,EAAUV,WAMxB,OALIU,EAAU+C,YACV/C,EAAUxC,GAAgBiB,KAC1ByD,EAAM7B,IAAI2B,EAAKhC,GACfA,EAAUgD,WAAWC,OAAM,WAAM,OAAAf,EAAMgB,OAAOlB,EAAI,GAAE,CAAEmB,WAAW,EAAMC,MAAM,KAE1E7D,C,EAEXc,IAAG,SAACgD,EAAUrB,GACV,IAAMhC,EAAYkC,EAAMV,IAAIQ,IAAQK,EAAiBL,GACrD,IAAKW,sBAAoB3C,GACrB,MAAMyC,YAAUa,aAAiBC,MAAM,oCAAqCvD,GAEhFA,EAAUK,IAAIgD,E,GAItB,OAAO,SAAArB,GACH,IAAKT,cAAYS,GAAM,CACnB,IAAMwB,EAAYtB,EAAMV,IAAIQ,GAC5B,GAAIwB,EACA,OAAOA,EAAUhG,EAExB,CAED,OAAOoF,OAAKN,EAAYN,EAC5B,CACJ,E,+BMvEM,SAAyByB,GAC3B,IAAMC,EAAQb,OAAKrD,aAEnB,OADAiE,EAAKE,MAAK,SAAAlD,GAAK,OAAAiD,EAAME,SAASnD,EAAE,IAAE,SAAAoD,GAAK,OAAAH,EAAME,SAAS,IAAIjE,eAAakE,GAAhC,IAChCH,CACX,E,8CCWM,SAAqBI,GACvB,OAAO,W,IAAC,IAA8BC,EAAA,GAAAjD,EAAA,EAA9BA,EAA8BC,UAAAC,OAA9BF,IAAAiD,EAA8BjD,GAAAC,UAAAD,GAAK,WAAI2B,YAAUuB,WAAWF,EAAGC,EAA5B,CAC/C,E,kCCAgB,SAAkBD,EAAyDG,GACvF,IAAIC,EAAWD,EACf,OAAO,SAAiBZ,GACpB,IAAMxB,EAASiC,EAAE3F,KAAKM,KAAM4E,EAAUa,GAEtC,OADAA,EAAWb,EACJxB,CACX,CACJ,E,OCdM,SAAkBnE,GACpB,OAAO+E,YAAUC,qBAAoB,WAAM,OAAAhF,EAAE8D,KAAF,GAC/C,E,YATM,SAAuB9D,GACzB,OAAO+E,YAAUC,qBAAoB,WAAM,OAAAhF,EAAE4B,UAAF,GAC/C,E,YAYM,SAAuB5B,GACzB,OAAO+E,YAAUC,qBAAoB,WAAM,OAAAhF,EAAEmC,KAAK,GACtD,E,OCAgB,SAAciE,EAAiDK,GAC3E,IAAIC,EAAMD,EACV,OAAO,SAAiBtE,GACpB,OAAOuE,EAAMN,EAAE3F,KAAKM,KAAM2F,EAAKvE,EACnC,CACJ,E,4BLNM,SAAiByB,GACnB,GAAIC,cAAYD,GACZ,OAAOA,EAEX,IAAKvD,MAAM0D,QAAQH,KAASK,QAAMC,cAAcN,GAC5C,MAAUiC,MAAM,8DAEpB,OAAOtC,SAAOI,EAAYC,EAC9B,E,qBFsB6BlC,EAAoBe,EAAsB8B,GACnE,OAAOlC,EAAYX,GAAM6D,OAAM,SAAA1D,GAAS,OAAAW,EAAeC,EAAIZ,EAAM,GAAE0C,EACvE,E,WQnCM,SAAmBoC,G,IAA6B,IAAcxD,EAAA,GAAAC,EAAA,EAAdA,EAAcC,UAAAC,OAAdF,IAAAD,EAAcC,EAAA,GAAAC,UAAAD,GAChE,OAAOG,UAAO,WAEV,IADA,IAAIqD,EAAI,GACCC,EAAI,EAAGA,EAAIF,EAAMrD,OAAQuD,IAC9BD,GAAKD,EAAME,GACPA,EAAI1D,EAAKG,SACTsD,GAAKlD,SAAOP,EAAK0D,KAGzB,OAAOD,CACX,GACJ,E","ignoreList":[]}

package/src/derivable-cache.d.ts

@@ -9,5 +9,5 @@ export interface DerivableCacheOptions<K, V> {
     mapFactory?(): MapImplementation<K, Derivable<V>>;
     delayedEviction?: boolean;
 }
-export declare type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;
+export type DerivableCache<K, V> = (key: Unwrappable<K>) => SettableDerivable<V>;
 export declare function derivableCache<K, V>(opts: DerivableCacheOptions<K, V>): DerivableCache<K, V>;

package/src/lift.d.ts

@@ -13,4 +13,4 @@ export declare function lift<R>(f: () => R): () => Derivable<R>;
 export declare function lift<P1, R>(f: (p1: P1) => R): (p1: MD<P1>) => Derivable<R>;
 export declare function lift<P1, P2, R>(f: (p1: P1, p2: P2) => R): (p1: MD<P1>, p2: MD<P2>) => Derivable<R>;
 export declare function lift<P1, P2, P3, R>(f: (p1: P1, p2: P2, p3: P3) => R): (p1: MD<P1>, p2: MD<P2>, p3: MD<P3>) => Derivable<R>;
-export declare type MD<P> = P | Derivable<P>;
+export type MD<P> = P | Derivable<P>;

package/src/state.d.ts

@@ -1,5 +1,5 @@
 import { Derivable, DerivableAtom, ReactorOptions, State } from '@politie/sherlock';
-export declare type StateObject<V> = {
+export type StateObject<V> = {
     value: V;
     errored: false;
     resolved: true;