@formicoidea/labre-core 0.45.0 → 0.46.1

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/actions.d.ts

@@ -4,17 +4,28 @@ import type { SelectionPaneNode } from './tree.js';
  * Move `id` so it sits directly ABOVE `above` in the stack — `null` puts it at
  * the bottom of its stack. Answers whether anything was written.
  *
- * The drop target of a drag in a top-first list: dropping a row just over row
- * X means "directly above X". The new `index` is a key between the two
- * neighbours (the same `fractional-indexing` keys `LayerManager` generates), so
- * one field of one model is written and nothing else moves.
- *
- * Refused, with nothing written: a read-only document; a mindmap node (it has
- * no index of its own — the whole mindmap moves as one, as the toolbar's
- * reorder already says); an `above` that is not stacked with `id`; and a
- * target that is where the model already is.
+ * The one-row case of {@link reorderPaneElements}, kept for its callers.
  */
 export declare function reorderPaneElement(std: BlockStdScope, id: string, above: string | null): boolean;
+/**
+ * Move the models `ids`, as one block, so they sit directly ABOVE `above` in
+ * their stack — `null` puts them at the bottom of it. They keep their current
+ * relative z-order, whatever order `ids` lists them in. Answers whether
+ * anything was written.
+ *
+ * The drop target of a drag in a top-first list: dropping rows just over row
+ * X means "directly above X". Each moved model gets a new `index` between its
+ * new neighbours (the same `fractional-indexing` keys `LayerManager`
+ * generates), so only the moved models are written and nothing else shifts.
+ *
+ * Refused, with nothing written: a read-only document; an unknown id; a
+ * mindmap node (it has no index of its own — the whole mindmap moves as one,
+ * as the toolbar's reorder already says); models that are not all stacked
+ * together (a selection spanning two stacks has no one place to land, ADR
+ * 0034); an `above` that is one of them or not stacked with them; and a
+ * target that is where the models already are.
+ */
+export declare function reorderPaneElements(std: BlockStdScope, ids: readonly string[], above: string | null): boolean;
 /**
  * Lock or unlock each model ON ITS OWN. Answers whether anything was written.
  *

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/actions.js

@@ -48,26 +48,53 @@ function stackSiblings(std, model) {
  * Move `id` so it sits directly ABOVE `above` in the stack — `null` puts it at
  * the bottom of its stack. Answers whether anything was written.
  *
- * The drop target of a drag in a top-first list: dropping a row just over row
- * X means "directly above X". The new `index` is a key between the two
- * neighbours (the same `fractional-indexing` keys `LayerManager` generates), so
- * one field of one model is written and nothing else moves.
- *
- * Refused, with nothing written: a read-only document; a mindmap node (it has
- * no index of its own — the whole mindmap moves as one, as the toolbar's
- * reorder already says); an `above` that is not stacked with `id`; and a
- * target that is where the model already is.
+ * The one-row case of {@link reorderPaneElements}, kept for its callers.
  */
 export function reorderPaneElement(std, id, above) {
+    return reorderPaneElements(std, [id], above);
+}
+/**
+ * Move the models `ids`, as one block, so they sit directly ABOVE `above` in
+ * their stack — `null` puts them at the bottom of it. They keep their current
+ * relative z-order, whatever order `ids` lists them in. Answers whether
+ * anything was written.
+ *
+ * The drop target of a drag in a top-first list: dropping rows just over row
+ * X means "directly above X". Each moved model gets a new `index` between its
+ * new neighbours (the same `fractional-indexing` keys `LayerManager`
+ * generates), so only the moved models are written and nothing else shifts.
+ *
+ * Refused, with nothing written: a read-only document; an unknown id; a
+ * mindmap node (it has no index of its own — the whole mindmap moves as one,
+ * as the toolbar's reorder already says); models that are not all stacked
+ * together (a selection spanning two stacks has no one place to land, ADR
+ * 0034); an `above` that is one of them or not stacked with them; and a
+ * target that is where the models already are.
+ */
+export function reorderPaneElements(std, ids, above) {
     if (std.store.readonly)
         return false;
-    const model = gfxModel(std, id);
-    if (!model || id === above)
+    const moving = new Set(ids);
+    if (moving.size === 0)
         return false;
-    if (model.group instanceof MindmapElementModel)
+    if (above !== null && moving.has(above))
         return false;
-    const siblings = stackSiblings(std, model);
-    const others = siblings.filter(other => other !== model);
+    const models = [];
+    for (const id of moving) {
+        const model = gfxModel(std, id);
+        if (!model)
+            return false;
+        if (model.group instanceof MindmapElementModel)
+            return false;
+        models.push(model);
+    }
+    const siblings = stackSiblings(std, models[0]);
+    if (models.some(model => !siblings.includes(model)))
+        return false;
+    // `siblings` is in stacking order, bottom first, so filtering keeps the
+    // moved models' relative order.
+    const moved = siblings.filter(model => moving.has(model.id));
+    const others = siblings.filter(model => !moving.has(model.id));
     let position = 0;
     if (above !== null) {
         const target = others.findIndex(other => other.id === above);
@@ -75,10 +102,13 @@ export function reorderPaneElement(std, id, above) {
             return false;
         position = target + 1;
     }
-    // Already there: the model's current lower neighbour is the target.
-    const current = siblings.indexOf(model);
-    const lowerNow = current > 0 ? siblings[current - 1] : null;
-    if ((lowerNow?.id ?? null) === above)
+    // Already there: the stack would read the same after the move.
+    const after = [
+        ...others.slice(0, position),
+        ...moved,
+        ...others.slice(position),
+    ];
+    if (after.every((model, i) => model === siblings[i]))
         return false;
     const lower = others[position - 1]?.index ?? null;
     const upper = others[position]?.index ?? null;
@@ -86,9 +116,16 @@ export function reorderPaneElement(std, id, above) {
     // this only guards a hand-made document; refusing beats throwing in a drop.
     if (lower !== null && upper !== null && lower >= upper)
         return false;
-    const index = generateKeyBetween(lower, upper);
+    const gfx = std.get(GfxControllerIdentifier);
     std.store.captureSync();
-    std.get(GfxControllerIdentifier).updateElement(model, { index });
+    std.store.transact(() => {
+        let previous = lower;
+        for (const model of moved) {
+            const index = generateKeyBetween(previous, upper);
+            gfx.updateElement(model, { index });
+            previous = index;
+        }
+    });
     return true;
 }
 /**

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/commands.d.ts

@@ -1,19 +1,17 @@
 import type { AnyCommandDescriptor } from '../../../std/index.js';
 import { z } from 'zod';
 export declare const reorderElementParams: z.ZodObject<{
-    /** The element or gfx block to move. */
-    id: z.ZodString;
-    /**
-     * The model it lands directly ABOVE, stacked with it; `null` puts it at the
-     * bottom of its stack.
-     */
+    id: z.ZodOptional<z.ZodString>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     above: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    id: string;
     above: string | null;
+    id?: string | undefined;
+    ids?: string[] | undefined;
 }, {
-    id: string;
     above: string | null;
+    id?: string | undefined;
+    ids?: string[] | undefined;
 }>;
 export type ReorderElementParams = z.infer<typeof reorderElementParams>;
 export declare const lockElementsParams: z.ZodObject<{

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/commands.js

@@ -1,7 +1,7 @@
 import { CanvasLocalVisibility, SelectionPaneProvider, TelemetryProvider, } from '../../../affine-shared/services/index.js';
 import { GfxControllerIdentifier } from '../../../std/gfx/index.js';
 import { z } from 'zod';
-import { renamePaneFrame, renamePaneGroup, reorderPaneElement, setPaneElementsHiddenForEveryone, setPaneElementsLocked, } from './actions.js';
+import { renamePaneFrame, renamePaneGroup, reorderPaneElements, setPaneElementsHiddenForEveryone, setPaneElementsLocked, } from './actions.js';
 import { setUserLayersHiddenForEveryone } from '../user-layers/actions.js';
 import { SelectionPaneModel } from './tree.js';
 /**
@@ -68,13 +68,20 @@ const toggleSelectionPane = {
         });
     },
 };
+/*
+ * "An `id` or a non-empty `ids`" is checked in `run`, not with a zod `refine`:
+ * a refined schema is a `ZodEffects`, which `describeCommandParams` cannot
+ * project, so the agent manifest would lose the whole parameter contract.
+ */
 export const reorderElementParams = z.object({
-    /** The element or gfx block to move. */
-    id: z.string().min(1),
-    /**
-     * The model it lands directly ABOVE, stacked with it; `null` puts it at the
-     * bottom of its stack.
-     */
+    // The element or gfx block to move.
+    id: z.string().min(1).optional(),
+    // Several models of ONE stack, moved as a block in their current relative
+    // order (the selection pane's multi-row drag, ADR 0034). Added beside `id`,
+    // which stays: a caller passing `id` alone is unchanged.
+    ids: z.array(z.string().min(1)).optional(),
+    // The model they land directly ABOVE, stacked with them; `null` puts them
+    // at the bottom of their stack.
     above: z.string().min(1).nullable(),
 });
 const reorderElement = {
@@ -97,7 +104,13 @@ const reorderElement = {
             console.error('canvas.element.reorder: invalid params', parsed.error);
             return;
         }
-        reorderPaneElement(std, parsed.data.id, parsed.data.above);
+        const { id, ids = [], above } = parsed.data;
+        const moving = id === undefined ? ids : [id, ...ids];
+        if (!moving.length) {
+            console.error('canvas.element.reorder: needs an id or ids');
+            return;
+        }
+        reorderPaneElements(std, moving, above);
     },
 };
 export const lockElementsParams = z.object({

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/index.d.ts

@@ -1,3 +1,3 @@
-export { filterSelectionPaneTree, renamePaneFrame, renamePaneGroup, reorderPaneElement, type SelectionPaneFilterTarget, selectionPaneFilterMembers, selectionPaneFilterTargets, setPaneElementsHiddenForEveryone, setPaneElementsLocked, } from './actions.js';
+export { filterSelectionPaneTree, renamePaneFrame, renamePaneGroup, reorderPaneElement, reorderPaneElements, type SelectionPaneFilterTarget, selectionPaneFilterMembers, selectionPaneFilterTargets, setPaneElementsHiddenForEveryone, setPaneElementsLocked, } from './actions.js';
 export { type HideForEveryoneParams, hideForEveryoneParams, type HideLocalParams, hideLocalParams, type LockElementsParams, lockElementsParams, type RenameGroupParams, renameGroupParams, type ReorderElementParams, reorderElementParams, selectionPaneCommands, } from './commands.js';
 export { buildSelectionPaneTree, DEFAULT_LAYER_ID, paneContainerOf, paneLayersOf, type SelectionPaneLayers, type SelectionPaneNode, SelectionPaneModel, selectionPaneTree, } from './tree.js';

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/index.js

@@ -1,3 +1,3 @@
-export { filterSelectionPaneTree, renamePaneFrame, renamePaneGroup, reorderPaneElement, selectionPaneFilterMembers, selectionPaneFilterTargets, setPaneElementsHiddenForEveryone, setPaneElementsLocked, } from './actions.js';
+export { filterSelectionPaneTree, renamePaneFrame, renamePaneGroup, reorderPaneElement, reorderPaneElements, selectionPaneFilterMembers, selectionPaneFilterTargets, setPaneElementsHiddenForEveryone, setPaneElementsLocked, } from './actions.js';
 export { hideForEveryoneParams, hideLocalParams, lockElementsParams, renameGroupParams, reorderElementParams, selectionPaneCommands, } from './commands.js';
 export { buildSelectionPaneTree, DEFAULT_LAYER_ID, paneContainerOf, paneLayersOf, SelectionPaneModel, selectionPaneTree, } from './tree.js';

package/dist/_pkgs/affine-components/portal/portal.d.ts

@@ -17,7 +17,7 @@ import { LitElement, type TemplateResult } from 'lit';
  */
 export declare class Portal extends LitElement {
     private _portalRoot;
-    createRenderRoot(): HTMLDivElement | ShadowRoot;
+    createRenderRoot(): ShadowRoot | HTMLDivElement;
     disconnectedCallback(): void;
     render(): TemplateResult | undefined;
     accessor container: HTMLElement;

package/dist/_pkgs/affine-foundation/view.d.ts

@@ -23,13 +23,13 @@ declare const optionsSchema: z.ZodObject<{
         style: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         style: string;
-        font: string;
         url: string;
+        font: string;
         weight: string;
     }, {
         style: string;
-        font: string;
         url: string;
+        font: string;
         weight: string;
     }>, "many">>;
     telemetry: z.ZodOptional<z.ZodType<TelemetryService, z.ZodTypeDef, TelemetryService>>;
@@ -42,8 +42,8 @@ declare const optionsSchema: z.ZodObject<{
     } | undefined;
     fontConfig?: {
         style: string;
-        font: string;
         url: string;
+        font: string;
         weight: string;
     }[] | undefined;
     telemetry?: TelemetryService | undefined;
@@ -56,8 +56,8 @@ declare const optionsSchema: z.ZodObject<{
     } | undefined;
     fontConfig?: {
         style: string;
-        font: string;
         url: string;
+        font: string;
         weight: string;
     }[] | undefined;
     telemetry?: TelemetryService | undefined;
@@ -87,13 +87,13 @@ export declare class FoundationViewExtension extends ViewExtensionProvider<Found
             style: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             style: string;
-            font: string;
             url: string;
+            font: string;
             weight: string;
         }, {
             style: string;
-            font: string;
             url: string;
+            font: string;
             weight: string;
         }>, "many">>;
         telemetry: z.ZodOptional<z.ZodType<TelemetryService, z.ZodTypeDef, TelemetryService>>;
@@ -106,8 +106,8 @@ export declare class FoundationViewExtension extends ViewExtensionProvider<Found
         } | undefined;
         fontConfig?: {
             style: string;
-            font: string;
             url: string;
+            font: string;
             weight: string;
         }[] | undefined;
         telemetry?: TelemetryService | undefined;
@@ -120,8 +120,8 @@ export declare class FoundationViewExtension extends ViewExtensionProvider<Found
         } | undefined;
         fontConfig?: {
             style: string;
-            font: string;
             url: string;
+            font: string;
             weight: string;
         }[] | undefined;
         telemetry?: TelemetryService | undefined;

package/dist/_pkgs/affine-fragment-frame-panel/body/frame-panel-body.d.ts

@@ -11,8 +11,15 @@ export declare class FramePanelBody extends FramePanelBody_base {
      */
     private readonly _clickBlank;
     private _docDisposables;
-    private _frameElementHeight;
     private _frameItems;
+    /** The side panels' one reorder gesture (ADR 0034), made on connect. */
+    private _reorder;
+    /** The card a press landed on: what a pick-up picks up. */
+    private _pressed;
+    /** The dragged cards' copies following the pointer, top one last. */
+    private _ghosts;
+    /** The list's `gap`, read once at the pick-up: the drop line sits in it. */
+    private _listGap;
     private _indicatorTranslateY;
     private _lastEdgelessRootId;
     private get _gfx();
@@ -20,10 +27,36 @@ export declare class FramePanelBody extends FramePanelBody_base {
     private readonly _updateFrameItems;
     get frames(): FrameBlockModel[];
     get viewportPadding(): [number, number, number, number];
+    private _createReorderDrag;
+    /** The cards on screen, in presentation order. */
+    private _cards;
+    /** A press on a card: the controller decides whether it becomes a drag. */
     private _drag;
+    /**
+     * The press became a drag. The pressed card is selected if it was not
+     * (shift adds it to the selection), and every selected card moves: their
+     * copies — the last two, the top one counting them — follow the pointer,
+     * and the cards themselves stay in place as placeholders.
+     */
+    private _pickUp;
+    /**
+     * A release at the gap `gap` puts the selected cards right before the first
+     * card at or after it that does not move, or at the end. The line sits in
+     * the middle of the list's gap: above the card under the gap, or under the
+     * last card — the frame panel's own drag used to draw that last one at 0.
+     */
+    private _dropAt;
     private _fitToElement;
     private _renderEmptyContent;
     private _renderFrameList;
+    /**
+     * Move the selected cards, as one block, right before the frame `before`
+     * (`null` = at the end; `_dropAt` picks it). The write is
+     * `canvas.frame.reorder` (ADR 0034): the read-only refusal, the no-op check
+     * and the one undo step live in its action, run through the imported
+     * descriptor so the panel reorders in page mode too, where the command is
+     * not registered.
+     */
     private _reorderFrames;
     private _setDocDisposables;
     private _updateFrames;
@@ -34,7 +67,6 @@ export declare class FramePanelBody extends FramePanelBody_base {
     updated(_changedProperties: PropertyValues): void;
     private accessor _dragging;
     private accessor _selected;
-    accessor domHost: Document | HTMLElement;
     accessor editorHost: EditorHost;
     accessor fitPadding: number[];
     accessor frameListContainer: HTMLElement;