@adobe/data 0.1.3 → 0.2.0

package/src/observe/types.ts

@@ -0,0 +1,40 @@
+/*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.*/
+/**
+ * An Observe type is a function that can be called to observe a sequence of values.
+ * The Observe function is called with a Callback function that may be called zero or more times.
+ * The Observe function returns an Unobserve function that can be called to stop observing the Observe function.
+ */
+export type Observe<T> = (notify: Notify<T>) => Unobserve;
+
+/**
+ * Callback function called zero or more times with a sequence of values.
+ * *may* be called back synchronously, immediately when selector function is called.
+ * *may* also be called back later asynchronously any number of times.
+ * *may* be called multiple sequential times with the same value.
+ */
+export type Notify<T> = (value: T) => void;
+
+/**
+ * Function called to stop observing an Observe function.
+ */
+export type Unobserve = () => void;

package/src/observe/with-async-map.ts

@@ -0,0 +1,37 @@
+/*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 { Observe } from "./types.js";
+
+/**
+ * Creates a new Observe function that converts the original observe function's values into
+ * a new value at each notification using an async promise mapping function.
+ */
+export function withAsyncMap<T, U>(
+  observable: Observe<T>,
+  map: (value: T) => Promise<U>
+): Observe<U> {
+  return (observer) => {
+    return observable(async (value) => {
+      observer(await map(value));
+    });
+  };
+}

package/src/observe/with-batch.test.ts

@@ -0,0 +1,141 @@
+/*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 { describe, it, expect, vi } from 'vitest';
+import { withBatch } from './with-batch.js';
+import { createObservableState } from './create-observable-state.js';
+
+describe('withBatch', () => {
+    it('should batch multiple rapid emissions into a single notification', async () => {
+        const [source, setSource] = createObservableState<number>(1);
+        const batched = withBatch(source);
+        
+        const observedValues: number[] = [];
+        const unsubscribe = batched((value) => {
+            observedValues.push(value);
+        });
+
+        // Initial value should be emitted immediately
+        expect(observedValues).toEqual([1]);
+
+        // Multiple rapid updates should be batched
+        setSource(2);
+        setSource(3);
+        setSource(4);
+
+        // Should not have emitted yet (still in same microtask)
+        expect(observedValues).toEqual([1]);
+
+        // Wait for next microtask
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        // Should have emitted only the last value
+        expect(observedValues).toEqual([1, 4]);
+
+        unsubscribe();
+    });
+
+    it('should handle multiple batches correctly', async () => {
+        const [source, setSource] = createObservableState<number>(1);
+        const batched = withBatch(source);
+        
+        const observedValues: number[] = [];
+        const unsubscribe = batched((value) => {
+            observedValues.push(value);
+        });
+
+        // Initial value
+        expect(observedValues).toEqual([1]);
+
+        // First batch
+        setSource(2);
+        setSource(3);
+
+        // Second batch (after microtask)
+        await new Promise(resolve => setTimeout(resolve, 0));
+        setSource(4);
+        setSource(5);
+
+        // Should have emitted only the last value from first batch
+        expect(observedValues).toEqual([1, 3]);
+
+        // Wait for second batch
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        // Should have emitted only the last value from second batch
+        expect(observedValues).toEqual([1, 3, 5]);
+
+        unsubscribe();
+    });
+
+    it('should handle unsubscribe correctly', async () => {
+        const [source, setSource] = createObservableState<number>(1);
+        const batched = withBatch(source);
+        
+        const observedValues: number[] = [];
+        const unsubscribe = batched((value) => {
+            observedValues.push(value);
+        });
+
+        // Initial value
+        expect(observedValues).toEqual([1]);
+
+        // Update and unsubscribe before microtask
+        setSource(2);
+        unsubscribe();
+
+        // Wait for microtask
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        // Should not have emitted after unsubscribe
+        expect(observedValues).toEqual([1]);
+    });
+
+    it('should work with multiple observers', async () => {
+        const [source, setSource] = createObservableState<number>(1);
+        const batched = withBatch(source);
+        
+        const values1: number[] = [];
+        const values2: number[] = [];
+
+        const unsubscribe1 = batched((value) => values1.push(value));
+        const unsubscribe2 = batched((value) => values2.push(value));
+
+        // Both observers should get initial value
+        expect(values1).toEqual([1]);
+        expect(values2).toEqual([1]);
+
+        // Multiple rapid updates
+        setSource(2);
+        setSource(3);
+        setSource(4);
+
+        // Wait for microtask
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        // Both observers should get only the last value
+        expect(values1).toEqual([1, 4]);
+        expect(values2).toEqual([1, 4]);
+
+        unsubscribe1();
+        unsubscribe2();
+    });
+}); 

package/src/observe/with-batch.ts

@@ -0,0 +1,67 @@
+/*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 { Observe } from "./types.js";
+
+/**
+ * Creates a new Observe function that batches multiple rapid emissions into a single notification.
+ * If multiple values are emitted within the same microtask, only the last value is forwarded to observers
+ * after the microtask boundary.
+ */
+export function withBatch<T>(observable: Observe<T>): Observe<T> {
+    return (observer) => {
+        let pendingValue: T | undefined;
+        let isScheduled = false;
+        let hasInitialValue = false;
+
+        const scheduleNotification = () => {
+            if (!isScheduled) {
+                isScheduled = true;
+                queueMicrotask(() => {
+                    if (pendingValue !== undefined) {
+                        observer(pendingValue);
+                        pendingValue = undefined;
+                    }
+                    isScheduled = false;
+                });
+            }
+        };
+
+        const unobserve = observable((value) => {
+            if (!hasInitialValue) {
+                // Emit initial value immediately
+                observer(value);
+                hasInitialValue = true;
+            } else {
+                // Batch subsequent values
+                pendingValue = value;
+                scheduleNotification();
+            }
+        });
+
+        return () => {
+            unobserve();
+            pendingValue = undefined;
+            isScheduled = false;
+            hasInitialValue = false;
+        };
+    };
+} 

package/{core/data.js → src/observe/with-cache.ts}

@@ -19,34 +19,40 @@ 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 { Notify, Observe, Unobserve } from "./types.js";
+
 /**
- * Compares two Data objects for deep equality.
- * Ordering of keys matters.
- * If order is not important then use normalize first.
+ * Creates a new Observe function that will cache the last value and notify observers immediately with the last value.
+ * Also prevents the base observe function from being called more than once with multiple simultaneous observers.
  */
-export function equals(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (!a || !b) {
-        return false;
+
+export function withCache<T>(observable: Observe<T>): Observe<T> {
+  let value: T | undefined = undefined;
+  let hasValue = false;
+  const observers = new Set<Notify<T>>();
+  let unobserve: Unobserve | null = null;
+  return (observer) => {
+    observers.add(observer);
+    if (hasValue) {
+      observer(value as T);
     }
-    return JSON.stringify(a) === JSON.stringify(b);
-}
-/**
- * Returns a new normalized object of the same type by
- * recursively sorting any contained objects keys alphabetically.
- */
-export function normalize(d) {
-    //  we could structured clone but let's explicitly shed any keys with undefined values.
-    return JSON.parse(JSON.stringify(d), (_key, value) => {
-        if (value && !Array.isArray(value) && typeof value === "object") {
-            return Object.fromEntries(Object.entries(value).sort(([a], [b]) => 
-            //  not using String.localeCompare
-            //  we want this consistent no matter locale
-            a < b ? -1 : a > b ? 1 : 0));
+
+    if (observers.size === 1) {
+      unobserve = observable((newValue) => {
+        hasValue = true;
+        value = newValue;
+        for (const callback of observers) {
+          callback(newValue);
         }
-        return value;
-    });
+      });
+    }
+
+    return () => {
+      observers.delete(observer);
+      if (observers.size === 0 && unobserve) {
+        unobserve();
+        unobserve = null;
+      }
+    };
+  };
 }
-//# sourceMappingURL=data.js.map

package/src/observe/with-copy.ts

@@ -0,0 +1,32 @@
+/*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 { Observe } from "./types.js";
+import { withMap } from "./with-map.js";
+
+/**
+ * Makes a deep copy of the observed value using structured cloning.
+ */
+export function withCopy<T>(observable: Observe<T>): Observe<T> {
+  return withMap(observable, (value) => {
+    return structuredClone(value);
+  });
+}

package/src/observe/with-deduplicate-data.ts

@@ -0,0 +1,43 @@
+/*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 { Observe } from "./types.js";
+import { Data } from "../data.js";
+import { equals } from "../equals.js";
+
+/**
+ * Creates a new Observe function that will cache the last value and only notify observers when the value changes.
+ * Performs a deep comparison of the value to determine if it has changed.
+ */
+export function withDeduplicateData<T extends Data>(
+  observable: Observe<T>
+): Observe<T> {
+  return (observer) => {
+    let lastValue: T | undefined = undefined;
+    return observable((value) => {
+      const notify = lastValue === undefined || !equals(lastValue, value);
+      if (notify) {
+        lastValue = value;
+        observer(value);
+      }
+    });
+  };
+}

package/src/observe/with-deduplicate.ts

@@ -0,0 +1,41 @@
+/*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 { Observe } from "./types.js";
+
+/**
+ * Creates a new Observe function on a data value which will be cached such that
+ * observers will never be notified consecutively of equivalent values.
+ */
+export function withDeduplicate<T>(observable: Observe<T>): Observe<T> {
+  return (observer) => {
+    let notified = false;
+    let lastValue: T | undefined = undefined;
+    return observable((value) => {
+      const notify = !notified || lastValue !== value;
+      if (notify) {
+        notified = true;
+        lastValue = value;
+        observer(value);
+      }
+    });
+  };
+}

package/src/observe/with-default.ts

@@ -0,0 +1,48 @@
+/*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 { Observe } from "./types.js";
+
+/**
+ * Creates a new observable that will use a defaultValue whenever the observed
+ * value is undefined and will always respond synchronously when called.
+ */
+export const withDefault =
+  <T>(defaultValue: T) =>
+    (observable: Observe<T | undefined>): Observe<T> => {
+      return (observer) => {
+        let notified = false as boolean;
+        const notify = (value?: T) => {
+          notified = true;
+          observer(value === undefined ? defaultValue : value);
+        };
+
+        const unobserverInternal = observable((value) => {
+          notify(value);
+        });
+
+        if (!notified) {
+          notify();
+        }
+
+        return unobserverInternal;
+      };
+    };

package/src/observe/with-lazy.test.ts

@@ -0,0 +1,68 @@
+/*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 { describe, it, expect } from 'vitest';
+import { withLazy } from './with-lazy.js';
+import { createObservableState } from './create-observable-state.js';
+
+describe('withLazy', () => {
+    it('should defer observable creation until first subscription', () => {
+        let factoryCalled = false;
+        const factory = () => {
+            factoryCalled = true;
+            const [source] = createObservableState<number>(42);
+            return source;
+        };
+
+        const lazyObs = withLazy(factory);
+        expect(factoryCalled).toBe(false);
+
+        const values: number[] = [];
+        const unsubscribe = lazyObs(value => values.push(value));
+        
+        expect(factoryCalled).toBe(true);
+        expect(values).toEqual([42]);
+        
+        unsubscribe();
+    });
+
+    it('should cache the observable after first creation', () => {
+        let callCount = 0;
+        const factory = () => {
+            callCount++;
+            const [source] = createObservableState<number>(42);
+            return source;
+        };
+
+        const lazyObs = withLazy(factory);
+        
+        // First subscription
+        const unsubscribe1 = lazyObs(() => {});
+        expect(callCount).toBe(1);
+        
+        // Second subscription should reuse the same observable
+        const unsubscribe2 = lazyObs(() => {});
+        expect(callCount).toBe(1);
+        
+        unsubscribe1();
+        unsubscribe2();
+    });
+}); 

package/{core/functions/is-promise.js → src/observe/with-lazy.ts}

@@ -19,8 +19,20 @@ 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.*/
-export function isPromise(obj) {
-    const maybePromise = obj;
-    return (!!maybePromise && (typeof maybePromise === 'object' || typeof maybePromise === 'function') && typeof maybePromise?.then === 'function');
-}
-//# sourceMappingURL=is-promise.js.map
+import { Observe } from "./types.js";
+
+/**
+ * Creates a new Observe function that defers the creation of an expensive observable
+ * until the first subscription. The created observable is cached and reused for
+ * all subsequent subscriptions.
+ */
+export function withLazy<T>(factory: () => Observe<T>): Observe<T> {
+    let cachedObservable: Observe<T> | null = null;
+    
+    return (observer) => {
+        if (!cachedObservable) {
+            cachedObservable = factory();
+        }
+        return cachedObservable(observer);
+    };
+} 

package/{observe/with-map-data.js → src/observe/with-map-data.ts}

@@ -19,14 +19,20 @@ 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 { Data } from "../index.js";
+import { Observe } from "./types.js";
 import { withCopy } from "./with-copy.js";
 import { withDeduplicateData } from "./with-deduplicate-data.js";
 import { withMap } from "./with-map.js";
+
 /**
  * A higher order observable that maps to a specific data value, deduplicates the data, and copies the data.
  * withMapData(observable, map) = withCopy(withDeduplicateData(withMap(observable, map)))
  */
-export function withMapData(observable, map) {
-    return withCopy(withDeduplicateData(withMap(observable, map)));
+export function withMapData<T, U extends Data>(
+  observable: Observe<T>,
+  map: (value: T) => U
+): Observe<U> {
+  return withCopy(withDeduplicateData(withMap(observable, map)));
 }
-//# sourceMappingURL=with-map-data.js.map