@jupyter/docprovider 5.0.0 → 5.0.1

package/lib/ydrive.js

@@ -73,19 +73,24 @@ export class RtcContentProvider {
                     if (!oldPath || !newPath) {
                         // This is expected when shared model initializes and the path is first populated
                         console.debug('New or old path not given', pathChange);
-                        return;
+                        return false;
+                    }
+                    // A rename can be reported by both the drive and the shared model.
+                    // Do not process the second notification again.
+                    if (oldPath !== path && newPath === path) {
+                        return false;
                     }
                     const oldKey = `${options.format}:${options.contentType}:${oldPath}`;
                     if (oldKey !== key) {
                         console.error('The computed old provider key is different from the current key');
-                        return;
+                        return false;
                     }
                     const newKey = `${options.format}:${options.contentType}:${newPath}`;
                     // Check if the provider is still registered (it may have been disposed if document was closed)
                     const provider = this._providers.get(oldKey);
                     if (!provider) {
                         console.warn(`Could not find a provider to update after rename ${oldKey}, ${newKey}`);
-                        return;
+                        return false;
                     }
                     // Re-register the provider under the new key
                     this._providers.set(newKey, provider);
@@ -102,6 +107,7 @@ export class RtcContentProvider {
                         documents.push(newPath);
                         (_b = this._globalAwareness) === null || _b === void 0 ? void 0 : _b.setLocalStateField('documents', documents);
                     }
+                    return true;
                 };
                 // The information about file being renamed can come from two places:
                 // - from the sharedModel via changed signal with documentChange
@@ -129,13 +135,21 @@ export class RtcContentProvider {
                 };
                 (_c = this._driveFileChanged) === null || _c === void 0 ? void 0 : _c.connect(handleFileChangedSignal);
                 sharedModel.changed.connect(async (_, change) => {
-                    var _a;
                     if (!change.stateChange) {
                         return;
                     }
                     const pathChanges = change.stateChange.filter(change => change.name === 'path');
                     for (const pathChange of pathChanges) {
-                        handlePathChange(pathChange);
+                        if (handlePathChange(pathChange)) {
+                            // The drive emits a rename directly in the client that initiated
+                            // it. Other clients learn about it through the shared model, so
+                            // proxy that change to their ContentsManager/DocumentContext too.
+                            this._providerFileChanged.emit({
+                                type: 'rename',
+                                oldValue: { path: pathChange.oldValue },
+                                newValue: { path: pathChange.newValue }
+                            });
+                        }
                     }
                     const hashChanges = change.stateChange.filter(change => change.name === 'hash');
                     if (hashChanges.length === 0) {
@@ -148,8 +162,10 @@ export class RtcContentProvider {
                     // A change in hash signifies that a save occurred on the server-side
                     // (e.g. a collaborator performed the save) - we want to notify the
                     // observers about this change so that they can store the new hash value.
-                    const newPath = (_a = sharedModel.state.path) !== null && _a !== void 0 ? _a : options.path;
-                    const model = await this.get(newPath, { content: false });
+                    // Use the path tracked by the provider. During a rename transaction,
+                    // the state accessor may still expose the old path even though the
+                    // path state change above has already been processed.
+                    const model = await this.get(path, { content: false });
                     this._providerFileChanged.emit({
                         type: 'save',
                         newValue: { ...model, hash: hashChange.newValue },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupyter/docprovider",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "JupyterLab - Document Provider",
   "homepage": "https://github.com/jupyterlab/jupyter-collaboration",
   "bugs": {
@@ -41,7 +41,7 @@
     "watch": "tsc -b --watch"
   },
   "dependencies": {
-    "@jupyter/collaborative-drive": "^5.0.0",
+    "@jupyter/collaborative-drive": "^5.0.1",
     "@jupyter/ydoc": "^4.0.0",
     "@jupyterlab/apputils": "^4.7.0",
     "@jupyterlab/cells": "^4.6.0",