@adobe/data 0.1.2 → 0.2.0

package/observe/from-element-id.d.ts

@@ -1,7 +0,0 @@
-import { Observe } from "./types.js";
-/**
- * Uses DOM MutationObserver to watch for the addition or removal of an element with a specific id.
- * @param id The id of the element to watch for.
- * @returns a new Observe<Element | null> which yields null if element does not exist.
- */
-export declare function fromElementId<T extends HTMLElement = HTMLElement>(ancestor: HTMLElement | ShadowRoot, id: string): Observe<T | null>;

package/observe/from-element-id.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-element-id.js","sourceRoot":"","sources":["../../src/observe/from-element-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;WAoBW;AACX,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD;;;;GAIG;AAEH,MAAM,UAAU,aAAa,CAC3B,QAAkC,EAClC,EAAU;IAEV,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACd,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,CAAC,QAAQ,EAAE,EAAE;QAClB,IAAI,WAAW,GAAa,IAAI,CAAC;QACjC,MAAM,MAAM,GAAG,GAAG,EAAE;YAClB,MAAM,UAAU,GAAG,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAa,CAAC;YAC3D,IAAI,CAAC,WAAW,IAAI,UAAU,KAAK,WAAW,EAAE,CAAC;gBAC/C,WAAW,GAAG,UAAU,CAAC;gBACzB,QAAQ,CAAC,UAAU,CAAC,CAAC;YACvB,CAAC;QACH,CAAC,CAAC;QACF,MAAM,EAAE,CAAC;QACT,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,CAAC,SAAS,EAAE,EAAE;YAC1D,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;gBACjC,IAAI,QAAQ,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;oBAClC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;wBACvC,IAAK,IAAU,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;4BAC1B,OAAO,GAAG,IAAI,CAAC;wBACjB,CAAC;oBACH,CAAC;oBACD,IAAI,CAAC,OAAO,EAAE,CAAC;wBACb,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,YAAY,EAAE,CAAC;4BACzC,IAAK,IAAU,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;gCAC1B,OAAO,GAAG,IAAI,CAAC;4BACjB,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,OAAO,EAAE,CAAC;gBACZ,MAAM,EAAE,CAAC;YACX,CAAC;QACH,CAAC,CAAC,CAAC;QACH,gBAAgB,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QACvE,OAAO,GAAG,EAAE;YACV,gBAAgB,CAAC,UAAU,EAAE,CAAC;QAChC,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/observe/from-element-properties-and-events.d.ts

@@ -1,2 +0,0 @@
-import { Observe } from "./types.js";
-export declare function fromElementPropertyAndEvents<T extends HTMLElement, K extends keyof T, E extends keyof HTMLElementEventMap>(element: T, property: K, events: E[]): Observe<T[K]>;

package/observe/from-element-properties-and-events.js

@@ -1,18 +0,0 @@
-//  private helper function to create an observable from an element property and events.
-export function fromElementPropertyAndEvents(element, property, events) {
-    return (observer) => {
-        const listener = () => {
-            observer(element[property]);
-        };
-        for (const event of events) {
-            element.addEventListener(event, listener);
-        }
-        observer(element[property]);
-        return () => {
-            for (const event of events) {
-                element.removeEventListener(event, listener);
-            }
-        };
-    };
-}
-//# sourceMappingURL=from-element-properties-and-events.js.map

package/observe/from-element-properties-and-events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-element-properties-and-events.js","sourceRoot":"","sources":["../../src/observe/from-element-properties-and-events.ts"],"names":[],"mappings":"AAuBA,wFAAwF;AACxF,MAAM,UAAU,4BAA4B,CAI1C,OAAU,EAAE,QAAW,EAAE,MAAW;IACpC,OAAO,CAAC,QAAQ,EAAE,EAAE;QAClB,MAAM,QAAQ,GAAG,GAAG,EAAE;YACpB,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC9B,CAAC,CAAC;QAEF,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,OAAO,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC5C,CAAC;QAED,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAE5B,OAAO,GAAG,EAAE;YACV,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,OAAO,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/observe/from-element-property.d.ts

@@ -1,11 +0,0 @@
-import { Observe } from "./types.js";
-/**
- * Returns an observable that will notify observers when the element property changes.
- * If there are any events provided, then the observer will be notified when the event is triggered.
- * If there are not then a dom mutation observer will be used to watch for changes.
- * @param element The element to watch a property for changes.
- * @param property The property on the element to watch for changes.
- * @param events The events that will trigger a new notification of changed values.
- * @returns
- */
-export declare function fromElementProperty<T extends HTMLElement, K extends keyof T, E extends keyof HTMLElementEventMap>(element: T, property: K, events?: E[]): Observe<T[K]>;

package/observe/from-element-property.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-element-property.js","sourceRoot":"","sources":["../../src/observe/from-element-property.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;WAoBW;AACX,OAAO,EAAE,4BAA4B,EAAE,MAAM,yCAAyC,CAAC;AAGvF,qGAAqG;AACrG,SAAS,sCAAsC,CAG7C,OAAU,EAAE,QAAW;IACvB,OAAO,CAAC,QAAQ,EAAE,EAAE;QAClB,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC5B,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,CAAC,SAAS,EAAE,EAAE;YAC1D,yDAAyD;YACzD,iDAAiD;YACjD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;gBACjC,IAAI,QAAQ,CAAC,aAAa,KAAK,QAAQ,EAAE,CAAC;oBACxC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;oBAC5B,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;QACH,gBAAgB,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QACxD,OAAO,GAAG,EAAE;YACV,gBAAgB,CAAC,UAAU,EAAE,CAAC;QAChC,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAIjC,OAAU,EAAE,QAAW,EAAE,SAAc,EAAE;IACzC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,OAAO,4BAA4B,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;IACjE,CAAC;SAAM,CAAC;QACN,OAAO,sCAAsC,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACnE,CAAC;AACH,CAAC"}

package/observe/from-promise-with-error.d.ts

@@ -1,7 +0,0 @@
-import { Observe } from "./types.js";
-/**
- * Creates a new Observer that will notify observers exactly once when the promise is resolved.
- * In the event of an error, the observer will be notified with the error.
- * Note that the promise is only created when the first observer is added so it is lazy.
- */
-export declare function fromPromiseWithError<T, E extends Error>(promiseFactory: () => Promise<T>): Observe<T | E>;

package/observe/from-promise-with-error.js

@@ -1,27 +0,0 @@
-/**
- * Creates a new Observer that will notify observers exactly once when the promise is resolved.
- * In the event of an error, the observer will be notified with the error.
- * Note that the promise is only created when the first observer is added so it is lazy.
- */
-export function fromPromiseWithError(promiseFactory) {
-    let promise = undefined;
-    return (observer) => {
-        let cancelled = false;
-        promise = promise ?? promiseFactory();
-        promise
-            .then((value) => {
-            if (!cancelled) {
-                observer(value);
-            }
-        })
-            .catch((error) => {
-            if (!cancelled) {
-                observer(error);
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    };
-}
-//# sourceMappingURL=from-promise-with-error.js.map

package/observe/from-promise-with-error.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-promise-with-error.js","sourceRoot":"","sources":["../../src/observe/from-promise-with-error.ts"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAClC,cAAgC;IAEhC,IAAI,OAAO,GAA2B,SAAS,CAAC;IAChD,OAAO,CAAC,QAAQ,EAAE,EAAE;QAClB,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,OAAO,GAAG,OAAO,IAAI,cAAc,EAAE,CAAC;QACtC,OAAO;aACJ,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YACd,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;QACH,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,KAAQ,EAAE,EAAE;YAClB,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;QACH,CAAC,CAAC,CAAC;QACL,OAAO,GAAG,EAAE;YACV,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/observe/from-promise.d.ts

@@ -1,6 +0,0 @@
-import { Observe } from "./types.js";
-/**
- * Creates a new Observer that will notify observers exactly once when the promise is resolved.
- * Note that the promise is only created when the first observer is added so it is lazy.
- */
-export declare function fromPromise<T>(promiseFactory: () => Promise<T>): Observe<T>;

package/observe/from-promise.js

@@ -1,22 +0,0 @@
-/**
- * Creates a new Observer that will notify observers exactly once when the promise is resolved.
- * Note that the promise is only created when the first observer is added so it is lazy.
- */
-export function fromPromise(promiseFactory) {
-    let promise = undefined;
-    return (observer) => {
-        let cancelled = false;
-        promise = promise ?? promiseFactory();
-        promise.then((value) => {
-            if (!cancelled) {
-                observer(value);
-            }
-        }, (reject) => {
-            console.error(`Error in Observe fromPromise`, reject);
-        });
-        return () => {
-            cancelled = true;
-        };
-    };
-}
-//# sourceMappingURL=from-promise.js.map

package/observe/from-promise.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-promise.js","sourceRoot":"","sources":["../../src/observe/from-promise.ts"],"names":[],"mappings":"AAuBA;;;GAGG;AACH,MAAM,UAAU,WAAW,CACzB,cAAgC;IAEhC,IAAI,OAAO,GAA2B,SAAS,CAAC;IAChD,OAAO,CAAC,QAAQ,EAAE,EAAE;QAClB,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,OAAO,GAAG,OAAO,IAAI,cAAc,EAAE,CAAC;QACtC,OAAO,CAAC,IAAI,CACV,CAAC,KAAK,EAAE,EAAE;YACR,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;QACH,CAAC,EACD,CAAC,MAAM,EAAE,EAAE;YACT,OAAO,CAAC,KAAK,CAAC,8BAA8B,EAAE,MAAM,CAAC,CAAC;QACxD,CAAC,CACF,CAAC;QACF,OAAO,GAAG,EAAE;YACV,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/observe/from-properties.d.ts

@@ -1,10 +0,0 @@
-import { Observe } from "./types.js";
-/**
- * Creates a new Observe function that combines every named observe function into a single observe function with a value this is an object with the same keys.
- * No result is provided until every required observe function has provided a value. If they all provide a value synchronously, then a result will be provided synchronously.
- */
-export declare function fromProperties<T extends {
-    [K: string]: Observe<unknown>;
-}>(observeProperties: T): Observe<{
-    readonly [K in keyof T]: T[K] extends Observe<infer U> ? U : never;
-}>;

package/observe/from-properties.js

@@ -1,33 +0,0 @@
-/**
- * Creates a new Observe function that combines every named observe function into a single observe function with a value this is an object with the same keys.
- * No result is provided until every required observe function has provided a value. If they all provide a value synchronously, then a result will be provided synchronously.
- */
-export function fromProperties(observeProperties) {
-    return (observer) => {
-        const values = new Map();
-        let initializing = true;
-        const maybeNotify = () => {
-            if (values.size === Object.keys(observeProperties).length) {
-                observer(Object.fromEntries(values));
-            }
-        };
-        const unobservers = Object.entries(observeProperties)
-            .map(([name, observable]) => {
-            return observable((value) => {
-                values.set(name, value);
-                if (!initializing) {
-                    maybeNotify();
-                }
-            });
-        })
-            .filter(Boolean);
-        initializing = false;
-        maybeNotify();
-        return () => {
-            for (const unobserve of unobservers) {
-                unobserve();
-            }
-        };
-    };
-}
-//# sourceMappingURL=from-properties.js.map

package/observe/from-properties.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-properties.js","sourceRoot":"","sources":["../../src/observe/from-properties.ts"],"names":[],"mappings":"AAuBA;;;GAGG;AACH,MAAM,UAAU,cAAc,CAG5B,iBAAoB;IAOpB,OAAO,CAAC,QAAkC,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAC;QAC9C,IAAI,YAAY,GAAG,IAAI,CAAC;QACxB,MAAM,WAAW,GAAG,GAAG,EAAE;YACvB,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,CAAC;gBAC1D,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAqB,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC,CAAC;QAEF,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC;aAClD,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,EAAE;YAC1B,OAAO,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC1B,MAAM,CAAC,GAAG,CAAC,IAAe,EAAE,KAAmB,CAAC,CAAC;gBACjD,IAAI,CAAC,YAAY,EAAE,CAAC;oBAClB,WAAW,EAAE,CAAC;gBAChB,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;aACD,MAAM,CAAC,OAAO,CAAC,CAAC;QAEnB,YAAY,GAAG,KAAK,CAAC;QACrB,WAAW,EAAE,CAAC;QAEd,OAAO,GAAG,EAAE;YACV,KAAK,MAAM,SAAS,IAAI,WAAW,EAAE,CAAC;gBACpC,SAAS,EAAE,CAAC;YACd,CAAC;QACH,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/observe/index.d.ts

@@ -1,27 +0,0 @@
-/**
- * TESTING SOME INDEX DOCUMENTATION HERE.
- */
-export * from "./create-observable-event.js";
-export * from "./create-observable-state.js";
-export * from "./create-persisted-state.js";
-export * from "./from-constant.js";
-export * from "./from-element-id.js";
-export * from "./from-element-properties-and-events.js";
-export * from "./from-element-property.js";
-export * from "./from-array.js";
-export * from "./from-properties.js";
-export * from "./from-promise-with-error.js";
-export * from "./from-promise.js";
-export * from "./to-promise.js";
-export * from "./to-properties.js";
-export * from "./types.js";
-export * from "./with-cache.js";
-export * from "./with-copy.js";
-export * from "./with-deduplicate-data.js";
-export * from "./with-deduplicate.js";
-export * from "./with-default.js";
-export * from "./with-async-map.js";
-export * from "./with-map.js";
-export * from "./with-map-data.js";
-export * from "./with-optional.js";
-export * from "./with-unwrap.js";

package/observe/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/observe/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;WAoBW;AAEX;;GAEG;AACH,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yCAAyC,CAAC;AACxD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/observe/observe.test.d.ts

@@ -1,7 +0,0 @@
-import { Observe } from "./index.js";
-export declare function testObservableFilter<T, U>(props: {
-    given: string;
-    filter: (observable: Observe<T>) => Observe<U>;
-    input: [T | undefined, Array<T>];
-    output: [U | undefined, Array<U>];
-}): Promise<void>;

package/observe/observe.test.js

@@ -1,417 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { assert } from "riteway/vitest";
-import { describe, test } from "vitest";
-import { createObservableState, fromConstant, fromArray, fromProperties, fromPromise, fromPromiseWithError, withCache, withDeduplicate, withDefault, withMap, withOptional, } from "./index.js";
-import { toProperties } from "./to-properties.js";
-import { withAsyncMap } from "./with-async-map.js";
-function createTestObservable(sync, async) {
-    const observers = new Set();
-    const observe = (observer) => {
-        observers.add(observer);
-        if (sync !== undefined) {
-            observer(sync);
-        }
-        return () => {
-            observers.delete(observer);
-        };
-    };
-    return [
-        observe,
-        async () => {
-            for (const value of async) {
-                await Promise.resolve();
-                for (const observer of observers) {
-                    observer(value);
-                }
-            }
-        },
-    ];
-}
-async function testObserver(props) {
-    const { given, expected, observable: observer, doAsync } = props;
-    const actual = { sync: undefined, async: [] };
-    let isSync = true;
-    const unobserve = observer((value) => {
-        if (isSync) {
-            actual.sync = value;
-        }
-        else {
-            actual.async.push(value);
-        }
-    });
-    isSync = false;
-    await doAsync();
-    unobserve();
-    assert({
-        given,
-        should: `observe ${JSON.stringify(expected)}`,
-        actual,
-        expected,
-    });
-}
-export async function testObservableFilter(props) {
-    const { given, input, filter, output } = props;
-    const [observer, done] = createTestObservable(input[0], input[1]);
-    const filtered = filter(observer);
-    await testObserver({
-        given,
-        expected: {
-            sync: output[0],
-            async: output[1],
-        },
-        observable: filtered,
-        doAsync: done,
-    });
-}
-describe("observable", () => {
-    test("createTestObservable", async () => {
-        const [observer, done] = createTestObservable(1, [2, 3]);
-        await testObserver({
-            given: "createTestObservable",
-            expected: {
-                sync: 1,
-                async: [2, 3],
-            },
-            observable: observer,
-            doAsync: done,
-        });
-    });
-    test("fromConstant", async () => {
-        await testObserver({
-            given: "fromConstant",
-            expected: {
-                sync: 1,
-                async: [],
-            },
-            observable: fromConstant(1),
-            doAsync: () => Promise.resolve(),
-        });
-    });
-    test("withOptional", async () => {
-        const observable = withOptional(fromPromise(() => Promise.resolve(1)));
-        //  manually test that we DO get a sync value callback.
-        {
-            let syncCallback = false;
-            let syncValue;
-            observable((value) => {
-                syncValue = value;
-                syncCallback = true;
-            })();
-            assert({
-                given: "withOptional",
-                should: "get a sync value callback",
-                actual: [syncCallback, syncValue],
-                expected: [true, undefined],
-            });
-        }
-        await testObserver({
-            given: "fromOptional",
-            expected: {
-                sync: undefined,
-                async: [1],
-            },
-            observable,
-            doAsync: () => Promise.resolve(),
-        });
-    });
-    test("fromObservableProperties sync", async () => {
-        const observable = fromProperties({
-            a: fromConstant(1),
-            b: fromConstant(2),
-            c: fromConstant(3),
-        });
-        await testObserver({
-            given: "fromObservableProperties called with all sync values should yield sync result",
-            expected: {
-                sync: { a: 1, b: 2, c: 3 },
-                async: [],
-            },
-            observable,
-            doAsync: () => Promise.resolve(),
-        });
-    });
-    test("fromObservableProperties optional called first", async () => {
-        const [observer1, doAsync1] = createTestObservable(undefined, [1, 2, 3]);
-        const [observer2, doAsync2] = createTestObservable("0", ["1", "2", "3"]);
-        const observable = fromProperties({
-            a: observer1,
-            b: withOptional(observer2),
-        });
-        await testObserver({
-            given: "pick",
-            expected: {
-                sync: undefined,
-                async: [
-                    { a: 1, b: "3" },
-                    { a: 2, b: "3" },
-                    { a: 3, b: "3" },
-                ],
-            },
-            observable,
-            doAsync: async () => {
-                await doAsync2();
-                await doAsync1();
-            },
-        });
-    });
-    test("fromObservableProperties optional called second", async () => {
-        const [observer1, doAsync1] = createTestObservable(undefined, [1, 2, 3]);
-        const [observer2, doAsync2] = createTestObservable(undefined, [
-            "1",
-            "2",
-            "3",
-        ]);
-        const observable = fromProperties({
-            a: observer1,
-            b: withOptional(observer2),
-        });
-        await testObserver({
-            given: "pick",
-            expected: {
-                sync: undefined,
-                async: [
-                    { a: 1, b: undefined },
-                    { a: 2, b: undefined },
-                    { a: 3, b: undefined },
-                    { a: 3, b: "1" },
-                    { a: 3, b: "2" },
-                    { a: 3, b: "3" },
-                ],
-            },
-            observable,
-            doAsync: async () => {
-                await doAsync1();
-                await doAsync2();
-            },
-        });
-    });
-    test("fromObservableArray sync", async () => {
-        const observable = fromArray([
-            fromConstant(1),
-            fromConstant(2),
-            fromConstant(3),
-        ]);
-        await testObserver({
-            given: "fromObservableArray called with all sync values should yield sync result",
-            expected: {
-                sync: [1, 2, 3],
-                async: [],
-            },
-            observable,
-            doAsync: () => Promise.resolve(),
-        });
-    });
-    test("fromPromise", async () => {
-        const promise = Promise.resolve(1);
-        await testObserver({
-            given: "fromPromise",
-            expected: {
-                sync: undefined,
-                async: [1],
-            },
-            observable: fromPromise(() => promise),
-            doAsync: async () => {
-                await promise;
-            },
-        });
-    });
-    test("fromPromiseWithError", async () => {
-        const error = new Error("error");
-        const promise = Promise.reject(error);
-        await testObserver({
-            given: "fromPromiseWithError",
-            expected: {
-                sync: undefined,
-                async: [error],
-            },
-            observable: fromPromiseWithError(() => promise),
-            doAsync: async () => {
-                try {
-                    await promise;
-                }
-                catch (_error) {
-                    // ignore
-                }
-            },
-        });
-    });
-    test("cache", async () => {
-        //  create a promise
-        const promise = Promise.resolve(1);
-        //  create the observable with a cache
-        const observable = withCache(fromPromise(() => promise));
-        //  wait for the first observable value to return.
-        const first = await new Promise((resolve) => {
-            const unobserve = observable((value) => {
-                resolve(value);
-                unobserve();
-            });
-        });
-        assert({
-            given: "first return value from cache",
-            should: "be 1",
-            actual: first,
-            expected: 1,
-        });
-        //  now that it's primed let's verify we get a synchronous result.
-        let syncValue;
-        observable((value) => {
-            syncValue = value;
-        })();
-        assert({
-            given: "synchronous return value from primed cache",
-            should: "be 1",
-            actual: syncValue,
-            expected: 1,
-        });
-    });
-    test("deduplicate shallow compare", async () => {
-        await testObservableFilter({
-            given: "an Observable with cache shallow",
-            filter: withDeduplicate,
-            input: [1, [1, 2, 2, 2, 3, 3, 4]],
-            output: [1, [2, 3, 4]],
-        });
-    });
-    // test("deduplicate deep compare", async () => {
-    //   await testObservableFilter({
-    //     given: "an Observable with deduplicate data",
-    //     filter: withDeduplicateData,
-    //     input: [
-    //       { a: 1 },
-    //       [{ a: 1 }, { a: 2 }, { a: 2 }, { a: 3 }, { a: 3 }, { a: 4 }],
-    //     ],
-    //     output: [{ a: 1 }, [{ a: 2 }, { a: 3 }, { a: 4 }]],
-    //   });
-    // });
-    test("withDefault", async () => {
-        await testObservableFilter({
-            given: "an Observable withDefault",
-            filter: withDefault(0),
-            input: [undefined, [1, undefined, 3]],
-            output: [0, [1, 0, 3]],
-        });
-    });
-    test("withMap", async () => {
-        await testObservableFilter({
-            given: "an Observable withMap",
-            filter: (observable) => withMap(observable, (value) => value * 2),
-            input: [1, [1, 2, 3]],
-            output: [2, [2, 4, 6]],
-        });
-    });
-    test("withAsyncMap", async () => {
-        await testObservableFilter({
-            given: "an Observable withAsyncMap",
-            filter: (observable) => withAsyncMap(observable, async (value) => value * 2),
-            input: [1, [1, 2, 3]],
-            output: [undefined, [2, 2, 4, 6]],
-        });
-    });
-    test("withCache shares base observable", async () => {
-        let observeCount = 0;
-        const observer = withCache((callback) => {
-            observeCount++;
-            callback(42);
-            return () => { };
-        });
-        let observe1 = -1;
-        observer((value) => {
-            observe1 = value;
-        });
-        let observe2 = -1;
-        observer((value) => {
-            observe2 = value;
-        });
-        assert({
-            given: "withShared called multiple times",
-            should: "base observable to be called only once",
-            actual: [observe1, observe2, observeCount],
-            expected: [42, 42, 1],
-        });
-    });
-    test("toObservableProperties", async () => {
-        const [observable, setState] = createObservableState({ a: 1, b: "foo" });
-        const properties = toProperties(observable, ["a", "b"]);
-        const observedValues = [];
-        const observer = (value) => {
-            observedValues.push(value);
-        };
-        properties.a(observer);
-        properties.b(observer);
-        assert({
-            given: "toObservableProperties",
-            should: "observe values",
-            actual: observedValues,
-            expected: [1, "foo"],
-        });
-        setState({ a: 2, b: "bar" });
-        assert({
-            given: "toObservableProperties",
-            should: "observe new values",
-            actual: observedValues,
-            expected: [1, "foo", 2, "bar"],
-        });
-        setState({ a: 2, b: "bar" });
-        assert({
-            given: "toObservableProperties",
-            should: "not observe unchanged values",
-            actual: observedValues,
-            expected: [1, "foo", 2, "bar"],
-        });
-        setState({ a: 3, b: "bar" });
-        assert({
-            given: "toObservableProperties",
-            should: "observe only changed values",
-            actual: observedValues,
-            expected: [1, "foo", 2, "bar", 3],
-        });
-    });
-});
-describe("observable", () => {
-    test("createObservableWithSetter", async () => {
-        const [observable, setter] = createObservableState();
-        const observedValues = [];
-        const unobserve = observable((value) => {
-            observedValues.push(value);
-        });
-        const values = [2, 3, 4];
-        // Set subsequent values
-        values.forEach((value) => setter(value));
-        assert({
-            given: "createObservableWithSetter",
-            should: "observe values",
-            actual: observedValues,
-            expected: values,
-        });
-        unobserve();
-        values.forEach((value) => setter(value));
-        assert({
-            given: "createObservableWithSetter",
-            should: "not observe values after unobserve",
-            actual: observedValues,
-            expected: values,
-        });
-    });
-});
-//# sourceMappingURL=observe.test.js.map