@formicoidea/labre-core 0.32.0 → 0.34.1

package/dist/_pkgs/affine-shared/utils/file/filesys.js

@@ -79,6 +79,27 @@ const FileTypes = [
     },
 ];
 export async function openFilesWith(acceptType = 'Any', multiple = true) {
+    if (acceptType === 'Any')
+        return openFilesWithSpec(undefined, multiple);
+    const fileType = FileTypes.find(i => i.description === acceptType);
+    if (!fileType) {
+        // Unreachable through the closed `AcceptTypes` union, and reported rather
+        // than thrown for the same reason it always was: the picker branch used to
+        // throw this inside its own try/catch, log it and answer `null`. A caller
+        // asking for a filter that does not exist gets no dialog, not an exception
+        // it never had to handle.
+        console.error(new BlockSuiteError(ErrorCode.DefaultRuntimeError, `Unexpected acceptType "${acceptType}"`));
+        return null;
+    }
+    return openFilesWithSpec(fileType, multiple);
+}
+/**
+ * The picker itself, over a filter rather than over a name in the table.
+ *
+ * `undefined` is "Any": no filter at all, which is what the dialog shows when
+ * nobody narrowed it.
+ */
+async function openFilesWithSpec(spec, multiple) {
     // Feature detection. The API needs to be supported
     // and the app not run in an iframe.
     const supportsFileSystemAccess = 'showOpenFilePicker' in window &&
@@ -93,11 +114,8 @@ export async function openFilesWith(acceptType = 'Any', multiple = true) {
     // If the File System Access API is supported…
     if (supportsFileSystemAccess && window.showOpenFilePicker) {
         try {
-            const fileType = FileTypes.find(i => i.description === acceptType);
-            if (acceptType !== 'Any' && !fileType)
-                throw new BlockSuiteError(ErrorCode.DefaultRuntimeError, `Unexpected acceptType "${acceptType}"`);
             const pickerOpts = {
-                types: fileType ? [fileType] : undefined,
+                types: spec ? [spec] : undefined,
                 multiple,
             };
             // Show the file picker, optionally allowing multiple files.
@@ -117,9 +135,19 @@ export async function openFilesWith(acceptType = 'Any', multiple = true) {
         input.style.display = 'none';
         input.type = 'file';
         input.multiple = multiple;
-        if (acceptType !== 'Any') {
-            // For example, `accept="image/*"` or `accept="video/*,audio/*"`.
-            input.accept = Object.keys(FileTypes.find(i => i.description === acceptType)?.accept ?? '').join(',');
+        if (spec) {
+            // For example, `accept="image/*,.png,.jpg"` or `accept="video/*,.mp4"`.
+            //
+            // The EXTENSIONS as well as the MIME types, and the extensions are the
+            // half that matters for anything the OS has no type for: `.bpmn`, `.mm`
+            // and `.opml` are registered nowhere, so a filter built from
+            // `application/xml` alone greys them out in the native dialog and the
+            // file cannot be picked at all. This is the branch every browser without
+            // the File System Access API takes — Firefox and Safari — and
+            // `showOpenFilePicker` above already reads both halves of the same
+            // filter.
+            const type = spec.accept;
+            input.accept = [...Object.keys(type), ...Object.values(type).flat()].join(',');
         }
         document.body.append(input);
         // The `change` event fires when the user interacts with the dialog.
@@ -143,6 +171,19 @@ export async function openSingleFileWith(acceptType) {
     const files = await openFilesWith(acceptType, false);
     return files?.at(0) ?? null;
 }
+/**
+ * One file, filtered by a spec the caller built rather than by a name in
+ * {@link FileTypes}.
+ *
+ * What {@link openSingleFileWith} is for the editor's own dialogs, this is for
+ * anything whose filter is DECLARED somewhere else — today the interchange
+ * registry, whose formats each carry their extensions and their mime and are
+ * added by a framework, not by editing the table above.
+ */
+export async function openSingleFileWithSpec(spec) {
+    const files = await openFilesWithSpec(spec, false);
+    return files?.at(0) ?? null;
+}
 export async function getImageFilesFromLocal() {
     const files = await openFilesWith('Images');
     return files ?? [];

package/dist/_pkgs/affine-shared/utils/zod-schema.js

@@ -187,7 +187,5 @@ export function pickStylePropsForKey(key, props) {
             picked[prop] = parsed.data;
         }
     }
-    return Object.keys(picked).length
-        ? picked
-        : null;
+    return Object.keys(picked).length ? picked : null;
 }

package/dist/_pkgs/affine-widget-drag-handle/utils.js

@@ -4,7 +4,7 @@ import { ParagraphBlockComponent } from '../affine-block-paragraph/index.js';
 import { DatabaseBlockModel, ListBlockModel, ParagraphBlockModel, } from '../affine-model/index.js';
 import { DocModeProvider } from '../affine-shared/services/index.js';
 import { calcDropTarget, findClosestBlockComponent, getBlockProps, getClosestBlockComponentByPoint, matchModels, } from '../affine-shared/utils/index.js';
-import { Bound, Point, Rect, } from '../global/gfx/index.js';
+import { Bound, Point, Rect } from '../global/gfx/index.js';
 import { DRAG_HANDLE_CONTAINER_HEIGHT, DRAG_HANDLE_CONTAINER_OFFSET_LEFT, DRAG_HANDLE_CONTAINER_OFFSET_LEFT_LIST, EDGELESS_NOTE_EXTRA_PADDING, NOTE_CONTAINER_PADDING, } from './config.js';
 const heightMap = {
     text: 23,

package/dist/_pkgs/affine-widget-edgeless-auto-connect/index.js

@@ -40,7 +40,7 @@ import { matchModels, stopPropagation } from '../affine-shared/utils/index.js';
 import { Bound } from '../global/gfx/index.js';
 import { ArrowLeftSmallIcon, ArrowRightSmallIcon, InvisibleIcon, } from '@blocksuite/icons/lit';
 import { WidgetComponent, WidgetViewExtension } from '../std/index.js';
-import { GfxControllerIdentifier, } from '../std/gfx/index.js';
+import { GfxControllerIdentifier } from '../std/gfx/index.js';
 import { css, html, nothing } from 'lit';
 import { state } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';

package/dist/_pkgs/affine-widget-edgeless-dragging-area/edgeless-dragging-area-rect.js

@@ -1,4 +1,4 @@
-import { DefaultModeDragType, DefaultTool, } from '../affine-block-surface/index.js';
+import { DefaultModeDragType, DefaultTool } from '../affine-block-surface/index.js';
 import { WidgetComponent, WidgetViewExtension } from '../std/index.js';
 import { GfxControllerIdentifier } from '../std/gfx/index.js';
 import { cssVarV2 } from '@toeverything/theme/v2';

package/dist/_pkgs/affine-widget-edgeless-toolbar/catalogue/artefact-catalogue-default.d.ts

@@ -0,0 +1,14 @@
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * The DEFAULT `ArtefactCatalogueProvider`: the library's own left sidepanel.
+ *
+ * Registered next to the widget itself (`EdgelessToolbarViewExtension`), and
+ * unconditionally — a catalogue is core chrome, not a framework's tooling. ADR
+ * 0009's gating is carried by the frameworks: a framework whose flag is off
+ * shows no senior button, so its owner is never passed to `open`, and the panel
+ * simply never opens for it.
+ *
+ * `di.addImpl`, so a host's `ArtefactCatalogueExtension(service)` — which uses
+ * `di.override` — wins whatever the registration order.
+ */
+export declare const artefactCatalogueDefaultExtension: ExtensionType;

package/dist/_pkgs/affine-widget-edgeless-toolbar/catalogue/artefact-catalogue-default.js

@@ -0,0 +1,40 @@
+import { ArtefactCatalogueProvider, } from '../../affine-shared/services/index.js';
+import { StdIdentifier } from '../../std/index.js';
+import { EDGELESS_ARTEFACT_CATALOGUE_WIDGET, } from './artefact-catalogue-widget.js';
+/**
+ * The widget, found on the editor host — or `null` before it has mounted, and
+ * on a page-mode editor where it is not registered at all.
+ *
+ * A DOM lookup rather than a reference held at registration time, because the
+ * widget is created and destroyed by lit as the root block renders: the same
+ * lookup `EditorAnchoredPanel` makes for the toolbar it measures against. A
+ * `null` here is not an error — it is a catalogue nobody can open yet, and the
+ * `open` below is then a no-op rather than a throw in a menu click handler.
+ */
+function catalogueWidget(std) {
+    return (std.host.querySelector(EDGELESS_ARTEFACT_CATALOGUE_WIDGET) ?? null);
+}
+/**
+ * The DEFAULT `ArtefactCatalogueProvider`: the library's own left sidepanel.
+ *
+ * Registered next to the widget itself (`EdgelessToolbarViewExtension`), and
+ * unconditionally — a catalogue is core chrome, not a framework's tooling. ADR
+ * 0009's gating is carried by the frameworks: a framework whose flag is off
+ * shows no senior button, so its owner is never passed to `open`, and the panel
+ * simply never opens for it.
+ *
+ * `di.addImpl`, so a host's `ArtefactCatalogueExtension(service)` — which uses
+ * `di.override` — wins whatever the registration order.
+ */
+export const artefactCatalogueDefaultExtension = {
+    setup: di => {
+        di.addImpl(ArtefactCatalogueProvider, provider => {
+            const std = provider.get(StdIdentifier);
+            const service = {
+                open: owner => catalogueWidget(std)?.openFor(owner),
+                close: () => catalogueWidget(std)?.closePanel(),
+            };
+            return service;
+        });
+    },
+};

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

@@ -0,0 +1,158 @@
+import type { RootBlockModel } from '../../affine-model/index.js';
+import { type CommandOwner, WidgetComponent } from '../../std/index.js';
+import { nothing } from 'lit';
+export declare const EDGELESS_ARTEFACT_CATALOGUE_WIDGET = "edgeless-artefact-catalogue-widget";
+/**
+ * The **artefact catalogue** sidepanel (PF6).
+ *
+ * A framework's senior sub-menu is a row of icons, and a row of icons stops
+ * working somewhere around fourteen. The BPMN pack is the first framework to
+ * pass that line, so the sub-menu shows the thirteen the ranking put first and
+ * hands the rest to this panel: everything the owner declares on the
+ * `'catalogue'` surface, grouped by the categories the framework itself
+ * declared, with the label and the chord spelled out instead of guessed from a
+ * glyph.
+ *
+ * ## Left, full height, inside the editor
+ *
+ * Not a popover, not a modal. It is a column down the left edge of the editor
+ * host — the side no toolbar occupies — the canvas stays live to its right, and
+ * a click on the canvas puts it away. Twenty artefacts want a list you scroll,
+ * and a list you scroll wants height; a floating box would have had to choose
+ * between covering the board and showing four rows at a time.
+ *
+ * ## Not an `EditorAnchoredPanel`
+ *
+ * The shared base (ADR 0011) exists for panels pinned ABOVE the senior button
+ * bar and measured against it: its host is bottom-left and zero-sized, and
+ * `anchorBox()` returns a `bottom` and a width read off the bar. None of that
+ * is expressible for a full-height column, so the geometry is this file's own —
+ * but the WISDOM is not reinvented. The layer constant is imported from there
+ * rather than copied, and the host is zero-WIDTH for the same reason its host is
+ * zero-sized (`.widgets-container > * { pointer-events: auto }` is an outer-tree
+ * rule that beats `:host { pointer-events: none }`, so a host with a real box
+ * would swallow canvas clicks down the whole left side of the board). The
+ * click-away, the Escape-on-`std.host` scope and the disconnect cleanup are the
+ * same contracts, replicated in about thirty lines.
+ *
+ * ## What closing does, and does not
+ *
+ * X, Escape and click-away all close, on the FIRST gesture, and none of them
+ * touches the active senior tool: the panel is a way of reaching a command, not
+ * a mode. Invoking a row closes it too — the PO's default is one tap and back
+ * to the canvas.
+ *
+ * ## Who opens it
+ *
+ * `ArtefactCatalogueProvider`. This widget registers itself as the DEFAULT
+ * implementation ({@link artefactCatalogueDefaultExtension}); a host with its
+ * own sidebar registers `ArtefactCatalogueExtension(service)`, whose
+ * `di.override` wins, and this panel is then never asked to open.
+ */
+export declare class EdgelessArtefactCatalogueWidget extends WidgetComponent<RootBlockModel> {
+    static styles: import("lit").CSSResult;
+    /** Which framework's catalogue is on screen, or `null` when it is away. */
+    private accessor _owner;
+    /** The owner the body was last scrolled to the top for. */
+    private _scrolledFor;
+    get catalogueOpen(): boolean;
+    /**
+     * Show `owner`'s catalogue. Called through `ArtefactCatalogueProvider`, never
+     * from another widget's DOM — the sub-menu that opens it lives in a different
+     * tree, and the seam is what keeps a host's own sidebar substitutable.
+     */
+    openFor(owner: CommandOwner): void;
+    /**
+     * Put the panel away. Deliberately writes NOTHING but its own state: the
+     * senior tool the user armed before opening the catalogue is still armed
+     * after, whichever gesture closed it.
+     */
+    readonly closePanel: () => void;
+    /** Keep a gesture inside the panel from reaching the canvas behind it. */
+    private readonly _swallow;
+    private readonly _onDocumentPointerDown;
+    /**
+     * Escape is listened for on the EDITOR HOST, not on `document`: a host
+     * application keeps its own global Escape, and with the catalogue open the
+     * key dismisses the catalogue rather than clearing the canvas selection
+     * behind it. Same scope and same reasoning as `EditorAnchoredPanel`.
+     */
+    private readonly _onHostKeydown;
+    /**
+     * A wheel OVER THE PANEL scrolls the panel, never the board.
+     *
+     * Same bug and same fix as the violation bubble (PR #103, PO 02/08):
+     * `EdgelessRootBlock` takes `wheel` off the event dispatcher on the editor
+     * host and `preventDefault()`s unconditionally before panning — so a wheel
+     * over the catalogue's overflowing list panned the canvas instead of
+     * scrolling the twenty artefacts under the pointer (PO recette, 27/08/2026).
+     * One CAPTURE-phase listener on the host stops the event before the
+     * dispatcher sees it; no `preventDefault`, because the default action IS the
+     * panel scrolling.
+     *
+     * Narrower than the bubble's freeze, deliberately: the bubble owns the wheel
+     * everywhere while open (a reading gesture); the catalogue only claims the
+     * wheel over its own box — `composedPath` gate — and the canvas to its right
+     * keeps panning, because furnishing a diagram means looking around it.
+     */
+    private readonly _onHostWheel;
+    /**
+     * Idempotent, and called from both `firstUpdated` and a later
+     * `connectedCallback`: `WithDisposable` throws the group away on disconnect
+     * while lit runs `firstUpdated` exactly once.
+     */
+    private _wire;
+    connectedCallback(): void;
+    firstUpdated(): void;
+    /**
+     * On open: the panel takes the focus and the list starts at the top.
+     *
+     * The focus is what makes the panel reachable from a keyboard and audible to
+     * a screen reader — it carries the dialog's label, so the framework's name is
+     * read before the first artefact. `preventScroll` because the host is a
+     * zero-width box at the editor's origin and the browser would otherwise
+     * scroll the editor to "reveal" it.
+     *
+     * The scroll reset matters on the second open: a user who scrolled to the
+     * bottom of BPMN's twenty artefacts, closed, and opened the panel again for
+     * another framework would otherwise land mid-list with no idea what is above.
+     */
+    updated(): void;
+    /**
+     * The commands this panel draws: the owner's `'catalogue'` surface, minus the
+     * ones whose preconditions do not hold.
+     *
+     * Unavailable commands are DROPPED, not greyed out. A disabled row in a list
+     * of twenty is noise a reader has to step over on every pass, and the panel
+     * has no room to say why it is disabled; a command that comes back when the
+     * selection changes simply reappears.
+     */
+    private _commands;
+    /**
+     * The chord this command answers to on this platform, as the user would type
+     * it — or `null` for the many commands that ship keyless (and stay bindable).
+     *
+     * The host's override table is consulted, so a rebound command shows what it
+     * is actually bound to rather than what it shipped with, and a `'disabled'`
+     * entry shows nothing at all.
+     */
+    private _chord;
+    /**
+     * Run the command. The panel STAYS OPEN.
+     *
+     * `runCommand` is the one bottleneck (ADR 0008): the telemetry and the usage
+     * measure are emitted there, and `surface: 'catalogue'` is what makes this
+     * panel distinguishable from the sub-menu in the numbers.
+     *
+     * Staying open is the PO's call (recette, 27/08/2026), reversing the first
+     * default: a catalogue is where a user furnishes a diagram, and furnishing is
+     * several artefacts in a row — closing after each one turned that into
+     * open-click-reopen. The exits are unchanged and all one gesture: ×, Escape,
+     * or a click on the canvas.
+     */
+    private _invoke;
+    private _groupLabel;
+    private _renderEntry;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+}
+export declare const edgelessArtefactCatalogueWidget: import("../../store/index.js").ExtensionType;