@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/_pkgs/affine-gfx-group/command/group-api.js

@@ -1,6 +1,68 @@
 import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
 import { MindmapElementModel, } from '../../affine-model/index.js';
-import { GfxControllerIdentifier } from '../../std/gfx/index.js';
+import { batchAddChildren, batchRemoveChildren, generateKeyBetween, generateNKeysBetween, GfxControllerIdentifier, measureOperation, } from '../../std/gfx/index.js';
+/**
+ * Every element that sits at the root of the board, in painting order.
+ */
+const getTopLevelOrderedElements = (gfx) => {
+    const topLevelElements = gfx.layer.layers.reduce((elements, layer) => {
+        layer.elements.forEach(element => {
+            if (element.group === null) {
+                elements.push(element);
+            }
+        });
+        return elements;
+    }, []);
+    topLevelElements.sort((a, b) => gfx.layer.compare(a, b));
+    return topLevelElements;
+};
+/**
+ * The indexes the children of an ungrouped group should take: the slot the
+ * group itself occupied, so that everything it contained stays where the user
+ * last saw it instead of jumping to the top of the stack.
+ *
+ * The fallbacks go from "the exact slot" to "always valid", because the
+ * interval between the two siblings can be unusable — a document written by an
+ * older version, or two siblings sharing an index.
+ */
+const buildUngroupIndexes = (orderedElements, afterIndex, beforeIndex, fallbackAnchorIndex) => {
+    if (orderedElements.length === 0) {
+        return [];
+    }
+    const count = orderedElements.length;
+    const tryGenerateN = (left, right) => {
+        try {
+            const generated = generateNKeysBetween(left, right, count);
+            return generated.length === count ? generated : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const tryGenerateOneByOne = (left, right) => {
+        try {
+            let cursor = left;
+            return orderedElements.map(() => {
+                cursor = generateKeyBetween(cursor, right);
+                return cursor;
+            });
+        }
+        catch {
+            return null;
+        }
+    };
+    // Preferred: keep ungrouped children in the original group slot.
+    return (tryGenerateN(afterIndex, beforeIndex) ??
+        // Fallback: ignore the upper bound when legacy/broken data has reversed interval.
+        tryGenerateN(afterIndex, null) ??
+        // Fallback: use group index as anchor when sibling interval is unavailable.
+        tryGenerateN(fallbackAnchorIndex, null) ??
+        // Last resort: always valid.
+        tryGenerateN(null, null) ??
+        // Defensive fallback for unexpected library behavior.
+        tryGenerateOneByOne(null, null) ??
+        []);
+};
 export const createGroupCommand = (ctx, next) => {
     const { std, elements } = ctx;
     const gfx = std.get(GfxControllerIdentifier);
@@ -20,73 +82,99 @@ export const createGroupCommand = (ctx, next) => {
     next({ groupId });
 };
 export const createGroupFromSelectedCommand = (ctx, next) => {
-    const { std } = ctx;
-    const gfx = std.get(GfxControllerIdentifier);
-    const { selection, surface } = gfx;
-    if (!surface) {
-        return;
-    }
-    if (selection.selectedElements.length === 0 ||
-        !selection.selectedElements.every(element => element.group === selection.firstElement.group &&
-            !(element.group instanceof MindmapElementModel))) {
-        return;
-    }
-    const parent = selection.firstElement.group;
-    if (parent !== null) {
-        selection.selectedElements.forEach(element => {
-            // oxlint-disable-next-line unicorn/prefer-dom-node-remove
-            parent.removeChild(element);
+    measureOperation('edgeless:create-group-from-selected', () => {
+        const { std } = ctx;
+        const gfx = std.get(GfxControllerIdentifier);
+        const { selection, surface } = gfx;
+        if (!surface) {
+            return;
+        }
+        // Guarded BEFORE the child rewrites below: they write through raw
+        // transactions, and `crud.addElement` would refuse afterwards — leaving the
+        // selection orphaned from its parent group on a readonly board.
+        if (std.store.readonly) {
+            return;
+        }
+        if (selection.selectedElements.length === 0 ||
+            !selection.selectedElements.every(element => element.group === selection.firstElement.group &&
+                !(element.group instanceof MindmapElementModel))) {
+            return;
+        }
+        const parent = selection.firstElement.group;
+        const selectedElements = [...selection.selectedElements];
+        let groupId;
+        // One transaction for the whole regrouping, so a single undo takes the
+        // board back to where it was.
+        std.store.transact(() => {
+            const [_, result] = std.command.exec(createGroupCommand, {
+                elements: selectedElements,
+            });
+            if (!result.groupId) {
+                return;
+            }
+            groupId = result.groupId;
+            const group = surface.getElementById(groupId);
+            if (parent !== null && group) {
+                batchRemoveChildren(parent, selectedElements);
+                batchAddChildren(parent, [group]);
+            }
         });
-    }
-    const [_, result] = std.command.exec(createGroupCommand, {
-        elements: selection.selectedElements,
-    });
-    if (!result.groupId) {
-        return;
-    }
-    const group = surface.getElementById(result.groupId);
-    if (parent !== null && group) {
-        parent.addChild(group);
-    }
-    selection.set({
-        editing: false,
-        elements: [result.groupId],
+        if (!groupId) {
+            return;
+        }
+        selection.set({
+            editing: false,
+            elements: [groupId],
+        });
+        next({ groupId });
     });
-    next({ groupId: result.groupId });
 };
 export const ungroupCommand = (ctx, next) => {
-    const { std, group } = ctx;
-    const gfx = std.get(GfxControllerIdentifier);
-    const { selection } = gfx;
-    const parent = group.group;
-    const elements = group.childElements;
-    if (group instanceof MindmapElementModel) {
-        return;
-    }
-    if (parent !== null) {
-        // oxlint-disable-next-line unicorn/prefer-dom-node-remove
-        parent.removeChild(group);
-    }
-    elements.forEach(element => {
-        // oxlint-disable-next-line unicorn/prefer-dom-node-remove
-        group.removeChild(element);
-    });
-    // keep relative index order of group children after ungroup
-    elements
-        .sort((a, b) => gfx.layer.compare(a, b))
-        .forEach(element => {
+    measureOperation('edgeless:ungroup', () => {
+        const { std, group } = ctx;
+        const gfx = std.get(GfxControllerIdentifier);
+        const { selection } = gfx;
+        const parent = group.group;
+        const elements = [...group.childElements];
+        if (group instanceof MindmapElementModel) {
+            return;
+        }
+        // The child rewrites and the index rewrites below are raw transactions.
+        if (std.store.readonly) {
+            return;
+        }
+        const orderedElements = [...elements].sort((a, b) => gfx.layer.compare(a, b));
+        const siblings = parent
+            ? [...parent.childElements].sort((a, b) => gfx.layer.compare(a, b))
+            : getTopLevelOrderedElements(gfx);
+        const groupPosition = siblings.indexOf(group);
+        const beforeSiblingIndex = groupPosition > 0 ? (siblings[groupPosition - 1]?.index ?? null) : null;
+        const afterSiblingIndex = groupPosition === -1
+            ? null
+            : (siblings[groupPosition + 1]?.index ?? null);
+        const nextIndexes = buildUngroupIndexes(orderedElements, beforeSiblingIndex, afterSiblingIndex, group.index);
+        // One transaction for the whole ungrouping: opening one per child made a
+        // single undo put a single child back.
         std.store.transact(() => {
-            element.index = gfx.layer.generateIndex();
+            if (parent !== null) {
+                batchRemoveChildren(parent, [group]);
+            }
+            batchRemoveChildren(group, elements);
+            // keep relative index order of group children after ungroup
+            orderedElements.forEach((element, idx) => {
+                const index = nextIndexes[idx];
+                if (element.index !== index) {
+                    element.index = index;
+                }
+            });
+            if (parent !== null) {
+                batchAddChildren(parent, orderedElements);
+            }
         });
-    });
-    if (parent !== null) {
-        elements.forEach(element => {
-            parent.addChild(element);
+        selection.set({
+            editing: false,
+            elements: orderedElements.map(ele => ele.id),
         });
-    }
-    selection.set({
-        editing: false,
-        elements: elements.map(ele => ele.id),
+        next();
     });
-    next();
 };

package/dist/_pkgs/affine-gfx-group/text/edgeless-group-title-editor.js

@@ -33,6 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { DefaultTool } from '../../affine-block-surface/index.js';
+import { toOverlayCoord } from '../../affine-shared/utils/index.js';
 import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
 import { Bound } from '../../global/gfx/index.js';
 import { WithDisposable } from '../../global/lit/index.js';
@@ -156,7 +157,9 @@ let EdgelessGroupTitleEditor = (() => {
             }
             const viewport = this.gfx.viewport;
             const bound = Bound.deserialize(this.group.externalXYWH);
-            const [x, y] = viewport.toViewCoord(bound.x, bound.y);
+            // The editor is mounted inside the container the host may have scaled, so
+            // it is placed the way the title it replaces is, not in screen pixels.
+            const [x, y] = toOverlayCoord(viewport, bound.x, bound.y);
             const inlineEditorStyle = styleMap({
                 transformOrigin: 'top left',
                 borderRadius: '2px',

package/dist/_pkgs/affine-gfx-mindmap/adapter/markdown/index.js

@@ -1,6 +1,6 @@
 import { ElementToMarkdownAdapterExtension } from '../../../affine-block-surface/index.js';
 import { getShapeText } from '../../../affine-gfx-shape/index.js';
-import { buildMindMapTree, } from '../../../affine-model/index.js';
+import { buildMindMapTree } from '../../../affine-model/index.js';
 export const mindmapToMarkdownAdapterMatcher = ElementToMarkdownAdapterExtension({
     name: 'mindmap',
     match: elementModel => elementModel.type === 'mindmap',

package/dist/_pkgs/affine-gfx-mindmap/adapter/utils.js

@@ -1,5 +1,5 @@
 import { getShapeText } from '../../affine-gfx-shape/index.js';
-import { buildMindMapTree, } from '../../affine-model/index.js';
+import { buildMindMapTree } from '../../affine-model/index.js';
 /**
  * traverse the mindMapTree and construct the content string
  * like: