jazz-tools 0.7.0-alpha.35 → 0.7.0-alpha.37

package/src/implementation/devtoolsFormatters.ts

@@ -0,0 +1,109 @@
+import { ItemsSym } from "./symbols.js";
+
+(globalThis as any).devtoolsFormatters = [
+    {
+        header: (object: any) => {
+            if (object._type === "CoMap") {
+                return ["div", {}, ["span", {}, object.constructor.name]];
+            } else if (object._type === "CoList") {
+                return [
+                    "div",
+                    {},
+                    [
+                        "span",
+                        {},
+                        object.constructor.name + "(" + object.length + ") ",
+                    ],
+                ];
+            } else if (object._type === "Account") {
+                return [
+                    "div",
+                    {},
+                    [
+                        "span",
+                        {},
+                        object.constructor.name +
+                            "(" +
+                            object._refs.profile.value?.name +
+                            (object.isMe ? " ME" : "") +
+                            ")",
+                    ],
+                ];
+            } else {
+                return null;
+            }
+        },
+        hasBody: function () {
+            return true;
+        },
+        body: function (object: any) {
+            if (object._type === "CoMap" || object._type === "Account") {
+                return [
+                    "div",
+                    { style: "margin-left: 15px" },
+                    ["div", "id: ", ["object", { object: object.id }]],
+                    ...Object.entries(object).map(([k, v]) => [
+                        "div",
+                        { style: "white-space: nowrap;" },
+                        [
+                            "span",
+                            { style: "font-weight: bold; opacity: 0.6" },
+                            k,
+                            ": ",
+                        ],
+                        ["object", { object: v }],
+                        ...(typeof object._schema[k] === "function"
+                            ? v === null
+                                ? [
+                                      [
+                                          "span",
+                                          { style: "opacity: 0.5" },
+                                          ` (pending ${object._schema[k].name} `,
+                                          [
+                                              "object",
+                                              { object: object._refs[k] },
+                                          ],
+                                          ")",
+                                      ],
+                                  ]
+                                : []
+                            : []),
+                    ]),
+                ];
+            } else if (object._type === "CoList") {
+                return [
+                    "div",
+                    { style: "margin-left: 15px" },
+                    ["div", "id: ", ["object", { object: object.id }]],
+                    ...(object as any[]).map((v, i) => [
+                        "div",
+                        { style: "white-space: nowrap;" },
+                        [
+                            "span",
+                            { style: "font-weight: bold; opacity: 0.6" },
+                            i,
+                            ": ",
+                        ],
+                        ["object", { object: v }],
+                        ...(typeof object._schema[ItemsSym] === "function"
+                            ? v === null
+                                ? [
+                                      [
+                                          "span",
+                                          { style: "opacity: 0.5" },
+                                          ` (pending ${object._schema[ItemsSym].name} `,
+                                          [
+                                              "object",
+                                              { object: object._refs[i] },
+                                          ],
+                                          ")",
+                                      ],
+                                  ]
+                                : []
+                            : []),
+                    ]),
+                ];
+            }
+        },
+    },
+];

package/src/implementation/refs.ts

@@ -16,6 +16,8 @@ import {
 
 const refCache = new WeakMap<RawCoValue, CoValue>();
 
+const TRACE_ACCESSES = false;
+
 export class Ref<out V extends CoValue> {
     constructor(
         readonly id: ID<V>,
@@ -28,7 +30,6 @@ export class Ref<out V extends CoValue> {
     }
 
     get value() {
-        // TODO: cache it for object identity!!!
         const raw = this.controlledAccount._raw.core.node.getLoaded(
             this.id as unknown as CoID<RawCoValue>
         );
@@ -87,16 +88,33 @@ export class Ref<out V extends CoValue> {
         }
     }
 
-    accessFrom(fromScopeValue: CoValue): V | null {
+    accessFrom(fromScopeValue: CoValue, key: string | number | symbol): V | null {
         const subScope = subscriptionsScopes.get(fromScopeValue);
 
-        subScope?.onRefAccessedOrSet(this.id);
+        subScope?.onRefAccessedOrSet(fromScopeValue.id, this.id);
+        TRACE_ACCESSES && console.log(subScope?.scopeID, "accessing", fromScopeValue, key, this.id);
 
         if (this.value && subScope) {
             subscriptionsScopes.set(this.value, subScope);
         }
 
-        return this.value;
+        if (subScope) {
+            const cached = subScope.cachedValues[this.id];
+            if (cached) {
+                TRACE_ACCESSES && console.log("cached", cached);
+                return cached as V;
+            } else if (this.value !== null) {
+                const freshValueInstance = instantiateRefEncoded(this.schema, this.value?._raw);
+                TRACE_ACCESSES && console.log("freshValueInstance", freshValueInstance);
+                subScope.cachedValues[this.id] = freshValueInstance;
+                subscriptionsScopes.set(freshValueInstance, subScope);
+                return freshValueInstance as V;
+            } else {
+                return null
+            }
+        } else {
+            return this.value;
+        }
     }
 }
 

package/src/implementation/subscriptionScope.ts

@@ -6,6 +6,8 @@ export const subscriptionsScopes = new WeakMap<
     SubscriptionScope<any>
 >();
 
+const TRACE_INVALIDATIONS = false;
+
 export class SubscriptionScope<
     Root extends CoValue
 > {
@@ -23,6 +25,8 @@ export class SubscriptionScope<
     };
     onUpdate: (newRoot: Root) => void;
     scheduledUpdate: boolean = false;
+    cachedValues: {[id: ID<CoValue>]: CoValue} = {};
+    parents: {[id: ID<CoValue>]: Set<ID<CoValue>>} = {};
 
     constructor(
         root: Root,
@@ -63,12 +67,15 @@ export class SubscriptionScope<
         }
     }
 
-    onRefAccessedOrSet(accessedOrSetId: ID<CoValue> | undefined) {
+    onRefAccessedOrSet(fromId: ID<CoValue>, accessedOrSetId: ID<CoValue> | undefined) {
         // console.log("onRefAccessedOrSet", this.scopeID, accessedOrSetId);
         if (!accessedOrSetId) {
             return;
         }
 
+        this.parents[accessedOrSetId] = this.parents[accessedOrSetId] || new Set();
+        this.parents[accessedOrSetId]!.add(fromId);
+
         if (!this.entries.has(accessedOrSetId)) {
             const loadingEntry = {
                 state: "loading",
@@ -94,6 +101,7 @@ export class SubscriptionScope<
                         const rawUnsub = core.subscribe((rawUpdate) => {
                             // console.log("ref update", this.scopeID, accessedOrSetId, JSON.stringify(rawUpdate))
                             if (!rawUpdate) return;
+                            this.invalidate(accessedOrSetId);
                             this.scheduleUpdate();
                         });
 
@@ -103,6 +111,14 @@ export class SubscriptionScope<
         }
     }
 
+    invalidate(id: ID<CoValue>, fromChild?: ID<CoValue>) {
+        TRACE_INVALIDATIONS && console.log("invalidating", fromChild, "->", id, this.cachedValues[id]);
+        delete this.cachedValues[id];
+        for (const parent of this.parents[id] || []) {
+            this.invalidate(parent, id);
+        }
+    }
+
     unsubscribeAll() {
         for (const entry of this.entries.values()) {
             if (entry.state === "loaded") {

package/src/internal.ts

@@ -13,4 +13,6 @@ export * from "./implementation/refs.js";
 export * from "./implementation/schema.js";
 export * from "./implementation/subscriptionScope.js";
 
-export * from "./coValues/extensions/imageDef.js";
+export * from "./coValues/extensions/imageDef.js";
+
+import "./implementation/devtoolsFormatters.js"