@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/_pkgs/affine-widget-keyboard-toolbar/keyboard-tool-panel.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { SignalWatcher, WithDisposable } from '../global/lit/index.js';
-import { PropTypes, requiredProperties, ShadowlessElement, } from '../std/index.js';
+import { PropTypes, requiredProperties, ShadowlessElement } from '../std/index.js';
 import { html, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';

package/dist/_pkgs/affine-widget-linked-doc/import-doc/import-doc.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { CloseIcon, ExportToHTMLIcon, ExportToMarkdownIcon, HelpIcon, NewIcon, NotionIcon, } from '../../affine-components/icons/index.js';
-import { openFilesWith, openSingleFileWith, } from '../../affine-shared/utils/index.js';
+import { openFilesWith, openSingleFileWith } from '../../affine-shared/utils/index.js';
 import { WithDisposable } from '../../global/lit/index.js';
 import { html, LitElement } from 'lit';
 import { query, state } from 'lit/decorators.js';

package/dist/_pkgs/affine-widget-linked-doc/linked-doc-popover.js

@@ -46,7 +46,7 @@ import { property, query, queryAll, state } from 'lit/decorators.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import throttle from 'lodash-es/throttle.js';
 import { linkedDocPopoverStyles } from './styles.js';
-import { resolveSignal } from './utils.js';
+import { createLinkedDocKeydownInterceptor, resolveSignal } from './utils.js';
 let LinkedDocPopover = (() => {
     let _classDecorators = [requiredProperties({
             context: PropTypes.object,
@@ -162,20 +162,7 @@ let LinkedDocPopover = (() => {
             createKeydownObserver({
                 target: eventSource,
                 signal: keydownObserverAbortController.signal,
-                interceptor: (event, next) => {
-                    if (event.key === 'ArrowRight' || event.key === 'ArrowLeft') {
-                        event.preventDefault();
-                        event.stopPropagation();
-                        return;
-                    }
-                    if (event.key === 'Escape') {
-                        this.context.close();
-                        event.preventDefault();
-                        event.stopPropagation();
-                        return;
-                    }
-                    next();
-                },
+                interceptor: createLinkedDocKeydownInterceptor(() => this.context.close()),
                 onInput: isComposition => {
                     if (isComposition) {
                         this._updateLinkedDocGroup().catch(console.error);

package/dist/_pkgs/affine-widget-linked-doc/transformers/markdown.d.ts

@@ -1,4 +1,13 @@
-import type { ExtensionType, Schema, Store, Workspace } from '../../store/index.js';
+import type { DocMeta, ExtensionType, Schema, Store, Workspace } from '../../store/index.js';
+type ParsedFrontmatterMeta = Partial<Pick<DocMeta, 'title' | 'createDate' | 'updatedDate' | 'tags' | 'favorite'>>;
+/**
+ * Read the frontmatter off a markdown file and hand back the content without
+ * it, so the metadata never lands in the document as a paragraph of its own.
+ */
+export declare function parseFrontmatter(markdown: string): {
+    content: string;
+    meta: ParsedFrontmatterMeta;
+};
 type ImportMarkdownToBlockOptions = {
     doc: Store;
     markdown: string;

package/dist/_pkgs/affine-widget-linked-doc/transformers/markdown.js

@@ -3,7 +3,131 @@ import { Container } from '../../global/di/index.js';
 import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
 import { sha } from '../../global/utils/index.js';
 import { extMimeMap, Transformer } from '../../store/index.js';
-import { createAssetsArchive, download, Unzip } from './utils.js';
+import { createAssetsArchive, download, parseMatter, Unzip, } from './utils.js';
+/**
+ * The spellings the tools people export markdown from actually use. Anything
+ * else in the frontmatter is metadata we have no field for, and is dropped.
+ */
+const FRONTMATTER_KEYS = {
+    title: ['title', 'name'],
+    created: [
+        'created',
+        'createdat',
+        'created_at',
+        'createddate',
+        'created_date',
+        'creationdate',
+        'date',
+        'time',
+    ],
+    updated: [
+        'updated',
+        'updatedat',
+        'updated_at',
+        'updateddate',
+        'updated_date',
+        'modified',
+        'modifiedat',
+        'modified_at',
+        'lastmodified',
+        'last_modified',
+        'lastedited',
+        'last_edited',
+        'lasteditedtime',
+        'last_edited_time',
+    ],
+    tags: ['tags', 'tag', 'categories', 'category', 'labels', 'keywords'],
+    favorite: ['favorite', 'favourite', 'star', 'starred', 'pinned'],
+};
+const truthyStrings = new Set(['true', 'yes', 'y', '1', 'on']);
+const falsyStrings = new Set(['false', 'no', 'n', '0', 'off']);
+function parseBoolean(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (truthyStrings.has(normalized))
+        return true;
+    if (falsyStrings.has(normalized))
+        return false;
+    return undefined;
+}
+function parseTimestamp(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const seconds = Number(value);
+    if (value.trim() && !Number.isNaN(seconds)) {
+        // A bare number is an epoch: in seconds unless it is far too large for one.
+        return seconds > 1e10 ? seconds : Math.round(seconds * 1000);
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function parseTags(value) {
+    const tags = (Array.isArray(value) ? value : value.split(/[,;]+/))
+        .map(tag => tag.trim())
+        .filter(Boolean);
+    return tags.length ? [...new Set(tags)] : undefined;
+}
+function buildMetaFromFrontmatter(data) {
+    const meta = {};
+    for (const [rawKey, value] of Object.entries(data)) {
+        const key = rawKey.trim().toLowerCase();
+        if (FRONTMATTER_KEYS.title.includes(key) && typeof value === 'string') {
+            const title = value.trim();
+            if (title)
+                meta.title = title;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.created.includes(key)) {
+            const timestamp = parseTimestamp(value);
+            if (timestamp !== undefined)
+                meta.createDate = timestamp;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.updated.includes(key)) {
+            const timestamp = parseTimestamp(value);
+            if (timestamp !== undefined)
+                meta.updatedDate = timestamp;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.tags.includes(key)) {
+            const tags = parseTags(value);
+            if (tags)
+                meta.tags = tags;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.favorite.includes(key)) {
+            const favorite = parseBoolean(value);
+            if (favorite !== undefined)
+                meta.favorite = favorite;
+        }
+    }
+    return meta;
+}
+/**
+ * Read the frontmatter off a markdown file and hand back the content without
+ * it, so the metadata never lands in the document as a paragraph of its own.
+ */
+export function parseFrontmatter(markdown) {
+    try {
+        const parsed = parseMatter(markdown);
+        if (!parsed) {
+            return { content: markdown, meta: {} };
+        }
+        return {
+            content: parsed.body,
+            meta: buildMetaFromFrontmatter(parsed.metadata),
+        };
+    }
+    catch {
+        return { content: markdown, meta: {} };
+    }
+}
+function applyMetaPatch(collection, docId, meta) {
+    if (Object.keys(meta).length) {
+        collection.meta.setDocMeta(docId, meta);
+    }
+}
 function getProvider(extensions) {
     const container = new Container();
     extensions.forEach(ext => {
@@ -90,6 +214,7 @@ async function importMarkdownToBlock({ doc, markdown, blockId, extensions, }) {
  * @returns A Promise that resolves to the ID of the newly created doc, or undefined if import fails
  */
 async function importMarkdownToDoc({ collection, schema, markdown, fileName, extensions, }) {
+    const { content, meta } = parseFrontmatter(markdown);
     const provider = getProvider(extensions);
     const job = new Transformer({
         schema,
@@ -101,18 +226,19 @@ async function importMarkdownToDoc({ collection, schema, markdown, fileName, ext
         },
         middlewares: [
             defaultImageProxyMiddleware,
-            fileNameMiddleware(fileName),
+            fileNameMiddleware(meta.title ?? fileName),
             docLinkBaseURLMiddleware(collection.id),
         ],
     });
     const mdAdapter = new MarkdownAdapter(job, provider);
     const page = await mdAdapter.toDoc({
-        file: markdown,
+        file: content,
         assets: job.assetsManager,
     });
     if (!page) {
         return;
     }
+    applyMetaPatch(collection, page.id, meta);
     return page.id;
 }
 /**
@@ -159,6 +285,7 @@ async function importMarkdownZip({ collection, schema, imported, extensions, })
     await Promise.all(markdownBlobs.map(async (markdownFile) => {
         const { filename, contentBlob, fullPath } = markdownFile;
         const fileNameWithoutExt = filename.replace(/\.[^/.]+$/, '');
+        const { content, meta } = parseFrontmatter(await contentBlob.text());
         const job = new Transformer({
             schema,
             blobCRUD: collection.blobSync,
@@ -169,7 +296,7 @@ async function importMarkdownZip({ collection, schema, imported, extensions, })
             },
             middlewares: [
                 defaultImageProxyMiddleware,
-                fileNameMiddleware(fileNameWithoutExt),
+                fileNameMiddleware(meta.title ?? fileNameWithoutExt),
                 docLinkBaseURLMiddleware(collection.id),
                 filePathMiddleware(fullPath),
             ],
@@ -188,12 +315,12 @@ async function importMarkdownZip({ collection, schema, imported, extensions, })
             }
         }
         const mdAdapter = new MarkdownAdapter(job, provider);
-        const markdown = await contentBlob.text();
         const doc = await mdAdapter.toDoc({
-            file: markdown,
+            file: content,
             assets: job.assetsManager,
         });
         if (doc) {
+            applyMetaPatch(collection, doc.id, meta);
             docIds.push(doc.id);
         }
     }));

package/dist/_pkgs/affine-widget-linked-doc/transformers/utils.d.ts

@@ -21,4 +21,14 @@ export declare class Unzip {
     }, void, unknown>;
 }
 export declare function createAssetsArchive(assetsMap: Map<string, Blob>, assetsIds: string[]): Promise<Zip>;
+export type FrontmatterValue = string | string[];
+/**
+ * Split a markdown file into its frontmatter metadata and the content below,
+ * or `null` when it opens with no frontmatter at all.
+ */
+export declare const parseMatter: (contents: string) => {
+    matter: string;
+    body: string;
+    metadata: Record<string, FrontmatterValue>;
+} | null;
 export declare function download(blob: Blob, name: string): void;

package/dist/_pkgs/affine-widget-linked-doc/transformers/utils.js

@@ -52,6 +52,42 @@ export class Zip {
         });
     }
 }
+const strictUtf8Decoder = new TextDecoder('utf-8', { fatal: true });
+/**
+ * Repair an entry name that was decoded as Latin-1.
+ *
+ * fflate follows the zip spec: unless an entry sets the UTF-8 flag (general
+ * purpose bit 11) its name is decoded as Latin-1. Common archivers — the macOS
+ * `zip` tool among them — write UTF-8 bytes without ever setting that flag, so
+ * a CJK name comes back as mojibake, one character per raw byte.
+ *
+ * Such a name only ever holds code points in the 0x00-0xff range, so it can be
+ * turned back into the original bytes and decoded again, strictly, as UTF-8.
+ * Anything that is not valid UTF-8 — a name that really was Latin-1, or one
+ * fflate already decoded correctly — is left untouched.
+ */
+function fixFileNameEncoding(fileName) {
+    const bytes = new Uint8Array(fileName.length);
+    let hasNonAscii = false;
+    for (let i = 0; i < fileName.length; i++) {
+        const code = fileName.charCodeAt(i);
+        // A code point above 0xff cannot come out of a Latin-1 decode: the name was
+        // already decoded from its declared UTF-8 bytes, nothing to repair.
+        if (code > 0xff)
+            return fileName;
+        if (code > 0x7f)
+            hasNonAscii = true;
+        bytes[i] = code;
+    }
+    if (!hasNonAscii)
+        return fileName;
+    try {
+        return strictUtf8Decoder.decode(bytes);
+    }
+    catch {
+        return fileName;
+    }
+}
 export class Unzip {
     async load(blob) {
         this.unzipped = fflate.unzipSync(new Uint8Array(await blob.arrayBuffer()));
@@ -60,15 +96,17 @@ export class Unzip {
         const keys = Object.keys(this.unzipped ?? {});
         let index = 0;
         while (keys.length) {
-            const path = keys.shift();
-            if (path.includes('__MACOSX') || path.includes('DS_Store')) {
+            const rawPath = keys.shift();
+            if (rawPath.includes('__MACOSX') || rawPath.includes('DS_Store')) {
                 continue;
             }
+            const data = this.unzipped[rawPath];
+            const path = fixFileNameEncoding(rawPath);
             const lastSplitIndex = path.lastIndexOf('/');
             const fileName = path.substring(lastSplitIndex + 1);
             const fileExt = fileName.lastIndexOf('.') === -1 ? '' : fileName.split('.').at(-1);
             const mime = extMimeMap.get(fileExt ?? '');
-            const content = new File([this.unzipped[path]], fileName, {
+            const content = new File([data], fileName, {
                 type: mime ?? '',
             });
             yield { path, content, index };
@@ -86,6 +124,85 @@ export async function createAssetsArchive(assetsMap, assetsIds) {
     }
     return zip;
 }
+/**
+ * A frontmatter block, and only at the very top of the file: a `---` further
+ * down is a horizontal rule and the reader expects to see it.
+ */
+const FRONTMATTER = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+const unquote = (value) => {
+    const trimmed = value.trim();
+    const quote = trimmed[0];
+    if (trimmed.length >= 2 &&
+        (quote === '"' || quote === "'") &&
+        trimmed.endsWith(quote)) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+};
+/**
+ * Parse the flat subset of YAML a frontmatter block actually uses: `key: value`
+ * pairs, flow sequences (`tags: [a, b]`) and block sequences. Every scalar
+ * stays a string — the caller knows which of them is a date, a flag or a list,
+ * and a full YAML parser would only add a dependency to guess it for us.
+ * Nested mappings are ignored rather than flattened.
+ */
+const parseFrontmatterBody = (source) => {
+    const data = {};
+    let listKey = null;
+    for (const line of source.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const item = trimmed.match(/^-\s+(.*)$/);
+        if (item && listKey) {
+            const list = data[listKey];
+            const value = unquote(item[1]);
+            if (Array.isArray(list))
+                list.push(value);
+            else
+                data[listKey] = [value];
+            continue;
+        }
+        // Keys are read at the top level only, so an indented mapping under a key
+        // does not silently become a sibling of it.
+        const entry = line.match(/^([A-Za-z0-9_][A-Za-z0-9_ -]*):(.*)$/);
+        if (!entry) {
+            listKey = null;
+            continue;
+        }
+        const key = entry[1].trim();
+        const value = entry[2].trim();
+        listKey = null;
+        if (!value) {
+            // Either a block sequence follows, or a nested mapping we will ignore.
+            data[key] = [];
+            listKey = key;
+            continue;
+        }
+        const flow = value.match(/^\[(.*)\]$/);
+        data[key] = flow
+            ? flow[1].split(',').map(unquote).filter(Boolean)
+            : unquote(value);
+    }
+    return Object.keys(data).length ? data : null;
+};
+/**
+ * Split a markdown file into its frontmatter metadata and the content below,
+ * or `null` when it opens with no frontmatter at all.
+ */
+export const parseMatter = (contents) => {
+    const match = contents.match(FRONTMATTER);
+    if (!match)
+        return null;
+    const metadata = parseFrontmatterBody(match[1]);
+    if (!metadata)
+        return null;
+    return {
+        matter: match[1],
+        body: contents.slice(match[0].length),
+        metadata,
+    };
+};
 export function download(blob, name) {
     const element = document.createElement('a');
     element.setAttribute('download', name);

package/dist/_pkgs/affine-widget-linked-doc/utils.d.ts

@@ -1,2 +1,14 @@
 import { Signal } from '@preact/signals-core';
 export declare function resolveSignal<T>(data: T | Signal<T>): T;
+/**
+ * The keydown interceptor of the linked-doc popover.
+ *
+ * The shared keydown observer treats "a modifier plus any other key" as a
+ * reason to abort, so every key the popover wants to survive has to be caught
+ * here first — which is why changing the OS keyboard LAYOUT used to close the
+ * popover: on Windows and Linux, Alt+Shift arrives as a keydown whose `key` is
+ * `GroupNext` or `GroupPrevious`, and that reads as modifier + key.
+ *
+ * @param close - what `Escape` does; the popover's own `close`.
+ */
+export declare function createLinkedDocKeydownInterceptor(close: () => void): (event: KeyboardEvent, next: () => void) => void;

package/dist/_pkgs/affine-widget-linked-doc/utils.js

@@ -2,3 +2,36 @@ import { Signal } from '@preact/signals-core';
 export function resolveSignal(data) {
     return data instanceof Signal ? data.value : data;
 }
+/**
+ * The keydown interceptor of the linked-doc popover.
+ *
+ * The shared keydown observer treats "a modifier plus any other key" as a
+ * reason to abort, so every key the popover wants to survive has to be caught
+ * here first — which is why changing the OS keyboard LAYOUT used to close the
+ * popover: on Windows and Linux, Alt+Shift arrives as a keydown whose `key` is
+ * `GroupNext` or `GroupPrevious`, and that reads as modifier + key.
+ *
+ * @param close - what `Escape` does; the popover's own `close`.
+ */
+export function createLinkedDocKeydownInterceptor(close) {
+    return (event, next) => {
+        if (event.key === 'GroupNext' || event.key === 'GroupPrevious') {
+            // The user switched keyboard layout, not documents. Swallow it and leave
+            // the query, the selection and the popover exactly as they were.
+            event.stopPropagation();
+            return;
+        }
+        if (event.key === 'ArrowRight' || event.key === 'ArrowLeft') {
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+        }
+        if (event.key === 'Escape') {
+            close();
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+        }
+        next();
+    };
+}

package/dist/_pkgs/affine-widget-page-dragging-area/index.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { ViewportElementProvider } from '../affine-shared/services/index.js';
-import { autoScroll, getScrollContainer, } from '../affine-shared/utils/index.js';
+import { autoScroll, getScrollContainer } from '../affine-shared/utils/index.js';
 import { BlockComponent, BlockSelection, WidgetComponent, WidgetViewExtension, } from '../std/index.js';
 import { html, nothing } from 'lit';
 import { state } from 'lit/decorators.js';

package/dist/_pkgs/affine-widget-remote-selection/doc/doc-remote-selection.js

@@ -36,7 +36,7 @@ import { AttachmentBlockModel, BookmarkBlockModel, CodeBlockModel, DatabaseBlock
 import { getSelectionRectsCommand } from '../../affine-shared/commands/index.js';
 import { EMBED_BLOCK_MODEL_LIST } from '../../affine-shared/consts/index.js';
 import { matchModels } from '../../affine-shared/utils/index.js';
-import { BlockSelection, TextSelection, WidgetComponent, } from '../../std/index.js';
+import { BlockSelection, TextSelection, WidgetComponent } from '../../std/index.js';
 import { GfxControllerIdentifier } from '../../std/gfx/index.js';
 import { computed, effect } from '@preact/signals-core';
 import { css, html, nothing } from 'lit';

package/dist/_pkgs/affine-widget-remote-selection/edgeless/index.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
-import { getSelectedRect, isTopLevelBlock, requestThrottledConnectedFrame, } from '../../affine-shared/utils/index.js';
+import { getSelectedRect, isTopLevelBlock, overlayScale, requestThrottledConnectedFrame, } from '../../affine-shared/utils/index.js';
 import { MultiCursorDuotoneIcon } from '@blocksuite/icons/lit';
 import { WidgetComponent } from '../../std/index.js';
 import { GfxControllerIdentifier } from '../../std/gfx/index.js';
@@ -252,9 +252,11 @@ let EdgelessRemoteSelectionWidget = (() => {
                 this._remoteRects = remoteRects;
             };
             this._updateTransform = requestThrottledConnectedFrame(() => {
-                const { translateX, translateY, zoom } = this.gfx.viewport;
-                this.style.setProperty('--v-zoom', `${zoom}`);
-                this.style.setProperty('transform', `translate(${translateX}px, ${translateY}px) scale(var(--v-zoom))`);
+                const { translateX, translateY, viewScale } = this.gfx.viewport;
+                // Stated in the scaled space of the container, like every other overlay
+                // and like `GfxBlockComponent.getCSSTransform`.
+                this.style.setProperty('--v-zoom', `${overlayScale(this.gfx.viewport)}`);
+                this.style.setProperty('transform', `translate(${translateX / viewScale}px, ${translateY / viewScale}px) scale(var(--v-zoom))`);
             }, this);
             this.#_remoteCursors_accessor_storage = __runInitializers(this, __remoteCursors_initializers, new Map());
             this.#_remoteRects_accessor_storage = (__runInitializers(this, __remoteCursors_extraInitializers), __runInitializers(this, __remoteRects_initializers, new Map()));

package/dist/_pkgs/affine-widget-slash-menu/slash-menu-popover.js

@@ -48,7 +48,7 @@ import groupBy from 'lodash-es/groupBy.js';
 import throttle from 'lodash-es/throttle.js';
 import { AFFINE_SLASH_MENU_MAX_HEIGHT, AFFINE_SLASH_MENU_TOOLTIP_TIMEOUT, AFFINE_SLASH_MENU_TRIGGER_KEY, } from './consts.js';
 import { slashItemToolTipStyle, styles } from './styles.js';
-import { isActionItem, isSubMenuItem, parseGroup, slashItemClassName, } from './utils.js';
+import { isActionItem, isSubMenuItem, isTextInputKey, parseGroup, slashItemClassName, } from './utils.js';
 let SlashMenu = (() => {
     let _classSuper = WithDisposable(LitElement);
     let __filteredItems_decorators;
@@ -217,9 +217,13 @@ let SlashMenu = (() => {
                         // The IME case of above
                         return;
                     }
-                    if (key !== 'Backspace' && this._queryState === 'no_result') {
-                        // if the following key is not the backspace key,
-                        // the slash menu will be closed
+                    if (key !== 'Backspace' &&
+                        this._queryState === 'no_result' &&
+                        !isTextInputKey(event)) {
+                        // The search found nothing and the user is not typing: whatever this
+                        // key is, it is not narrowing the query, so the slash menu closes.
+                        // Typing keeps it alive — the query state is refreshed asynchronously
+                        // and would otherwise be judged stale.
                         this.abortController.abort();
                         return;
                     }

package/dist/_pkgs/affine-widget-slash-menu/utils.d.ts

@@ -1,4 +1,13 @@
 import type { SlashMenuActionItem, SlashMenuConfig, SlashMenuContext, SlashMenuItem, SlashMenuSubMenu } from './types.js';
+/**
+ * Whether a keydown is the user typing one more character into the query.
+ *
+ * The slash menu closes on the first key that follows an empty result, which is
+ * right for a command key and wrong for a letter: the query state is computed
+ * asynchronously, so a letter typed just after a deletion is judged against a
+ * STALE `no_result` and kills a menu that was about to find matches again.
+ */
+export declare function isTextInputKey(event: KeyboardEvent): boolean;
 export declare function isActionItem(item: SlashMenuItem): item is SlashMenuActionItem;
 export declare function isSubMenuItem(item: SlashMenuItem): item is SlashMenuSubMenu;
 export declare function slashItemClassName({ name }: SlashMenuItem): string;

package/dist/_pkgs/affine-widget-slash-menu/utils.js

@@ -1,3 +1,27 @@
+/**
+ * Whether a keydown is the user typing one more character into the query.
+ *
+ * The slash menu closes on the first key that follows an empty result, which is
+ * right for a command key and wrong for a letter: the query state is computed
+ * asynchronously, so a letter typed just after a deletion is judged against a
+ * STALE `no_result` and kills a menu that was about to find matches again.
+ */
+export function isTextInputKey(event) {
+    // Keys combined with modifiers are not text input.
+    if (event.ctrlKey || event.metaKey || event.altKey)
+        return false;
+    // During IME composition, the query is updated by the input / composition
+    // hooks, never by the keydown.
+    if (event.isComposing)
+        return false;
+    // Only single-character keys are text input: `Enter`, `Tab`, `F2`… are not.
+    if (event.key.length !== 1)
+        return false;
+    // Space still closes the slash menu — unchanged behaviour.
+    if (event.key === ' ')
+        return false;
+    return true;
+}
 export function isActionItem(item) {
     return 'action' in item;
 }

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

@@ -3,6 +3,7 @@ import { ToolbarContext } from '../affine-shared/services/index.js';
 import { type BlockComponent, WidgetComponent } from '../std/index.js';
 import { type GfxController, type GfxModel } from '../std/gfx/index.js';
 import type { ReferenceElement, SideObject } from '@floating-ui/dom';
+import { ToolbarFitter } from './utils.js';
 export declare const AFFINE_TOOLBAR_WIDGET = "affine-toolbar-widget";
 export declare class AffineToolbarWidget extends WidgetComponent {
     static styles: import("lit").CSSResult;
@@ -14,6 +15,11 @@ export declare class AffineToolbarWidget extends WidgetComponent {
     setReferenceElementWithElements(gfx: GfxController, elements: GfxModel[]): void;
     updateWithSurface(ctx: ToolbarContext, activated: boolean, elementIds: string[]): void;
     toolbar: EditorToolbar;
+    /**
+     * Keeps the row on one line: it renders the toolbar, measures it and hands
+     * the least important entries to the "⋮" menu when the room runs out.
+     */
+    fitter: ToolbarFitter;
     get toolbarRegistry(): import("../affine-shared/services/index.js").ToolbarRegistryExtension;
     connectedCallback(): void;
 }