@formicoidea/labre-core 0.42.0 → 0.45.0

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

@@ -0,0 +1,248 @@
+import { FrameBlockModel, GroupElementModel, MindmapElementModel, } from '../../../affine-model/index.js';
+import { compareLayer, GfxBlockElementModel, GfxControllerIdentifier, GfxPrimitiveElementModel, isStoredHiddenForEveryone, } from '../../../std/gfx/index.js';
+import { generateKeyBetween } from 'fractional-indexing';
+import * as Y from 'yjs';
+/**
+ * The selection pane's writes (ADR 0031, stage 2). Every one of them:
+ *
+ * - refuses on a read-only document before reading anything else;
+ * - writes nothing when nothing would change — an unchanged write is an empty
+ *   undo step, and an undo that "does nothing" reads as a broken undo;
+ * - takes ONE `captureSync()` first, so one gesture in the pane is one undo
+ *   step, whatever it touched;
+ * - writes through `gfx.updateElement`, which is `surface.updateElement` for an
+ *   element and `store.updateBlock` for a block — never a `Y.Map` directly.
+ *
+ * They are reached through the `canvas.element.*` / `canvas.group.rename`
+ * commands, so a host's own pane gets the same guards by calling `runCommand`.
+ */
+function gfxModel(std, id) {
+    const model = std.get(GfxControllerIdentifier).getElementById(id);
+    return model instanceof GfxPrimitiveElementModel ||
+        model instanceof GfxBlockElementModel
+        ? model
+        : null;
+}
+/**
+ * The models a reorder compares against: those sharing the moved model's RAW
+ * `group` — a group, a mindmap, a frame, or none.
+ *
+ * Raw and not the pane's container on purpose: an `index` only orders a model
+ * among the models its group-like ancestor stacks together (`compare` puts a
+ * frame's members right above the frame), so a key computed against a wider
+ * list could be written and still not move the row.
+ */
+function stackSiblings(std, model) {
+    const group = model.group;
+    const gfx = std.get(GfxControllerIdentifier);
+    // With user layers a model is restacked within its layer (ADR 0031 §4):
+    // a key computed against another layer's neighbours would not move it.
+    const userLayers = gfx.surface?.userLayers;
+    const layer = userLayers?.ranks ? userLayers.effectiveLayerOf(model) : null;
+    return gfx.gfxElements
+        .filter(other => other.group === group &&
+        (layer === null || userLayers.effectiveLayerOf(other) === layer))
+        .sort(compareLayer);
+}
+/**
+ * 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.
+ */
+export function reorderPaneElement(std, id, above) {
+    if (std.store.readonly)
+        return false;
+    const model = gfxModel(std, id);
+    if (!model || id === above)
+        return false;
+    if (model.group instanceof MindmapElementModel)
+        return false;
+    const siblings = stackSiblings(std, model);
+    const others = siblings.filter(other => other !== model);
+    let position = 0;
+    if (above !== null) {
+        const target = others.findIndex(other => other.id === above);
+        if (target === -1)
+            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)
+        return false;
+    const lower = others[position - 1]?.index ?? null;
+    const upper = others[position]?.index ?? null;
+    // Two equal keys cannot be split. `generateIndex` never produces them, so
+    // 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);
+    std.store.captureSync();
+    std.get(GfxControllerIdentifier).updateElement(model, { index });
+    return true;
+}
+/**
+ * Lock or unlock each model ON ITS OWN. Answers whether anything was written.
+ *
+ * Deliberately not the contextual toolbar's lock: that one, given several
+ * elements, wraps them into a new group and locks the group — a structural
+ * edit a row's padlock must never make. Here each row keeps its place in the
+ * tree; only `lockedBySelf` changes, and only where it differs.
+ */
+export function setPaneElementsLocked(std, ids, locked) {
+    if (std.store.readonly)
+        return false;
+    const targets = ids
+        .map(id => gfxModel(std, id))
+        .filter((model) => model !== null && (model.lockedBySelf === true) !== locked);
+    if (!targets.length)
+        return false;
+    const gfx = std.get(GfxControllerIdentifier);
+    std.store.captureSync();
+    std.store.transact(() => {
+        for (const model of targets) {
+            gfx.updateElement(model, { lockedBySelf: locked });
+        }
+    });
+    return true;
+}
+/**
+ * Hide models for EVERYONE, or show them again (ADR 0031 §7). Answers how
+ * many models were written.
+ *
+ * Writes the stored `hiddenForEveryone` — never `hidden`, which mindmap
+ * collapse owns. Hiding writes `true`; showing REMOVES the key (`clearField`
+ * on an element, the props proxy's delete on a block), never stores `false`,
+ * so an unhidden document is byte-identical to one never hidden. Models
+ * already in the asked state are skipped, so a gesture that changes nothing
+ * writes nothing and pushes no undo step; the rest go in one transaction
+ * after one `captureSync()`.
+ */
+export function setPaneElementsHiddenForEveryone(std, ids, hidden) {
+    if (std.store.readonly)
+        return 0;
+    const targets = ids
+        .map(id => gfxModel(std, id))
+        .filter((model) => model !== null && isStoredHiddenForEveryone(model) !== hidden);
+    if (!targets.length)
+        return 0;
+    const gfx = std.get(GfxControllerIdentifier);
+    std.store.captureSync();
+    std.store.transact(() => {
+        for (const model of targets) {
+            if (hidden) {
+                gfx.updateElement(model, { hiddenForEveryone: true });
+            }
+            else if (model instanceof GfxPrimitiveElementModel) {
+                model.clearField('hiddenForEveryone');
+            }
+            else {
+                // The props proxy deletes the `prop:` key (ADR 0031 §7).
+                delete model.props.hiddenForEveryone;
+            }
+        }
+    });
+    return targets.length;
+}
+/**
+ * Rename a group through its existing stored `title`. Answers whether
+ * anything was written. An empty or unchanged title writes nothing.
+ */
+export function renamePaneGroup(std, id, title) {
+    if (std.store.readonly)
+        return false;
+    const model = gfxModel(std, id);
+    if (!(model instanceof GroupElementModel))
+        return false;
+    const next = title.trim();
+    if (!next || next === model.title.toString())
+        return false;
+    std.store.captureSync();
+    std
+        .get(GfxControllerIdentifier)
+        .updateElement(model, { title: new Y.Text(next) });
+    return true;
+}
+/**
+ * Rename a frame through its existing stored `title`, edited in place — the
+ * `Text` the frame's own title editor binds to, never a replaced one, so an
+ * open title editor keeps its binding. Answers whether anything was written.
+ * An empty or unchanged title writes nothing.
+ */
+export function renamePaneFrame(std, id, title) {
+    if (std.store.readonly)
+        return false;
+    const model = gfxModel(std, id);
+    if (!(model instanceof FrameBlockModel))
+        return false;
+    const next = title.trim();
+    const text = model.props.title;
+    if (!next || next === text.toString())
+        return false;
+    std.store.captureSync();
+    text.replace(0, text.length, next);
+    return true;
+}
+/** The frames on the canvas, top first — what the pane's filter offers. */
+export function selectionPaneFilterTargets(std) {
+    return std
+        .get(GfxControllerIdentifier)
+        .gfxElements.filter(model => model instanceof FrameBlockModel)
+        .sort((a, b) => compareLayer(b, a))
+        .map(model => ({ id: model.id, kind: 'frame' }));
+}
+/**
+ * The ids a frame filter keeps: the frame itself — a row like any other, so
+ * the list keeps showing what it is filtered by (ADR 0031, amendments) — its
+ * `childElementIds` and their descendants. `null` for an id that is not a
+ * frame.
+ */
+export function selectionPaneFilterMembers(std, targetId) {
+    const target = std.get(GfxControllerIdentifier).getElementById(targetId);
+    if (!(target instanceof FrameBlockModel))
+        return null;
+    const ids = new Set([target.id]);
+    for (const child of target.childElements) {
+        ids.add(child.id);
+        if ('descendantElements' in child) {
+            for (const descendant of child
+                .descendantElements) {
+                ids.add(descendant.id);
+            }
+        }
+    }
+    return ids;
+}
+/**
+ * The tree narrowed to `members`: a row is kept when it is a member or holds
+ * one, so a group reaching into a frame stays as the path to its member.
+ *
+ * A LAYER row is always kept, its children narrowed (ADR 0031, amendments): a
+ * layer is where new elements land and where a drop goes, not something a
+ * frame holds, and a layer created under a filter that hid it read as a
+ * "New layer" button doing nothing.
+ */
+export function filterSelectionPaneTree(nodes, members) {
+    const kept = [];
+    for (const node of nodes) {
+        const children = node.children
+            ? filterSelectionPaneTree(node.children, members)
+            : undefined;
+        if (node.kind === 'layer' ||
+            members.has(node.id) ||
+            (children && children.length)) {
+            kept.push(children ? { ...node, children } : node);
+        }
+    }
+    return kept;
+}

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

@@ -0,0 +1,82 @@
+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.
+     */
+    above: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    above: string | null;
+}, {
+    id: string;
+    above: string | null;
+}>;
+export type ReorderElementParams = z.infer<typeof reorderElementParams>;
+export declare const lockElementsParams: z.ZodObject<{
+    /**
+     * The models to act on. Omitted: the current canvas selection. Each one is
+     * locked ON ITS OWN — never wrapped into a group.
+     */
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ids?: string[] | undefined;
+}, {
+    ids?: string[] | undefined;
+}>;
+export type LockElementsParams = z.infer<typeof lockElementsParams>;
+export declare const renameGroupParams: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+}, {
+    id: string;
+    title: string;
+}>;
+export type RenameGroupParams = z.infer<typeof renameGroupParams>;
+export declare const hideLocalParams: z.ZodObject<{
+    /** The models to act on. Omitted: the current canvas selection. */
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Whole user layers to act on instead (ADR 0031 stage 7). When given,
+     * `ids` and the selection are ignored.
+     */
+    layerIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** `false` shows them again. Omitted: hide. */
+    hidden: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    hidden?: boolean | undefined;
+    ids?: string[] | undefined;
+    layerIds?: string[] | undefined;
+}, {
+    hidden?: boolean | undefined;
+    ids?: string[] | undefined;
+    layerIds?: string[] | undefined;
+}>;
+export type HideLocalParams = z.infer<typeof hideLocalParams>;
+export declare const hideForEveryoneParams: z.ZodObject<{
+    /** The models to act on. Omitted: the current canvas selection. */
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Whole user layers to act on instead: `hidden: true` on each record, one
+     * write per layer, never one per member (ADR 0031 §7).
+     */
+    layerIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** `false` shows them again, for everyone. Omitted: hide. */
+    hidden: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    hidden?: boolean | undefined;
+    ids?: string[] | undefined;
+    layerIds?: string[] | undefined;
+}, {
+    hidden?: boolean | undefined;
+    ids?: string[] | undefined;
+    layerIds?: string[] | undefined;
+}>;
+export type HideForEveryoneParams = z.infer<typeof hideForEveryoneParams>;
+export declare const selectionPaneCommands: AnyCommandDescriptor[];

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

@@ -0,0 +1,342 @@
+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 { setUserLayersHiddenForEveryone } from '../user-layers/actions.js';
+import { SelectionPaneModel } from './tree.js';
+/**
+ * The selection pane's commands (ADR 0031, stage 2), `owner: 'core'`: the pane
+ * belongs to no framework, and `'core'` owners are exempt from the id-prefix
+ * rule (ADR 0008).
+ *
+ * The pane's own rows invoke the parameterised ones through `runCommand`, and
+ * so does a host's pane: the read-only refusal lives in the action, once.
+ */
+/** How the user reached the pane, as `SelectionPaneOpened` reports it. */
+function openedFrom(invocation) {
+    if (invocation.surface === 'shortcut')
+        return 'shortcut';
+    if (invocation.source === 'toolbar:general')
+        return 'toolbar';
+    // The palette and the agent both invoke the command by name.
+    return 'palette';
+}
+const paneService = (std) => std.getOptional(SelectionPaneProvider);
+/**
+ * Open the pane, or put the library's own panel away when it is the one on
+ * screen.
+ *
+ * Toggling needs a state the two-verb seam does not carry, so it reads the
+ * library panel's own (`SelectionPaneModel.open$`). A host that replaced the
+ * panel keeps its open state to itself: for it, the toggle always opens, and
+ * closing is the host's own control.
+ *
+ * Emits `SelectionPaneOpened` from its body, and only when it opens — see the
+ * telemetry README for why this command self-emits like `doc.copyLink`.
+ *
+ * Opening writes nothing, so no read-only guard: the pane is how a reader finds
+ * what is on a canvas they cannot edit.
+ */
+const toggleSelectionPane = {
+    id: 'canvas.selectionPane.toggle',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.selection-pane.toggle',
+    labelFallback: 'Selection pane',
+    descriptionKey: 'com.labre.command.canvas.selection-pane.toggle.description',
+    descriptionFallback: 'List the elements of the canvas by stacking order, to select, lock, rename or reorder them.',
+    keywords: ['layers', 'objects', 'z-order', 'stack'],
+    surfaces: ['palette', 'agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    // `null` from `SelectionPaneExtension(null)` switches the pane off; the
+    // command then disappears rather than opening nothing.
+    when: std => !!paneService(std),
+    run: (std, invocation) => {
+        const service = paneService(std);
+        if (!service)
+            return;
+        const model = std.getOptional(SelectionPaneModel);
+        if (model?.open$.peek()) {
+            service.close();
+            return;
+        }
+        service.open();
+        std.getOptional(TelemetryProvider)?.track('SelectionPaneOpened', {
+            page: 'whiteboard editor',
+            source: openedFrom(invocation),
+        });
+    },
+};
+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.
+     */
+    above: z.string().min(1).nullable(),
+});
+const reorderElement = {
+    id: 'canvas.element.reorder',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.element.reorder',
+    labelFallback: 'Move in the stack',
+    descriptionKey: 'com.labre.command.canvas.element.reorder.description',
+    descriptionFallback: 'Place an element directly above another one in the stacking order.',
+    // Agent only: without an explicit target there is nothing to say where.
+    surfaces: ['agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'editable',
+    params: reorderElementParams,
+    run: (std, _invocation, params) => {
+        const parsed = reorderElementParams.safeParse(params);
+        if (!parsed.success) {
+            console.error('canvas.element.reorder: invalid params', parsed.error);
+            return;
+        }
+        reorderPaneElement(std, parsed.data.id, parsed.data.above);
+    },
+};
+export const lockElementsParams = z.object({
+    /**
+     * The models to act on. Omitted: the current canvas selection. Each one is
+     * locked ON ITS OWN — never wrapped into a group.
+     */
+    ids: z.array(z.string()).optional(),
+});
+function lockTargets(std, params) {
+    const parsed = lockElementsParams.safeParse(params ?? {});
+    if (!parsed.success)
+        return [];
+    return (parsed.data.ids ?? std.get(GfxControllerIdentifier).selection.selectedIds);
+}
+function lockCommand(locked) {
+    const verb = locked ? 'lock' : 'unlock';
+    return {
+        id: `canvas.element.${verb}`,
+        owner: 'core',
+        kind: 'action',
+        labelKey: `com.labre.command.canvas.element.${verb}`,
+        labelFallback: locked ? 'Lock each element' : 'Unlock each element',
+        descriptionKey: `com.labre.command.canvas.element.${verb}.description`,
+        descriptionFallback: locked
+            ? 'Lock every selected element on its own, without grouping them.'
+            : 'Unlock every selected element on its own.',
+        surfaces: ['palette', 'agent'],
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+        availability: 'editable',
+        when: std => std.get(GfxControllerIdentifier).selection.selectedIds.length > 0,
+        params: lockElementsParams,
+        run: (std, _invocation, params) => {
+            setPaneElementsLocked(std, lockTargets(std, params), locked);
+        },
+    };
+}
+export const renameGroupParams = z.object({
+    id: z.string().min(1),
+    title: z.string(),
+});
+const renameGroup = {
+    id: 'canvas.group.rename',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.group.rename',
+    labelFallback: 'Rename group',
+    descriptionKey: 'com.labre.command.canvas.group.rename.description',
+    descriptionFallback: 'Give a group a new title.',
+    surfaces: ['agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'editable',
+    params: renameGroupParams,
+    run: (std, _invocation, params) => {
+        const parsed = renameGroupParams.safeParse(params);
+        if (!parsed.success) {
+            console.error('canvas.group.rename: invalid params', parsed.error);
+            return;
+        }
+        renamePaneGroup(std, parsed.data.id, parsed.data.title);
+    },
+};
+/**
+ * A frame's row is renamed in place like a group's (ADR 0031, amendments:
+ * frames are rows). Its own command rather than `canvas.group.rename` widened:
+ * the agent reads a command's wording, and a frame is not a group.
+ */
+const renameFrame = {
+    id: 'canvas.frame.rename',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.frame.rename',
+    labelFallback: 'Rename frame',
+    descriptionKey: 'com.labre.command.canvas.frame.rename.description',
+    descriptionFallback: 'Give a frame a new title.',
+    surfaces: ['agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'editable',
+    params: renameGroupParams,
+    run: (std, _invocation, params) => {
+        const parsed = renameGroupParams.safeParse(params);
+        if (!parsed.success) {
+            console.error('canvas.frame.rename: invalid params', parsed.error);
+            return;
+        }
+        renamePaneFrame(std, parsed.data.id, parsed.data.title);
+    },
+};
+export const hideLocalParams = z.object({
+    /** The models to act on. Omitted: the current canvas selection. */
+    ids: z.array(z.string()).optional(),
+    /**
+     * Whole user layers to act on instead (ADR 0031 stage 7). When given,
+     * `ids` and the selection are ignored.
+     */
+    layerIds: z.array(z.string()).optional(),
+    /** `false` shows them again. Omitted: hide. */
+    hidden: z.boolean().optional(),
+});
+function reportVisibility(std, hidden, count, scope = 'local', target = 'element') {
+    if (!count)
+        return;
+    std.getOptional(TelemetryProvider)?.track('CanvasVisibilityChanged', {
+        page: 'whiteboard editor',
+        target,
+        scope,
+        hidden,
+        count,
+    });
+}
+/**
+ * Hide elements for THIS viewer only (ADR 0031 §8) — or, with
+ * `hidden: false`, show them again; the pane's eye is both.
+ *
+ * Nothing is written to the document, so there is no read-only guard: a
+ * reader may hide what is in their way. Self-emits `CanvasVisibilityChanged`
+ * with the number of elements the gesture actually changed.
+ */
+const hideLocal = {
+    id: 'canvas.visibility.hideLocal',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.visibility.hide-local',
+    labelFallback: 'Hide for me',
+    descriptionKey: 'com.labre.command.canvas.visibility.hide-local.description',
+    descriptionFallback: 'Hide the selected elements on your screen only. Nothing changes for anyone else.',
+    surfaces: ['palette', 'agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'selection',
+    when: std => !!std.getOptional(CanvasLocalVisibility),
+    params: hideLocalParams,
+    run: (std, _invocation, params) => {
+        const visibility = std.getOptional(CanvasLocalVisibility);
+        const parsed = hideLocalParams.safeParse(params ?? {});
+        if (!visibility || !parsed.success)
+            return;
+        if (parsed.data.layerIds) {
+            const hidden = parsed.data.hidden ?? true;
+            const layers = parsed.data.layerIds;
+            const count = hidden
+                ? visibility.hideLayers(layers)
+                : visibility.showLayers(layers);
+            reportVisibility(std, hidden, count, 'local', 'layer');
+            return;
+        }
+        const ids = parsed.data.ids ?? std.get(GfxControllerIdentifier).selection.selectedIds;
+        const hidden = parsed.data.hidden ?? true;
+        const count = hidden ? visibility.hide(ids) : visibility.show(ids);
+        reportVisibility(std, hidden, count);
+    },
+};
+export const hideForEveryoneParams = z.object({
+    /** The models to act on. Omitted: the current canvas selection. */
+    ids: z.array(z.string()).optional(),
+    /**
+     * Whole user layers to act on instead: `hidden: true` on each record, one
+     * write per layer, never one per member (ADR 0031 §7).
+     */
+    layerIds: z.array(z.string()).optional(),
+    /** `false` shows them again, for everyone. Omitted: hide. */
+    hidden: z.boolean().optional(),
+});
+/**
+ * Hide elements for EVERYONE (ADR 0031 §7) — or, with `hidden: false`, show
+ * them again for everyone. Written to the document and synced: every viewer,
+ * every peer, stops painting and picking them, while rules, legends and
+ * semantic exports keep counting them (§9). Refused on a read-only document
+ * (`availability`, and again in the action). Self-emits
+ * `CanvasVisibilityChanged` with `scope: 'everyone'` and the count actually
+ * written.
+ */
+const hideForEveryone = {
+    id: 'canvas.visibility.hideForEveryone',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.visibility.hide-for-everyone',
+    labelFallback: 'Hide for everyone',
+    descriptionKey: 'com.labre.command.canvas.visibility.hide-for-everyone.description',
+    descriptionFallback: 'Hide the selected elements for everyone who opens this document. They stay in the document and in the selection pane.',
+    surfaces: ['palette', 'agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'editable',
+    when: std => std.get(GfxControllerIdentifier).selection.selectedIds.length > 0,
+    params: hideForEveryoneParams,
+    run: (std, _invocation, params) => {
+        const parsed = hideForEveryoneParams.safeParse(params ?? {});
+        if (!parsed.success)
+            return;
+        if (parsed.data.layerIds) {
+            const hidden = parsed.data.hidden ?? true;
+            const count = setUserLayersHiddenForEveryone(std, parsed.data.layerIds, hidden);
+            reportVisibility(std, hidden, count, 'everyone', 'layer');
+            return;
+        }
+        const ids = parsed.data.ids ?? std.get(GfxControllerIdentifier).selection.selectedIds;
+        const hidden = parsed.data.hidden ?? true;
+        const count = setPaneElementsHiddenForEveryone(std, ids, hidden);
+        reportVisibility(std, hidden, count, 'everyone');
+    },
+};
+/**
+ * Show everything this viewer hid. Stays in the palette whatever the pane
+ * seam says: with `SelectionPaneExtension(null)` it is the one way back.
+ */
+const showAll = {
+    id: 'canvas.visibility.showAll',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.visibility.show-all',
+    labelFallback: 'Show hidden elements',
+    descriptionKey: 'com.labre.command.canvas.visibility.show-all.description',
+    descriptionFallback: 'Show again every element and layer you hid on your screen.',
+    surfaces: ['palette', 'agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    when: std => {
+        const visibility = std.getOptional(CanvasLocalVisibility);
+        return ((visibility?.hiddenIds$.peek().size ?? 0) > 0 ||
+            (visibility?.hiddenLayerIds$.peek().size ?? 0) > 0);
+    },
+    run: std => {
+        const visibility = std.getOptional(CanvasLocalVisibility);
+        reportVisibility(std, false, visibility?.showAll() ?? 0);
+        reportVisibility(std, false, visibility?.showAllLayers() ?? 0, 'local', 'layer');
+    },
+};
+export const selectionPaneCommands = [
+    toggleSelectionPane,
+    reorderElement,
+    lockCommand(true),
+    lockCommand(false),
+    renameGroup,
+    renameFrame,
+    hideLocal,
+    hideForEveryone,
+    showAll,
+];

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

@@ -0,0 +1,3 @@
+export { filterSelectionPaneTree, renamePaneFrame, renamePaneGroup, reorderPaneElement, 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

@@ -0,0 +1,3 @@
+export { filterSelectionPaneTree, renamePaneFrame, renamePaneGroup, reorderPaneElement, 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';