@shaxpir/duiduidui-models 1.25.11 → 1.26.0

package/dist/models/Chat.js

@@ -54,36 +54,25 @@ class Chat extends SharedContent_1.SharedContent {
      */
     async modelUpdated() {
         this.checkDisposed('Chat.modelUpdated');
-        const chatId = this.id;
-        const title = this.title;
-        console.log(`[Chat.modelUpdated] START chat=${chatId} title=${JSON.stringify(title)} acquireCount=${this.acquireCount}`);
         // Update manifests for all participants
         await super.modelUpdated();
-        console.log(`[Chat.modelUpdated] after super.modelUpdated chat=${chatId} acquireCount=${this.acquireCount}`);
         // Update workspace stubs for all participants
         const stub = this.toStub();
         const userIds = this.getAllSharedUserIds();
-        console.log(`[Chat.modelUpdated] stub.title=${JSON.stringify(stub.title)} userIds=${JSON.stringify(userIds)}`);
         for (const userId of userIds) {
             try {
                 const workspaceId = shaxpir_common_1.CachingHasher.makeMd5Base62Hash(userId + "-" + ContentKind_1.ContentKind.WORKSPACE);
                 const workspace = await this.shareSync.acquire(ContentKind_1.ContentKind.WORKSPACE, workspaceId);
                 if (workspace && workspace.exists()) {
-                    console.log(`[Chat.modelUpdated] upserting stub for user=${userId} workspace=${workspaceId}`);
                     // Cast needed to avoid circular dependency between Chat and Workspace
                     workspace.upsertChatStub(stub);
                     workspace.release();
                 }
-                else {
-                    console.log(`[Chat.modelUpdated] workspace not found for user=${userId} workspace=${workspaceId}`);
-                }
             }
             catch (err) {
-                console.error(`[Chat.modelUpdated] ERROR for user=${userId}:`, err);
                 this.shareSync.onError(err, 'Chat.modelUpdated.workspaceStub');
             }
         }
-        console.log(`[Chat.modelUpdated] END chat=${chatId}`);
     }
     // ---- Getters ----
     get payload() {

package/dist/models/Model.d.ts

@@ -18,6 +18,14 @@ export declare abstract class Model {
     protected shareSync: ShareSync;
     private _subscribingPromise;
     private _acquireCount;
+    private _disposeTimer;
+    /**
+     * How long to wait (ms) after refcount hits 0 before actually disposing.
+     * This allows rapid acquire/release cycles (e.g., multiple concurrent
+     * modelUpdated calls) to reuse the model without it being destroyed
+     * and re-fetched in between.
+     */
+    private static readonly DISPOSE_DELAY_MS;
     constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
     get kind(): ContentKind;
     get ref(): ContentRef;

package/dist/models/Model.js

@@ -13,6 +13,7 @@ class Model {
         this._clearEventListeners = null;
         this._subscribingPromise = null;
         this._acquireCount = 0;
+        this._disposeTimer = null;
         const model = this;
         model.doc = doc;
         model.shareSync = shareSync;
@@ -95,6 +96,11 @@ class Model {
         return this._acquireCount;
     }
     async acquire(minVersion) {
+        // Cancel any pending deferred disposal — this model is being reused
+        if (this._disposeTimer) {
+            clearTimeout(this._disposeTimer);
+            this._disposeTimer = null;
+        }
         this._acquireCount++;
         if (!this._hasEventListeners) {
             this._setupEventListeners();
@@ -113,7 +119,17 @@ class Model {
         this.log(`RELEASE: (${this.compoundKey}); acquireCount = ${this.acquireCount}`);
         if (this._acquireCount <= 0) {
             this._acquireCount = 0;
-            this.dispose();
+            // Defer disposal to allow rapid re-acquire without destroying the doc.
+            // If acquire() is called before the timer fires, it cancels the timer.
+            if (!this._disposeTimer) {
+                this._disposeTimer = setTimeout(() => {
+                    this._disposeTimer = null;
+                    // Only dispose if still unreferenced
+                    if (this._acquireCount <= 0) {
+                        this.dispose();
+                    }
+                }, Model.DISPOSE_DELAY_MS);
+            }
         }
     }
     dispose() {
@@ -301,3 +317,10 @@ class Model {
 }
 exports.Model = Model;
 Model.CHANGED = "MODEL_CHANGED";
+/**
+ * How long to wait (ms) after refcount hits 0 before actually disposing.
+ * This allows rapid acquire/release cycles (e.g., multiple concurrent
+ * modelUpdated calls) to reuse the model without it being destroyed
+ * and re-fetched in between.
+ */
+Model.DISPOSE_DELAY_MS = 5000;

package/dist/models/SharedContent.js

@@ -28,27 +28,21 @@ class SharedContent extends Content_1.Content {
     async modelUpdated() {
         this.checkDisposed("SharedContent.modelUpdated");
         this.acquire();
-        const contentId = this.id;
         const userIds = this.getAllSharedUserIds();
         for (const userId of userIds) {
             try {
                 const manifestId = Manifest_1.Manifest.makeManifestId(userId);
-                console.log(`[SharedContent.modelUpdated] acquiring manifest ${manifestId} for content=${contentId}`);
                 const manifest = await this.shareSync.acquire(ContentKind_1.ContentKind.MANIFEST, manifestId);
-                console.log(`[SharedContent.modelUpdated] acquired manifest ${manifestId} exists=${manifest?.exists()}`);
                 if (manifest && manifest.exists()) {
                     manifest.update(this);
                     manifest.release();
-                    console.log(`[SharedContent.modelUpdated] updated and released manifest ${manifestId}`);
                 }
             }
             catch (err) {
-                console.error(`[SharedContent.modelUpdated] ERROR acquiring manifest for user=${userId}:`, err);
                 this.shareSync.onError(err, 'SharedContent.modelUpdated.manifest');
             }
         }
         this.release();
-        console.log(`[SharedContent.modelUpdated] released content=${contentId} acquireCount=${this.acquireCount}`);
     }
 }
 exports.SharedContent = SharedContent;

package/dist/repo/ShareSync.js

@@ -389,28 +389,15 @@ class ShareSync {
         // First, try getting the content from the cache
         const compoundKey = `${kind}/${id}`;
         if (this._modelCache.has(compoundKey)) {
-            const cached = this._modelCache.get(compoundKey);
-            console.log(`[ShareSync.load] cache hit: ${compoundKey} isDisposed=${cached._isDisposed} acquireCount=${cached.acquireCount}`);
-            return cached;
+            return this._modelCache.get(compoundKey);
         }
         // If not in the cache, get the model doc from the connection.
         // Then wrap it and put it in the cache for future reference.
         const doc = this._connection.get(kind, id);
         if (!doc) {
-            console.error(`[ShareSync.load] connection.get(${kind}, ${id}) returned null/undefined doc`);
+            console.error(`[ShareSync] connection.get(${kind}, ${id}) returned null/undefined doc`);
             return null;
         }
-        const docAny = doc;
-        const docState = {
-            hasData: typeof doc.data !== 'undefined',
-            version: doc.version,
-            type: doc.type ? 'set' : 'null',
-            wantsDestroy: docAny._wantsDestroy,
-            inflightFetch: docAny.inflightFetch?.length,
-            pendingFetch: docAny.pendingFetch?.length,
-            hasPending: docAny.hasPending?.(),
-        };
-        console.log(`[ShareSync.load] cache miss: ${compoundKey} doc=${JSON.stringify(docState)}`);
         const model = this.wrap(kind, doc, false);
         this._modelCache.set(compoundKey, model);
         return model;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaxpir/duiduidui-models",
-  "version": "1.25.11",
+  "version": "1.26.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/shaxpir/duiduidui-models"