@formicoidea/labre-core 0.43.1 → 0.45.0

package/dist/_pkgs/affine-widget-edgeless-toolbar/translations.d.ts

@@ -17,5 +17,57 @@ export declare const EDGELESS_TOOLBAR_MORE_TOOLS: ChromeWording;
  * is the family name, a proper name the host does not translate.
  */
 export declare const EDGELESS_TOOLBAR_FONT_FAMILY_UNAVAILABLE: ChromeWording;
+/** The pane's title, and the toolbar button's tooltip. */
+export declare const SELECTION_PANE_TITLE: ChromeWording;
+/**
+ * The catalogue's own "Close": the same word on the same kind of side panel,
+ * so one key (L7 dedupe: one chrome word, one key). The manifest already
+ * declares it for the catalogue, so it is not listed again below.
+ */
+export declare const SELECTION_PANE_CLOSE: ChromeWording;
+/** What the pane says on a canvas with nothing on it, or nothing filtered. */
+export declare const SELECTION_PANE_EMPTY: ChromeWording;
+export declare const SELECTION_PANE_FILTER: ChromeWording;
+/** The filter entry that shows every element again. */
+export declare const SELECTION_PANE_FILTER_ALL: ChromeWording;
+/** A frame offered by the filter; `{{name}}` is the frame's own title. */
+export declare const SELECTION_PANE_FILTER_FRAME: ChromeWording;
+/**
+ * Under a layer whose members the frame filter all leaves out: how many rows
+ * it holds. `{{count}}` is the number; the host pluralises.
+ */
+export declare const SELECTION_PANE_LAYER_FILTERED: ChromeWording;
+/** The eye of a visible row: hide it for this viewer only (ADR 0031 §8). */
+export declare const SELECTION_PANE_HIDE: ChromeWording;
+/** The eye of a row this viewer hid: show it again. */
+export declare const SELECTION_PANE_SHOW: ChromeWording;
+/**
+ * A row's menu entry that hides it for EVERYONE (ADR 0031 §7): written to
+ * the document, painted with the theme's warning tokens.
+ */
+export declare const SELECTION_PANE_HIDE_FOR_EVERYONE: ChromeWording;
+/** The same entry on a row hidden for everyone: show it to everyone again. */
+export declare const SELECTION_PANE_SHOW_FOR_EVERYONE: ChromeWording;
+/** The pane's head button that adds a user layer (ADR 0031 §2). */
+export declare const SELECTION_PANE_NEW_LAYER: ChromeWording;
+/** The hint on the active layer's row: where new elements land. */
+export declare const SELECTION_PANE_ACTIVE_LAYER: ChromeWording;
+/**
+ * A layer row's menu entry that deletes the layer WITH its members, in one
+ * undo step (ADR 0031 §10). Absent on the default layer.
+ */
+export declare const SELECTION_PANE_DELETE_LAYER: ChromeWording;
+/** The menu of a row, opened by a right click or its "more" button. */
+export declare const SELECTION_PANE_ROW_MENU: ChromeWording;
+/** The padlock of a locked row; the unlocked one reads `TOOLBAR_LOCK`. */
+export declare const SELECTION_PANE_UNLOCK: ChromeWording;
+export declare const SELECTION_PANE_EXPAND: ChromeWording;
+export declare const SELECTION_PANE_COLLAPSE: ChromeWording;
+/** One wording per element type and gfx block flavour the library ships. */
+export declare const SELECTION_PANE_TYPE_WORDINGS: Readonly<Record<string, ChromeWording>>;
+/** Every `affine:embed-*` flavour: the iframe embed's own word. */
+export declare const SELECTION_PANE_TYPE_EMBED: ChromeWording;
+/** A kind the library does not ship: a framework's own element type. */
+export declare const SELECTION_PANE_TYPE_ELEMENT: ChromeWording;
 /** Every wording this package declares, in the order it renders them. */
 export declare const EDGELESS_TOOLBAR_WORDINGS: readonly ChromeWording[];

package/dist/_pkgs/affine-widget-edgeless-toolbar/translations.js

@@ -1,4 +1,4 @@
-import { ICON_BUTTON_COMING_SOON, } from '../affine-shared/services/index.js';
+import { ATTACHMENT_LABEL, ICON_BUTTON_COMING_SOON, IMAGE_LABEL, TOOL_NAME_FRAME, TOOL_NAME_NOTE, } from '../affine-shared/services/index.js';
 /**
  * The generic edgeless toolbar's own wordings — not a specific tool's, the
  * toolbar chrome itself. `STYLE_GENERAL`/`STYLE_SCRIBBLED` (`config/consts.ts`'s
@@ -23,8 +23,168 @@ export const EDGELESS_TOOLBAR_FONT_FAMILY_UNAVAILABLE = [
     'com.labre.edgeless-toolbar.font-family-unavailable',
     '{{name}} (unavailable)',
 ];
+/* ── Selection pane (ADR 0031) ────────────────────────────────────────── */
+/** The pane's title, and the toolbar button's tooltip. */
+export const SELECTION_PANE_TITLE = [
+    'com.labre.selection-pane.title',
+    'Selection pane',
+];
+/**
+ * The catalogue's own "Close": the same word on the same kind of side panel,
+ * so one key (L7 dedupe: one chrome word, one key). The manifest already
+ * declares it for the catalogue, so it is not listed again below.
+ */
+export const SELECTION_PANE_CLOSE = [
+    'com.labre.catalogue.close',
+    'Close',
+];
+/** What the pane says on a canvas with nothing on it, or nothing filtered. */
+export const SELECTION_PANE_EMPTY = [
+    'com.labre.selection-pane.empty',
+    'Nothing on the canvas',
+];
+export const SELECTION_PANE_FILTER = [
+    'com.labre.selection-pane.filter',
+    'Filter',
+];
+/** The filter entry that shows every element again. */
+export const SELECTION_PANE_FILTER_ALL = [
+    'com.labre.selection-pane.filter.all',
+    'All elements',
+];
+/** A frame offered by the filter; `{{name}}` is the frame's own title. */
+export const SELECTION_PANE_FILTER_FRAME = [
+    'com.labre.selection-pane.filter.frame',
+    'Frame: {{name}}',
+];
+/**
+ * Under a layer whose members the frame filter all leaves out: how many rows
+ * it holds. `{{count}}` is the number; the host pluralises.
+ */
+export const SELECTION_PANE_LAYER_FILTERED = [
+    'com.labre.selection-pane.layer.filtered',
+    '{{count}} hidden by the filter',
+];
+/** The eye of a visible row: hide it for this viewer only (ADR 0031 §8). */
+export const SELECTION_PANE_HIDE = [
+    'com.labre.selection-pane.hide',
+    'Hide for me',
+];
+/** The eye of a row this viewer hid: show it again. */
+export const SELECTION_PANE_SHOW = [
+    'com.labre.selection-pane.show',
+    'Show',
+];
+/**
+ * A row's menu entry that hides it for EVERYONE (ADR 0031 §7): written to
+ * the document, painted with the theme's warning tokens.
+ */
+export const SELECTION_PANE_HIDE_FOR_EVERYONE = [
+    'com.labre.selection-pane.hide-for-everyone',
+    'Hide for everyone',
+];
+/** The same entry on a row hidden for everyone: show it to everyone again. */
+export const SELECTION_PANE_SHOW_FOR_EVERYONE = [
+    'com.labre.selection-pane.show-for-everyone',
+    'Show for everyone',
+];
+/** The pane's head button that adds a user layer (ADR 0031 §2). */
+export const SELECTION_PANE_NEW_LAYER = [
+    'com.labre.selection-pane.new-layer',
+    'New layer',
+];
+/** The hint on the active layer's row: where new elements land. */
+export const SELECTION_PANE_ACTIVE_LAYER = [
+    'com.labre.selection-pane.active-layer',
+    'New elements go into this layer',
+];
+/**
+ * A layer row's menu entry that deletes the layer WITH its members, in one
+ * undo step (ADR 0031 §10). Absent on the default layer.
+ */
+export const SELECTION_PANE_DELETE_LAYER = [
+    'com.labre.selection-pane.delete-layer',
+    'Delete layer',
+];
+/** The menu of a row, opened by a right click or its "more" button. */
+export const SELECTION_PANE_ROW_MENU = [
+    'com.labre.selection-pane.row-menu',
+    'More actions',
+];
+/** The padlock of a locked row; the unlocked one reads `TOOLBAR_LOCK`. */
+export const SELECTION_PANE_UNLOCK = [
+    'com.labre.selection-pane.unlock',
+    'Unlock',
+];
+export const SELECTION_PANE_EXPAND = [
+    'com.labre.selection-pane.expand',
+    'Expand',
+];
+export const SELECTION_PANE_COLLAPSE = [
+    'com.labre.selection-pane.collapse',
+    'Collapse',
+];
+/**
+ * The wording of a row whose element carries no text and no role: its KIND.
+ *
+ * The kinds the pane is the first to name get their own keys below; the
+ * others reuse the word their tool, slash entry or label already declares (L7
+ * dedupe: one chrome word, one key), restated here with the owner's exact
+ * fallback because this package cannot import every owner's table.
+ */
+const SELECTION_PANE_OWN_TYPE_WORDINGS = {
+    shape: ['com.labre.selection-pane.type.shape', 'Shape'],
+    text: ['com.labre.selection-pane.type.text', 'Text'],
+    group: ['com.labre.selection-pane.type.group', 'Group'],
+    brush: ['com.labre.selection-pane.type.brush', 'Drawing'],
+    'affine:bookmark': ['com.labre.selection-pane.type.bookmark', 'Link'],
+    'affine:latex': ['com.labre.selection-pane.type.latex', 'Equation'],
+};
+/** One wording per element type and gfx block flavour the library ships. */
+export const SELECTION_PANE_TYPE_WORDINGS = {
+    ...SELECTION_PANE_OWN_TYPE_WORDINGS,
+    'affine:edgeless-text': SELECTION_PANE_OWN_TYPE_WORDINGS.text,
+    connector: ['com.labre.connector.toolbar.connector', 'Connector'],
+    mindmap: ['com.labre.surface-ref.type.mindmap', 'Mind map'],
+    highlighter: ['com.labre.highlight.label', 'Highlight'],
+    'affine:frame': TOOL_NAME_FRAME,
+    'affine:note': TOOL_NAME_NOTE,
+    'affine:image': IMAGE_LABEL,
+    'affine:attachment': ATTACHMENT_LABEL,
+};
+/** Every `affine:embed-*` flavour: the iframe embed's own word. */
+export const SELECTION_PANE_TYPE_EMBED = [
+    'com.labre.embed.iframe.slash.name',
+    'Embed',
+];
+/** A kind the library does not ship: a framework's own element type. */
+export const SELECTION_PANE_TYPE_ELEMENT = [
+    'com.labre.selection-pane.type.element',
+    'Element',
+];
 /** Every wording this package declares, in the order it renders them. */
 export const EDGELESS_TOOLBAR_WORDINGS = [
     EDGELESS_TOOLBAR_MORE_TOOLS,
     EDGELESS_TOOLBAR_FONT_FAMILY_UNAVAILABLE,
+    SELECTION_PANE_TITLE,
+    SELECTION_PANE_EMPTY,
+    SELECTION_PANE_FILTER,
+    SELECTION_PANE_FILTER_ALL,
+    SELECTION_PANE_FILTER_FRAME,
+    SELECTION_PANE_LAYER_FILTERED,
+    SELECTION_PANE_HIDE,
+    SELECTION_PANE_SHOW,
+    SELECTION_PANE_HIDE_FOR_EVERYONE,
+    SELECTION_PANE_SHOW_FOR_EVERYONE,
+    SELECTION_PANE_ROW_MENU,
+    SELECTION_PANE_NEW_LAYER,
+    SELECTION_PANE_ACTIVE_LAYER,
+    SELECTION_PANE_DELETE_LAYER,
+    SELECTION_PANE_UNLOCK,
+    SELECTION_PANE_EXPAND,
+    SELECTION_PANE_COLLAPSE,
+    // Only the kinds this pane names first; the reused words are declared by
+    // their owners.
+    ...Object.values(SELECTION_PANE_OWN_TYPE_WORDINGS),
+    SELECTION_PANE_TYPE_ELEMENT,
 ];

package/dist/_pkgs/affine-widget-edgeless-toolbar/view.js

@@ -4,6 +4,9 @@ import { edgelessArtefactCatalogueWidget } from './catalogue/artefact-catalogue-
 import { edgelessToolbarWidget } from './edgeless-toolbar.js';
 import { effects } from './effects.js';
 import { ArtefactPlacementTool } from './placement/artefact-placement-tool.js';
+import { selectionPaneDefaultExtension } from './selection-pane/selection-pane-default.js';
+import { selectionPaneQuickTool } from './selection-pane/selection-pane-tool.js';
+import { edgelessSelectionPaneWidget } from './selection-pane/selection-pane-widget.js';
 export class EdgelessToolbarViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -28,6 +31,13 @@ export class EdgelessToolbarViewExtension extends ViewExtensionProvider {
             // chrome driven by whatever commands are registered, so a framework whose
             // flag is off simply never arms it. See `docs/adr/0009`.
             context.register(ArtefactPlacementTool);
+            // The selection pane (ADR 0031), on the catalogue's terms: its panel,
+            // the default implementation of its seam, and its toolbar entry, all
+            // unconditional. A host replaces or switches it off through
+            // `SelectionPaneExtension`; nothing it lists is a flag's business.
+            context.register(edgelessSelectionPaneWidget);
+            context.register(selectionPaneDefaultExtension);
+            context.register(selectionPaneQuickTool);
         }
     }
 }

package/dist/_pkgs/affine-widget-note-slicer/note-slicer.js

@@ -32,7 +32,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { EdgelessLegacySlotIdentifier, getSurfaceComponent, isNoteBlock, } from '../affine-block-surface/index.js';
+import { applyCreationLayer, EdgelessLegacySlotIdentifier, getSurfaceComponent, isNoteBlock, sourceLayerOf, } from '../affine-block-surface/index.js';
 import { DEFAULT_NOTE_HEIGHT, } from '../affine-model/index.js';
 import { EDGELESS_BLOCK_CHILD_PADDING } from '../affine-shared/consts/index.js';
 import { TelemetryProvider } from '../affine-shared/services/index.js';
@@ -192,13 +192,17 @@ let NoteSlicer = (() => {
             const [x, , width] = deserializeXYWH(xywh);
             const sliceVerticalPos = this._divingLinePositions[this._activeSlicerIndex].y;
             const newY = this.gfx.viewport.toModelCoord(x, sliceVerticalPos)[1];
-            const newNoteId = this.store.addBlock('affine:note', {
+            const props = {
                 background,
                 displayMode,
                 xywh: serializeXYWH(x, newY + NEW_NOTE_GAP, width, DEFAULT_NOTE_HEIGHT),
                 index: originalIndex + 1,
                 edgeless: restOfEdgeless,
-            }, doc.root?.id, originalNoteIndex ? originalNoteIndex + 1 : undefined);
+                // The split-off half stays in its note's layer (ADR 0031 §6).
+                layer: sourceLayerOf(this._anchorNote),
+            };
+            applyCreationLayer(this.std, props);
+            const newNoteId = this.store.addBlock('affine:note', props, doc.root?.id, originalNoteIndex ? originalNoteIndex + 1 : undefined);
             doc.moveBlocks(resetBlocks, doc.getModelById(newNoteId));
             this._activeSlicerIndex = 0;
             this._selection.set({

package/dist/_pkgs/std/gfx/controller.d.ts

@@ -8,6 +8,7 @@ import type { CursorType } from './cursor.js';
 import { GridManager } from './grid.js';
 import { KeyboardController } from './keyboard.js';
 import { LayerManager } from './layer.js';
+import { GfxHiddenForEveryone, GfxLocalVisibility } from './local-visibility.js';
 import type { PointTestOptions } from './model/base.js';
 import { GfxBlockElementModel } from './model/gfx-block-model.js';
 import type { GfxModel } from './model/model.js';
@@ -20,6 +21,18 @@ export declare class GfxController extends LifeCycleWatcher {
     private readonly _surface$;
     readonly cursor$: Signal<CursorType>;
     readonly keyboard: KeyboardController;
+    /**
+     * What this viewer has hidden on the canvas (ADR 0031 §8). Read by the
+     * renderers, the DOM block views, pointer picking and the marquee — never by
+     * `grid.search`, whose answer rules and legends share.
+     */
+    readonly localVisibility: GfxLocalVisibility;
+    /**
+     * The ids hidden for everyone (ADR 0031 §7), followed on the surface and
+     * the store and registered into {@link localVisibility}: what nobody sees
+     * is, a fortiori, not seen by this viewer.
+     */
+    readonly hiddenForEveryone: GfxHiddenForEveryone;
     readonly viewport: Viewport;
     get grid(): GridManager;
     get layer(): LayerManager;

package/dist/_pkgs/std/gfx/controller.js

@@ -10,6 +10,7 @@ import { GridManager } from './grid.js';
 import { gfxControllerKey } from './identifiers.js';
 import { KeyboardController } from './keyboard.js';
 import { LayerManager } from './layer.js';
+import { GfxHiddenForEveryone, GfxLocalVisibility, } from './local-visibility.js';
 import { GfxBlockElementModel } from './model/gfx-block-model.js';
 import { GfxPrimitiveElementModel } from './model/surface/element-model.js';
 import { FIT_TO_SCREEN_PADDING, Viewport, ZOOM_INITIAL } from './viewport.js';
@@ -46,11 +47,27 @@ export class GfxController extends LifeCycleWatcher {
         this._disposables = new DisposableGroup();
         this._surface$ = new Signal(null);
         this.cursor$ = new Signal();
+        /**
+         * What this viewer has hidden on the canvas (ADR 0031 §8). Read by the
+         * renderers, the DOM block views, pointer picking and the marquee — never by
+         * `grid.search`, whose answer rules and legends share.
+         */
+        this.localVisibility = new GfxLocalVisibility();
+        /**
+         * The ids hidden for everyone (ADR 0031 §7), followed on the surface and
+         * the store and registered into {@link localVisibility}: what nobody sees
+         * is, a fortiori, not seen by this viewer.
+         */
+        this.hiddenForEveryone = new GfxHiddenForEveryone();
         this.viewport = new Viewport();
         this.keyboard = new KeyboardController(std);
         this._disposables.add(onSurfaceAdded(this.doc, surface => {
             this._surface$.value = surface;
+            this.hiddenForEveryone.watch(this.doc, surface);
         }));
+        this._disposables.add(this.localVisibility.register(this.hiddenForEveryone.ids$));
+        this._disposables.add(this.localVisibility.registerLayers(this.hiddenForEveryone.layerIds$));
+        this._disposables.add(() => this.hiddenForEveryone.dispose());
         this._disposables.add(this.viewport);
         this._disposables.add(this.keyboard);
         this.std.provider.getAll(GfxClassExtenderIdentifier).forEach(ext => {
@@ -94,8 +111,11 @@ export class GfxController extends LifeCycleWatcher {
             h: responsePadding[1] * 2,
         };
         const candidates = this.grid.search(hitTestBound);
-        const picked = candidates.filter(elm => elm.includesPoint(x, y, options, this.std.host) ||
-            elm.externalBound?.isPointInBound([x, y]));
+        // A model this viewer hid is not under the pointer: it is not painted,
+        // so it cannot be what the user aims at (ADR 0031 §8).
+        const picked = candidates.filter(elm => !this.localVisibility.isHidden(elm) &&
+            (elm.includesPoint(x, y, options, this.std.host) ||
+                elm.externalBound?.isPointInBound([x, y])));
         picked.sort(this.layer.compare);
         if (all) {
             return picked;

package/dist/_pkgs/std/gfx/grid.d.ts

@@ -45,8 +45,37 @@ export declare class GridManager extends GfxExtension {
     remove(element: GfxModel | GfxLocalElementModel): void;
     /**
      * Search for elements in a bound.
-     * @param bound
-     * @param options
+     *
+     * Skips the stored `hidden` (mindmap collapse) and NOTHING ELSE, on purpose:
+     * this answer is shared by painting, picking AND logic — rules, legends,
+     * semantic exports — and a viewer's local hide must never change what
+     * another viewer's rules or legend say about the same document (ADR 0031
+     * §8). A new visibility is applied by the consumer, never added here.
+     *
+     * Caller audit (ADR 0031 §9; the row of its table each caller belongs to):
+     *
+     * - paint — the canvas renderer's bound pass (`_renderByBound`, which also
+     *   paints the SVG export and the PNG export's canvas layer) and the DOM
+     *   renderer's two passes: filter through the shared paint predicate
+     *   (`isPainted`, `affine-block-surface/renderer/paint-predicate.ts`).
+     * - paint, blocks — `gfx-viewport`'s `getModelsInViewport` in the edgeless
+     *   root and its preview: which DOM blocks to mount; a block's own
+     *   visibility is its view's business.
+     * - picking — `GfxController.getElementByPoint` and every caller of it
+     *   (selection, hover highlights, frame highlight, peek, connector reveal,
+     *   mindmap drag, pan, text tools, element link, spotlight).
+     * - marquee — `GfxController.getElementsByBound` from
+     *   `InteractivityManager.handleBoxSelection`.
+     * - export — `getElementsByBound` from the PNG export (`ExportManager`),
+     *   the SVG board export (`renderBoardSvg`) and copy-as-PNG
+     *   (`EdgelessClipboardController`'s canvas path).
+     * - logic, keeps every visibility — `getElementsByBound` from the legend
+     *   (`rolesInBound`, the legend redraw), and the surface-ref slash menu's
+     *   free-space search (a hidden element still takes its room).
+     * - pointer-adjacent, no row in the table yet, keeps every visibility today
+     *   — the connector tool's connectable targets in view and the snap
+     *   overlay's alignment candidates: a connector may still attach to, and a
+     *   drag still snap to, an element the viewer hid.
      */
     search<T extends BuiltInFilterType = 'canvas' | 'block'>(bound: IBound, options?: {
         /**

package/dist/_pkgs/std/gfx/index.d.ts

@@ -10,12 +10,14 @@ export { GfxControllerIdentifier } from './identifiers.js';
 export type { BoxSelectionContext, DragEndContext, DragExtensionInitializeContext, DragInitializationOption, DragMoveContext, DragStartContext, ExtensionDragEndContext, ExtensionDragMoveContext, ExtensionDragStartContext, GfxInteractivityContext, GfxViewInteractionConfig, ResizeConstraint, ResizeEndContext, ResizeHandle, ResizeMoveContext, ResizeStartContext, RotateConstraint, RotateEndContext, RotateMoveContext, RotateStartContext, SelectContext, } from './interactivity/index.js';
 export { GfxViewEventManager, GfxViewInteractionExtension, InteractivityExtension, InteractivityIdentifier, InteractivityManager, } from './interactivity/index.js';
 export { LayerManager, type ReorderingDirection } from './layer.js';
+export { GfxHiddenForEveryone, GfxLocalVisibility, } from './local-visibility.js';
 export type { GfxCompatibleInterface, GfxElementGeometry, GfxGroupCompatibleInterface, PointTestOptions, } from './model/base.js';
 export { gfxGroupCompatibleSymbol, isGfxGroupCompatibleModel, } from './model/base.js';
 export { GfxBlockElementModel, type GfxCommonBlockProps, GfxCompatibleBlockModel as GfxCompatible, type GfxCompatibleProps, } from './model/gfx-block-model.js';
 export { type GfxModel, isPrimitiveModel } from './model/model.js';
 export { convert, convertProps, derive, field, getDerivedProps, getFieldPropsSet, getLocalPropsSet, initializeObservers, initializeWatchers, local, observe, updateDerivedProps, watch, } from './model/surface/decorators/index.js';
-export { type BaseElementProps, type ForeignInterchange, type InterchangeScope, GfxGroupLikeElementModel, GfxPrimitiveElementModel, type SerializedElement, type ValidationException, } from './model/surface/element-model.js';
+export { type BaseElementProps, type ForeignInterchange, type InterchangeScope, GfxGroupLikeElementModel, GfxPrimitiveElementModel, isStoredHiddenForEveryone, type SerializedElement, type ValidationException, } from './model/surface/element-model.js';
+export { DEFAULT_LAYER_ID, layerCarrierOf, ownLayerOf, type SurfaceLayerRecord, SurfaceUserLayers, } from './model/surface/user-layers.js';
 export { GfxLocalElementModel, prop, } from './model/surface/local-element-model.js';
 export { collectPivotOccurrences, isPivotBound, type PivotBoundElement, type PivotOccurrence, resolvePivotBinding, } from './model/surface/pivot.js';
 export { type EdgeDirectionDef, findRoleDef, isTypedEdgeRole, type RoleDef, type RoleDefs, type RoleId, roleIsA, type RoleKind, RoleVocabularyExtension, RoleVocabularyIdentifier, } from './model/surface/role.js';

package/dist/_pkgs/std/gfx/index.js

@@ -8,11 +8,13 @@ export { DEFAULT_HIGHLIGHT_DURATION, DEFAULT_HIGHLIGHT_PADDING, ElementHighlight
 export { GfxControllerIdentifier } from './identifiers.js';
 export { GfxViewEventManager, GfxViewInteractionExtension, InteractivityExtension, InteractivityIdentifier, InteractivityManager, } from './interactivity/index.js';
 export { LayerManager } from './layer.js';
+export { GfxHiddenForEveryone, GfxLocalVisibility, } from './local-visibility.js';
 export { gfxGroupCompatibleSymbol, isGfxGroupCompatibleModel, } from './model/base.js';
 export { GfxBlockElementModel, GfxCompatibleBlockModel as GfxCompatible, } from './model/gfx-block-model.js';
 export { isPrimitiveModel } from './model/model.js';
 export { convert, convertProps, derive, field, getDerivedProps, getFieldPropsSet, getLocalPropsSet, initializeObservers, initializeWatchers, local, observe, updateDerivedProps, watch, } from './model/surface/decorators/index.js';
-export { GfxGroupLikeElementModel, GfxPrimitiveElementModel, } from './model/surface/element-model.js';
+export { GfxGroupLikeElementModel, GfxPrimitiveElementModel, isStoredHiddenForEveryone, } from './model/surface/element-model.js';
+export { DEFAULT_LAYER_ID, layerCarrierOf, ownLayerOf, SurfaceUserLayers, } from './model/surface/user-layers.js';
 export { GfxLocalElementModel, prop, } from './model/surface/local-element-model.js';
 export { collectPivotOccurrences, isPivotBound, resolvePivotBinding, } from './model/surface/pivot.js';
 export { findRoleDef, isTypedEdgeRole, roleIsA, RoleVocabularyExtension, RoleVocabularyIdentifier, } from './model/surface/role.js';

package/dist/_pkgs/std/gfx/interactivity/manager.js

@@ -225,6 +225,10 @@ export class InteractivityManager extends GfxExtension {
     }
     handleBoxSelection(context) {
         const elements = this.gfx.getElementsByBound(context.box).filter(model => {
+            // The marquee takes what the viewer sees: a locally hidden model is
+            // left out (ADR 0031 §8). The selection pane still selects it.
+            if (this.gfx.localVisibility.isHidden(model))
+                return false;
             const view = this.gfx.view.get(model);
             if (!view ||
                 view.onBoxSelected({
@@ -283,6 +287,9 @@ export class InteractivityManager extends GfxExtension {
             onDragMove(lastEvent);
         });
         const onDragMove = (event) => {
+            // The viewport watcher replays the latest pointer position; without
+            // this it replayed the drag start and snapped the elements back.
+            lastEvent = event;
             dragLastPos = Point.from(this.gfx.viewport.toModelCoordFromClientCoord([event.x, event.y]));
             const moveContext = {
                 ...internal,

package/dist/_pkgs/std/gfx/layer.js

@@ -220,11 +220,22 @@ export class LayerManager extends GfxExtension {
                     layerElements[0],
                     last(layerElements),
                 ], target)) {
-                    const insertIdx = layerElements.findIndex((_, idx) => {
-                        const pre = layerElements[idx - 1];
-                        return (compare(target, layerElements[idx]) < 0 &&
-                            (!pre || compare(target, pre) >= 0));
-                    });
+                    // The first element `target` sorts before. The layer is sorted and
+                    // `target` is in its range, so that position is found by bisection
+                    // rather than by comparing `target` with every element: a frame
+                    // adopting N children re-inserted each of them, N² comparisons.
+                    let low = 0;
+                    let high = layerElements.length;
+                    while (low < high) {
+                        const mid = (low + high) >>> 1;
+                        if (compare(target, layerElements[mid]) < 0) {
+                            high = mid;
+                        }
+                        else {
+                            low = mid + 1;
+                        }
+                    }
+                    const insertIdx = low;
                     if (layer.type === type) {
                         addToLayer(layer, target, insertIdx);
                         updateLayersZIndex(layers, cur);
@@ -468,6 +479,31 @@ export class LayerManager extends GfxExtension {
      * @returns
      */
     generateIndex(reverse = false) {
+        // With user layers the paint order is layer rank first (ADR 0031 §4), so
+        // the first and last runs no longer hold the lowest and highest `index`.
+        // "Above everything" must still mean above every key, which, rank first,
+        // is the top of whichever layer the new element lands in.
+        // Every model is scanned, not the runs' edges: a run can span two user
+        // layers, and the lower layer's highest key then sits mid-run.
+        if (this._surface?.userLayers.ranks) {
+            let lowest = null;
+            let highest = null;
+            for (const model of [...this.canvasElements, ...this.blocks]) {
+                const index = model.index;
+                if (typeof index !== 'string')
+                    continue;
+                if (lowest === null || index < lowest)
+                    lowest = index;
+                if (highest === null || index > highest)
+                    highest = index;
+            }
+            if (lowest === null || highest === null) {
+                return LayerManager.INITIAL_INDEX;
+            }
+            return reverse
+                ? generateKeyBetween(null, lowest)
+                : generateKeyBetween(highest, null);
+        }
         if (reverse) {
             const firstIndex = this.layers[0]?.indexes[0];
             return firstIndex
@@ -493,6 +529,13 @@ export class LayerManager extends GfxExtension {
         }
         else {
             elements = this.layers.reduce((pre, current) => pre.concat(current.elements.filter(element => element.group == null)), []);
+            // Forward / backward / front / back move an element WITHIN its user
+            // layer (ADR 0031 §4): its neighbours are that layer's members only.
+            const userLayers = this._surface?.userLayers;
+            if (userLayers?.ranks) {
+                const own = userLayers.effectiveLayerOf(element);
+                elements = elements.filter(other => userLayers.effectiveLayerOf(other) === own);
+            }
         }
         const currentIdx = elements.indexOf(element);
         switch (direction) {
@@ -553,6 +596,13 @@ export class LayerManager extends GfxExtension {
             }
             if (payload.type === 'update') {
                 const block = store.getModelById(payload.id);
+                // A block moved to another user layer (ADR 0031 §3) stacks
+                // elsewhere: re-sort it as if its `index` changed.
+                if (payload.props.key === 'layer' &&
+                    block instanceof GfxBlockElementModel &&
+                    this.blocks.includes(block)) {
+                    this.update(block);
+                }
                 if ((payload.props.key === 'index' ||
                     payload.props.key === 'childElementIds') &&
                     block instanceof GfxBlockElementModel &&
@@ -599,6 +649,24 @@ export class LayerManager extends GfxExtension {
                 if (payload.props['index'] || payload.props['childIds']) {
                     this.update(surface.getElementById(payload.id), payload.props);
                 }
+                else if ('layer' in payload.props || 'layer' in payload.oldValues) {
+                    // Moved to another user layer (ADR 0031 §3), set or cleared:
+                    // re-sort as an `index` change would (a group re-sorts whole).
+                    const element = surface.getElementById(payload.id);
+                    if (element)
+                        this.update(element);
+                }
+            }));
+            // The layer list changed — created, reordered, removed (ADR 0031 §2):
+            // every rank may have moved, so the whole order is rebuilt.
+            this._disposable.add(surface.propsUpdated.subscribe(({ key }) => {
+                if (key !== 'layers')
+                    return;
+                this._reset();
+                this.slots.layerUpdated.next({
+                    type: 'update',
+                    initiatingElement: surface,
+                });
             }));
             this._disposable.add(surface.elementRemoved.subscribe(payload => this.delete(payload.model)));
             this._disposable.add(surface.localElementAdded.subscribe(elm => {