@supernova-studio/client 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/index.mjs

@@ -8074,12 +8074,15 @@ var VersionRoomBaseYDoc = class {
     this.yDoc = yDoc;
   }
   getState() {
+    const groups = this.getGroups();
+    const isLoaded = !!groups.length;
     return {
+      isLoaded,
+      groups,
+      pages: this.getPages(),
       approvals: this.getApprovals(),
-      groups: this.getGroups(),
       groupSnapshots: this.getGroupSnapshots(),
       pageContentHashes: this.getDocumentationPageContentHashes(),
-      pages: this.getPages(),
       pageSnapshots: this.getPageSnapshots(),
       settings: this.getDocumentationInternalSettings()
     };
@@ -12900,24 +12903,34 @@ var BackendVersionRoomYDoc = class {
 var LocalStorage = class {
   constructor() {
     __publicField(this, "pages", /* @__PURE__ */ new Map());
+    __publicField(this, "deletedPageIds", /* @__PURE__ */ new Set());
     __publicField(this, "groups", /* @__PURE__ */ new Map());
   }
-  addPage(page) {
+  setPage(page) {
     if (this.pages.has(page.persistentId)) {
       throw new Error(`Page with id ${page.persistentId} already exists`);
     }
     this.pages.set(page.persistentId, page);
   }
+  deletePage(persistentId) {
+    this.pages.delete(persistentId);
+    this.deletedPageIds.add(persistentId);
+  }
+  tryGetPage(persistentId) {
+    return this.pages.get(persistentId);
+  }
   getPage(persistentId) {
-    const page = this.pages.get(persistentId);
-    if (!page) {
+    const page = this.tryGetPage(persistentId);
+    if (!page)
       throw new Error(`Page with id ${persistentId} doesn't exist`);
-    }
     return page;
   }
   getAllPages() {
     return Array.from(this.pages.values());
   }
+  getAllDeletedPages() {
+    return this.deletedPageIds;
+  }
   removePage(persistentId) {
     this.pages.delete(persistentId);
   }
@@ -12931,19 +12944,42 @@ var DocsStructureRepository = class {
     __publicField(this, "localState", new LocalStorage());
     __publicField(this, "yDoc");
     __publicField(this, "yObserver");
-    __publicField(this, "yState");
+    __publicField(this, "_yState");
+    __publicField(this, "_currentHierarchy");
     __publicField(this, "trxQueue");
     __publicField(this, "hierarchyObservers", /* @__PURE__ */ new Set());
+    __publicField(this, "initCallbacks", /* @__PURE__ */ new Set());
     this.yDoc = yDoc;
-    this.yState = new VersionRoomBaseYDoc(this.yDoc).getState();
     this.yObserver = yDoc.on("update", () => this.onYUpdate());
+    this.onYUpdate();
     this.trxQueue = new TransactionQueue(transactionExecutor);
   }
   //
+  // Convenience
+  //
+  get yState() {
+    const yState = this._yState;
+    if (!yState)
+      throw SupernovaException.shouldNotHappen(`Accessing Y state before it was loaded`);
+    return yState;
+  }
+  //
   // Lifecycle
   //
+  get isInitialized() {
+    return !!this._currentHierarchy;
+  }
+  onInitialized() {
+    if (this.isInitialized)
+      return Promise.resolve();
+    return new Promise((resolve) => {
+      this.initCallbacks.add(resolve);
+    });
+  }
   addHierarchyObserver(observer) {
     this.hierarchyObservers.add(observer);
+    if (this._currentHierarchy)
+      observer(this._currentHierarchy);
   }
   removeHierarchyObserver(observer) {
     this.hierarchyObservers.delete(observer);
@@ -12954,13 +12990,22 @@ var DocsStructureRepository = class {
     this.trxQueue.clear();
   }
   //
+  // Accessors
+  //
+  get currentHierarchy() {
+    const hierarchy = this._currentHierarchy;
+    if (!hierarchy)
+      throw new Error(`Hierarchy cannot be accessed while it's still loading`);
+    return hierarchy;
+  }
+  //
   // Actions
   //
   createPage(input) {
     void this.createPage(input);
   }
   createPagePromise(input) {
-    this.localState.addPage({
+    this.localState.setPage({
       createdAt: /* @__PURE__ */ new Date(),
       parentPersistentId: input.parentPersistentId,
       persistentId: input.persistentId,
@@ -12972,7 +13017,8 @@ var DocsStructureRepository = class {
       sortOrder: this.calculateSortOrder(input.parentPersistentId, input.afterPersistentId),
       designSystemVersionId: ""
     });
-    const promise = this.trxQueue.enqueue({
+    this.refreshHierarchy();
+    return this.trxQueue.enqueue({
       type: "DocumentationPageCreate",
       input: {
         persistentId: input.persistentId,
@@ -12982,27 +13028,104 @@ var DocsStructureRepository = class {
         configuration: input.configuration
       }
     });
-    this.recalculateHierarchy();
-    return promise;
+  }
+  updatePage(update) {
+    void this.updatePagePromise(update);
+  }
+  updatePagePromise(update) {
+    this.updatePageLocally(update);
+    this.refreshHierarchy();
+    return this.trxQueue.enqueue({
+      type: "DocumentationPageUpdate",
+      input: {
+        id: update.persistentId,
+        configuration: update.configuration,
+        title: update.title
+      }
+    });
+  }
+  updatePageLocally(update) {
+    const basePage = this.lookupPage(update.persistentId);
+    this.localState.setPage(this.createLocalPageUpdate(basePage, update));
+  }
+  deletePagePromise(persistentId) {
+    this.lookupPage(persistentId);
+    this.localState.deletePage(persistentId);
+    this.refreshHierarchy();
+    return this.trxQueue.enqueue({
+      type: "DocumentationPageDelete",
+      input: {
+        id: persistentId
+      }
+    });
+  }
+  deletePage(persistentId) {
+    void this.deletePagePromise(persistentId);
+  }
+  createLocalPageUpdate(basePage, update) {
+    const { title, configuration } = update;
+    return {
+      createdAt: basePage.createdAt,
+      data: {
+        configuration: configuration ?? basePage.data.configuration
+      },
+      designSystemVersionId: basePage.designSystemVersionId,
+      meta: { name: title ?? basePage.meta.name },
+      parentPersistentId: basePage.parentPersistentId,
+      persistentId: basePage.persistentId,
+      shortPersistentId: basePage.shortPersistentId,
+      sortOrder: basePage.sortOrder,
+      updatedAt: /* @__PURE__ */ new Date(),
+      slug: basePage.slug
+    };
+  }
+  lookupPage(persistentId) {
+    const localPageToUpdate = this.localState.tryGetPage(persistentId);
+    if (localPageToUpdate)
+      return localPageToUpdate;
+    const remotePage = this.yState.pages.find((p) => p.persistentId === persistentId);
+    if (remotePage)
+      return remotePage;
+    throw SupernovaException.notFound(`Page ${persistentId} was not found`);
   }
   //
   // Reactions
   //
-  recalculateHierarchy() {
+  refreshHierarchy() {
+    const hierarchy = this.calculateHierarchy();
+    if (!hierarchy)
+      return;
+    this._currentHierarchy = hierarchy;
+    this.initCallbacks.forEach((f) => f());
+    this.initCallbacks.clear();
+    this.hierarchyObservers.forEach((o) => o(hierarchy));
+  }
+  calculateHierarchy() {
+    const yState = this._yState;
+    if (!yState)
+      return;
+    const allPagesById = mapByUnique(yState.pages, (p) => p.persistentId);
+    this.localState.getAllPages().forEach((p) => {
+      allPagesById.set(p.persistentId, p);
+    });
+    this.localState.getAllDeletedPages().forEach((id) => allPagesById.delete(id));
     const hierarchy = computeDocsHierarchy({
-      approvals: this.yState.approvals,
-      groups: this.yState.groups,
-      groupSnapshots: this.yState.groupSnapshots,
-      pageContentHashes: this.yState.pageContentHashes,
-      pages: [...this.yState.pages, ...this.localState.getAllPages()],
-      pageSnapshots: this.yState.pageSnapshots,
-      settings: this.yState.settings
+      approvals: yState.approvals,
+      groups: yState.groups,
+      groupSnapshots: yState.groupSnapshots,
+      pageContentHashes: yState.pageContentHashes,
+      pages: Array.from(allPagesById.values()),
+      pageSnapshots: yState.pageSnapshots,
+      settings: yState.settings
     });
-    this.hierarchyObservers.forEach((o) => o(hierarchy));
+    return hierarchy;
   }
   onYUpdate() {
-    this.yState = new VersionRoomBaseYDoc(this.yDoc).getState();
-    this.recalculateHierarchy();
+    const newState = new VersionRoomBaseYDoc(this.yDoc).getState();
+    if (newState.groups.length) {
+      this._yState = newState;
+      this.refreshHierarchy();
+    }
   }
   //
   // Utils