effectweb 0.2.1 → 0.2.2

package/dist/cache.js

@@ -13,7 +13,7 @@ function createQueryCache(runtime) {
     const registry = AtomRegistry.make({ defaultIdleTTL: 30_000 });
     const generation = Atom.keepAlive(Atom.make(0));
     const resources = new Map();
-    const acquire = (key, load) => {
+    const acquire = (key, load, share = shareValue) => {
         let entry = resources.get(key);
         if (entry)
             entry.load = load;
@@ -24,7 +24,7 @@ function createQueryCache(runtime) {
                     const previous = Option.flatMap(get.self(), AsyncResult.value);
                     return loadEffect(() => next.load()).pipe(Effect.map((value) => {
                         next.loadedAt = Date.now();
-                        return Option.isSome(previous) ? shareValue(previous.value, value) : value;
+                        return Option.isSome(previous) ? share(previous.value, value) : value;
                     }));
                 }),
             };
@@ -47,7 +47,7 @@ function createQueryCache(runtime) {
         const { entry, atom } = acquire(queryKey(definition, args), () => {
             const effect = Effect.suspend(() => definition.load(args));
             return runtime ? runtime.provide(effect) : effect;
-        });
+        }, definition.share);
         entry.queryId = definition.id;
         if (registry.getNodes().has(atom) &&
             entry.loadedAt !== undefined &&

package/dist/collection.d.ts

@@ -10,6 +10,10 @@ export interface Rows<A> {
 }
 export declare function collection<A>(identity: (item: A, index: number) => Identity): {
     from: (items: readonly A[]) => Rows<A>;
+    share: {
+        <B extends A>(previous: readonly B[], next: B[]): B[];
+        <B extends A>(previous: readonly B[], next: readonly B[]): readonly B[];
+    };
 };
 /** Use positional identity for ordered values without stable entity IDs. */
 export declare function sequence<A>(items: readonly A[]): Rows<A>;

package/dist/collection.js

@@ -1,5 +1,7 @@
+import { shareValue } from './share.js';
 export function collection(identity) {
     const cache = new WeakMap();
+    const comparisons = new WeakMap();
     const from = (items) => {
         const cached = cache.get(items);
         if (cached)
@@ -15,7 +17,48 @@ export function collection(identity) {
         cache.set(items, rows);
         return rows;
     };
-    return { from };
+    function share(previous, next) {
+        if (previous === next)
+            return previous;
+        let pairs = comparisons.get(previous);
+        const cached = pairs?.get(next);
+        if (cached)
+            return cached;
+        let byIdentity;
+        let result;
+        let equal = previous.length === next.length;
+        for (let index = 0; index < next.length; index++) {
+            const item = next[index];
+            if (index < previous.length && Object.is(previous[index], item))
+                continue;
+            const key = identity(item, index);
+            let old = previous[index];
+            if (index >= previous.length || !Object.is(identity(old, index), key)) {
+                if (!byIdentity) {
+                    byIdentity = new Map(previous.map((value, i) => [identity(value, i), value]));
+                    const keys = next.map(identity);
+                    if (byIdentity.size !== previous.length || new Set(keys).size !== keys.length)
+                        throw new Error('Duplicate collection identity. Identity must be unique within the collection.');
+                }
+                old = byIdentity.get(key);
+            }
+            const value = old === undefined ? item : shareValue(old, item);
+            if (!Object.is(value, previous[index]))
+                equal = false;
+            if (!Object.is(value, item) && !result)
+                result = next.slice();
+            if (result)
+                result[index] = value;
+        }
+        const shared = equal ? previous : (result ?? next);
+        if (!pairs) {
+            pairs = new WeakMap();
+            comparisons.set(previous, pairs);
+        }
+        pairs.set(next, shared);
+        return shared;
+    }
+    return { from, share };
 }
 const positions = collection((_item, index) => index);
 /** Use positional identity for ordered values without stable entity IDs. */

package/dist/query.d.ts

@@ -7,16 +7,20 @@ export interface Query<Args, A, E = never, R = never> {
     readonly load: (args: Args) => Effect.Effect<A, E, R>;
     /** Revalidate on activation/prefetch after this many milliseconds. No polling timer. */
     readonly staleTime: number;
+    /** Reuse unchanged domain entities before publishing a refreshed result. */
+    readonly share?: (previous: A, next: A) => A;
 }
 /** Identity belongs to arguments, never callback identity. Separate caches isolate independent data scopes. */
 export declare function query<A, E = never, R = never>(definition: {
     readonly name: string;
     readonly load: () => Effect.Effect<A, E, R>;
     readonly staleTime?: number;
+    readonly share?: (previous: A, next: A) => A;
 }): Query<true, A, E, R>;
 export declare function query<Args, A, E = never, R = never>(definition: {
     readonly name: string;
     readonly key: (args: Args) => string;
     readonly load: (args: Args) => Effect.Effect<A, E, R>;
     readonly staleTime?: number;
+    readonly share?: (previous: A, next: A) => A;
 }): Query<Args, A, E, R>;

package/dist/share.d.ts

@@ -1,2 +1,6 @@
+/** Override sharing for selected fields, for example a collection keyed by domain identity. */
+export type ShareFields<T> = {
+    readonly [K in keyof T]?: (previous: T[K], next: T[K]) => T[K];
+};
 /** Share JSON-shaped data; Blob, typed arrays and class instances retain their own identity. */
-export declare function shareValue<T>(previous: T, next: T): T;
+export declare function shareValue<T>(previous: T, next: T, fields?: ShareFields<T>): T;

package/dist/share.js

@@ -2,7 +2,7 @@
 // already compared object pair without retaining either snapshot after its owners release it.
 const sharedPairs = new WeakMap();
 /** Share JSON-shaped data; Blob, typed arrays and class instances retain their own identity. */
-export function shareValue(previous, next) {
+export function shareValue(previous, next, fields) {
     if (Object.is(previous, next))
         return previous;
     if (!previous || !next || typeof previous !== 'object' || typeof next !== 'object')
@@ -15,7 +15,7 @@ export function shareValue(previous, next) {
             Object.getPrototypeOf(previous) !== Object.prototype))
         return next;
     let pairs = sharedPairs.get(previous);
-    if (pairs?.has(next))
+    if (!fields && pairs?.has(next))
         return pairs.get(next);
     const old = previous;
     const value = next;
@@ -24,13 +24,19 @@ export function shareValue(previous, next) {
     let unchangedNext = true;
     const shared = array ? [] : {};
     for (const key of keys) {
-        shared[key] = shareValue(old[key], value[key]);
+        const custom = fields && Object.hasOwn(fields, key) ? fields[key] : undefined;
+        shared[key] =
+            custom && Object.hasOwn(old, key)
+                ? custom(old[key], value[key])
+                : shareValue(old[key], value[key]);
         if (!Object.hasOwn(old, key) || shared[key] !== old[key])
             equal = false;
         if (shared[key] !== value[key])
             unchangedNext = false;
     }
     const result = equal ? previous : unchangedNext ? next : shared;
+    if (fields)
+        return result;
     if (!pairs) {
         pairs = new WeakMap();
         sharedPairs.set(previous, pairs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effectweb",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Immutable Effect models and compiled JSX with direct DOM rendering",
   "homepage": "https://github.com/DerpyCrabs/EffectWeb",
   "bugs": {