@qnote/q-ai-note 1.0.21 → 1.0.22

package/dist/web/app.js

@@ -1209,20 +1209,27 @@ function renderWorkTree() {
       if (fromIdx < 0) return;
       const toIdx = fromIdx + delta;
       if (toIdx < 0 || toIdx >= siblings.length) return;
-      const peers = siblings.filter((item) => item.id !== nodeId);
-      const left = peers[toIdx - 1] || null;
-      const right = peers[toIdx] || null;
+      const reordered = [...siblings];
+      const [movedNode] = reordered.splice(fromIdx, 1);
+      reordered.splice(toIdx, 0, movedNode);
+      const left = reordered[toIdx - 1] || null;
+      const right = reordered[toIdx + 1] || null;
       const nextOrderKey = rankBetween(getNodeOrderKey(left, 'order_key'), getNodeOrderKey(right, 'order_key'));
-      if (nextOrderKey === getNodeOrderKey(node, 'order_key')) return;
-      await apiRequest(`${API_BASE}/items/${nodeId}`, {
-        method: 'PUT',
-        body: JSON.stringify({
-          extra_data: {
-            ...(node.extra_data || {}),
-            order_key: nextOrderKey,
-          },
-        }),
-      });
+      const canDirectUpdate = nextOrderKey !== getNodeOrderKey(node, 'order_key')
+        && isOrderKeyBetween(getNodeOrderKey(left, 'order_key'), getNodeOrderKey(right, 'order_key'), nextOrderKey);
+      if (canDirectUpdate) {
+        await apiRequest(`${API_BASE}/items/${nodeId}`, {
+          method: 'PUT',
+          body: JSON.stringify({
+            extra_data: {
+              ...(node.extra_data || {}),
+              order_key: nextOrderKey,
+            },
+          }),
+        });
+      } else {
+        await persistSiblingOrderByList(reordered, parentId);
+      }
       await loadSandbox(state.currentSandbox.id);
     },
     onReorderSiblings: treeReadonly ? undefined : async (dragNodeId, targetNodeId, position) => {
@@ -1243,19 +1250,30 @@ function renderWorkTree() {
       const targetIndex = siblings.findIndex((item) => item.id === targetNodeId);
       if (targetIndex < 0) return;
       const insertIndex = position === 'after' ? targetIndex + 1 : targetIndex;
-      const left = siblings[insertIndex - 1] || null;
-      const right = siblings[insertIndex] || null;
+      const reordered = [...siblings];
+      reordered.splice(insertIndex, 0, dragNode);
+      const left = reordered[insertIndex - 1] || null;
+      const right = reordered[insertIndex + 1] || null;
       const nextOrderKey = rankBetween(getNodeOrderKey(left, 'order_key'), getNodeOrderKey(right, 'order_key'));
-      await apiRequest(`${API_BASE}/items/${dragNodeId}`, {
-        method: 'PUT',
-        body: JSON.stringify({
-          parent_id: nextParentId,
-          extra_data: {
-            ...(dragNode.extra_data || {}),
-            order_key: nextOrderKey,
-          },
-        }),
-      });
+      const canDirectUpdate = isOrderKeyBetween(getNodeOrderKey(left, 'order_key'), getNodeOrderKey(right, 'order_key'), nextOrderKey)
+        && (
+          nextOrderKey !== getNodeOrderKey(dragNode, 'order_key')
+          || (dragNode.parent_id || null) !== nextParentId
+        );
+      if (canDirectUpdate) {
+        await apiRequest(`${API_BASE}/items/${dragNodeId}`, {
+          method: 'PUT',
+          body: JSON.stringify({
+            parent_id: nextParentId,
+            extra_data: {
+              ...(dragNode.extra_data || {}),
+              order_key: nextOrderKey,
+            },
+          }),
+        });
+      } else {
+        await persistSiblingOrderByList(reordered, nextParentId, dragNodeId);
+      }
       await loadSandbox(state.currentSandbox.id);
     },
     onReorderLanes: treeReadonly ? undefined : async (dragRootId, targetRootId, position = 'before') => {
@@ -1409,6 +1427,55 @@ function rankBetween(left, right) {
   return `${prefix}${ORDER_ALPHABET[Math.floor(ORDER_BASE / 2)]}`;
 }
 
+function encodeOrderIndex(index, width = 6) {
+  let value = Number.isFinite(index) ? Math.max(0, Math.floor(index)) : 0;
+  let encoded = '';
+  do {
+    const digit = value % ORDER_BASE;
+    encoded = `${ORDER_ALPHABET[digit]}${encoded}`;
+    value = Math.floor(value / ORDER_BASE);
+  } while (value > 0);
+  return encoded.padStart(width, ORDER_ALPHABET[0]);
+}
+
+function isOrderKeyBetween(leftKey, rightKey, candidateKey) {
+  const left = String(leftKey || '');
+  const right = String(rightKey || '');
+  const candidate = String(candidateKey || '');
+  if (!candidate) return false;
+  if (left && candidate <= left) return false;
+  if (right && candidate >= right) return false;
+  return true;
+}
+
+async function persistSiblingOrderByList(orderedItems, nextParentId = null, movedNodeId = '') {
+  const items = Array.isArray(orderedItems) ? orderedItems : [];
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (!item?.id) continue;
+    const targetKey = encodeOrderIndex((index + 1) * 1024);
+    const currentKey = getNodeOrderKey(item, 'order_key');
+    const isMovedNode = Boolean(movedNodeId) && String(item.id) === String(movedNodeId);
+    const currentParentId = item.parent_id || null;
+    const needsParentUpdate = isMovedNode && currentParentId !== nextParentId;
+    const needsOrderUpdate = currentKey !== targetKey;
+    if (!needsParentUpdate && !needsOrderUpdate) continue;
+    const body = {
+      extra_data: {
+        ...(item.extra_data || {}),
+        order_key: targetKey,
+      },
+    };
+    if (needsParentUpdate) {
+      body.parent_id = nextParentId;
+    }
+    await apiRequest(`${API_BASE}/items/${item.id}`, {
+      method: 'PUT',
+      body: JSON.stringify(body),
+    });
+  }
+}
+
 function getNodeOrderKey(item, keyName = 'order_key') {
   return String(item?.extra_data?.[keyName] || '').trim();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qnote/q-ai-note",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "type": "module",
   "description": "AI-assisted personal work sandbox and diary system",
   "main": "dist/server/index.js",