@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/_pkgs/data-view/view-presets/table/pc/group.js

@@ -34,17 +34,18 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { menu, popFilterableSimpleMenu, popupTargetFromElement, } from '../../../../affine-components/context-menu/index.js';
 import { SignalWatcher, WithDisposable } from '../../../../global/lit/index.js';
-import { PlusIcon } from '@blocksuite/icons/lit';
+import { PlusIcon, ToggleDownIcon, ToggleRightIcon, } from '@blocksuite/icons/lit';
 import { ShadowlessElement } from '../../../../std/index.js';
-import { effect } from '@preact/signals-core';
+import { effect, signal } from '@preact/signals-core';
 import { cssVarV2 } from '@toeverything/theme/v2';
-import { css, html, unsafeCSS } from 'lit';
+import { css, html, nothing, unsafeCSS } from 'lit';
 import { property, query } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { GroupTitle } from '../../../core/group-by/group-title.js';
 import { createDndContext } from '../../../core/utils/wc-dnd/dnd-context.js';
 import { defaultActivators } from '../../../core/utils/wc-dnd/sensors/index.js';
 import { linearMove } from '../../../core/utils/wc-dnd/utils/linear-move.js';
+import { getCollapsedState, setCollapsedState } from '../collapsed-state.js';
 import { LEFT_TOOL_BAR_WIDTH } from '../consts.js';
 import { TableViewAreaSelection } from '../selection.js';
 import { DataViewColumnPreview } from './header/column-renderer.js';
@@ -85,6 +86,28 @@ const styles = css `
     line-height: 20px;
     color: var(--affine-text-secondary-color);
   }
+
+  .group-toggle-btn {
+    width: 20px;
+    height: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background-color 150ms cubic-bezier(0.42, 0, 1, 1);
+  }
+
+  .group-toggle-btn:hover {
+    background: var(--affine-hover-color);
+  }
+
+  .group-toggle-btn svg {
+    width: 16px;
+    height: 16px;
+    flex-shrink: 0;
+    user-select: none;
+  }
 `;
 let TableGroup = (() => {
     let _classSuper = SignalWatcher(WithDisposable(ShadowlessElement));
@@ -109,6 +132,20 @@ let TableGroup = (() => {
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static { this.styles = styles; }
+        /**
+         * Read the stored collapsed state once, as soon as the group and its view
+         * are both known. Reading it earlier would key the lookup on a missing view
+         * id and pin the group open.
+         */
+        _loadCollapsedState() {
+            if (this.storageLoaded)
+                return;
+            this.storageLoaded = true;
+            const view = this.tableViewLogic?.view;
+            if (!view)
+                return;
+            this.collapsed$.value = getCollapsedState(view.id, this.group?.key ?? 'all');
+        }
         #group_accessor_storage;
         get group() { return this.#group_accessor_storage; }
         set group(value) { this.#group_accessor_storage = value; }
@@ -153,12 +190,25 @@ let TableGroup = (() => {
       </affine-database-column-stats>
     `;
         }
+        willUpdate(changed) {
+            super.willUpdate(changed);
+            if (!this.storageLoaded &&
+                (changed.has('group') || changed.has('tableViewLogic'))) {
+                this._loadCollapsedState();
+            }
+        }
         connectedCallback() {
             super.connectedCallback();
             this.showIndicator();
+            this._loadCollapsedState();
         }
         render() {
-            return this.renderRows(this.rows);
+            // Collapsed, only the header survives — the column header, the rows, the
+            // add-row affordance and the stats row all fold away with them.
+            return html `
+      ${this.collapsed$.value ? this.renderGroupHeader() : nothing}
+      ${this.collapsed$.value ? nothing : this.renderRows(this.rows)}
+    `;
         }
         #rowsContainer_accessor_storage;
         get rowsContainer() { return this.#rowsContainer_accessor_storage; }
@@ -171,6 +221,17 @@ let TableGroup = (() => {
         }
         constructor() {
             super(...arguments);
+            this.collapsed$ = signal(false);
+            this.storageLoaded = false;
+            this._toggleCollapse = (e) => {
+                e?.stopPropagation();
+                const next = !this.collapsed$.value;
+                this.collapsed$.value = next;
+                const view = this.tableViewLogic?.view;
+                if (view) {
+                    setCollapsedState(view.id, this.group?.key ?? 'all', next);
+                }
+            };
             this.clickAddRow = () => {
                 this.view.rowAdd('end', this.group?.key);
                 const selectionController = this.tableViewLogic.selectionController;
@@ -236,8 +297,28 @@ let TableGroup = (() => {
                 }
                 return html `
       <div
-        style="position: sticky;left: 0;width: max-content;padding: 6px 0;margin-bottom: 4px;display:flex;align-items:center;gap: 12px;max-width: 400px"
+        style="position: sticky;left: 0;width: max-content;padding: 6px 0;margin-bottom: 4px;display:flex;align-items:center;gap: 8px;max-width: 400px"
       >
+        <div
+          class="group-toggle-btn"
+          role="button"
+          aria-expanded=${this.collapsed$.value ? 'false' : 'true'}
+          aria-label=${this.collapsed$.value
+                    ? 'Expand group'
+                    : 'Collapse group'}
+          tabindex="0"
+          @click=${this._toggleCollapse}
+          @keydown=${(e) => {
+                    if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        this._toggleCollapse();
+                    }
+                }}
+        >
+          ${this.collapsed$.value
+                    ? ToggleRightIcon({ width: '16px', height: '16px' })
+                    : ToggleDownIcon({ width: '16px', height: '16px' })}
+        </div>
         ${GroupTitle(this.group, {
                     readonly: this.view.readonly$.value,
                     clickAdd: this.clickAddRowInStart,

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/controller/hotkeys.d.ts

@@ -7,5 +7,6 @@ export declare class TableHotkeysController implements ReactiveController {
     get selectionController(): import("./selection.js").TableSelectionController;
     constructor(logic: VirtualTableViewUILogic);
     get host(): import("../table-view-ui-logic.js").TableViewUI | undefined;
+    private _handleDeleteOrBackspace;
     hostConnected(): void;
 }

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/controller/hotkeys.js

@@ -14,39 +14,26 @@ export class TableHotkeysController {
     get host() {
         return this.logic.ui$.value;
     }
-    hostConnected() {
-        this.disposables.add(this.logic.bindHotkey({
-            Backspace: () => {
-                const selection = this.selectionController.selection;
-                if (!selection) {
-                    return;
-                }
-                if (TableViewRowSelection.is(selection)) {
-                    const rows = TableViewRowSelection.rowsIds(selection);
-                    this.selectionController.selection = undefined;
-                    this.logic.view.rowsDelete(rows);
-                    this.logic.ui$.value?.requestUpdate();
-                    return;
-                }
-                const { focus, rowsSelection, columnsSelection, isEditing, groupKey, } = selection;
-                if (focus && !isEditing) {
-                    if (rowsSelection && columnsSelection) {
-                        // multi cell
-                        for (let i = rowsSelection.start; i <= rowsSelection.end; i++) {
-                            const { start, end } = columnsSelection;
-                            for (let j = start; j <= end; j++) {
-                                const container = this.selectionController.getCellContainer(groupKey, i, j);
-                                const rowId = container?.dataset.rowId;
-                                const columnId = container?.dataset.columnId;
-                                if (rowId && columnId) {
-                                    container?.column$.value?.valueSetFromString(rowId, '');
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        // single cell
-                        const container = this.selectionController.getCellContainer(groupKey, focus.rowIndex, focus.columnIndex);
+    _handleDeleteOrBackspace() {
+        const selection = this.selectionController.selection;
+        if (!selection) {
+            return;
+        }
+        if (TableViewRowSelection.is(selection)) {
+            const rows = TableViewRowSelection.rowsIds(selection);
+            this.selectionController.selection = undefined;
+            this.logic.view.rowsDelete(rows);
+            this.logic.ui$.value?.requestUpdate();
+            return;
+        }
+        const { focus, rowsSelection, columnsSelection, isEditing, groupKey } = selection;
+        if (focus && !isEditing) {
+            if (rowsSelection && columnsSelection) {
+                // multi cell
+                for (let i = rowsSelection.start; i <= rowsSelection.end; i++) {
+                    const { start, end } = columnsSelection;
+                    for (let j = start; j <= end; j++) {
+                        const container = this.selectionController.getCellContainer(groupKey, i, j);
                         const rowId = container?.dataset.rowId;
                         const columnId = container?.dataset.columnId;
                         if (rowId && columnId) {
@@ -54,6 +41,25 @@ export class TableHotkeysController {
                         }
                     }
                 }
+            }
+            else {
+                // single cell
+                const container = this.selectionController.getCellContainer(groupKey, focus.rowIndex, focus.columnIndex);
+                const rowId = container?.dataset.rowId;
+                const columnId = container?.dataset.columnId;
+                if (rowId && columnId) {
+                    container?.column$.value?.valueSetFromString(rowId, '');
+                }
+            }
+        }
+    }
+    hostConnected() {
+        this.disposables.add(this.logic.bindHotkey({
+            Backspace: () => {
+                this._handleDeleteOrBackspace();
+            },
+            Delete: () => {
+                this._handleDeleteOrBackspace();
             },
             Escape: () => {
                 const selection = this.selectionController.selection;

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/group/top/group-title.js

@@ -19,9 +19,9 @@ export const GroupTitle = (groupData, ops) => {
     }
     const icon = groupData.value == null
         ? ''
-        : html ` <uni-lit
-          class="${groupHeaderIcon}"
-          .uni="${groupData.property.icon}"
+        : html ` <uni-lit
+          class="${groupHeaderIcon}"
+          .uni="${groupData.property.icon}"
         ></uni-lit>`;
     const props = {
         group: groupData,
@@ -29,25 +29,25 @@ export const GroupTitle = (groupData, ops) => {
     };
     const showColumnName = groupData.property.type$.value === 'checkbox';
     const columnName = showColumnName
-        ? html `<span class="${groupHeaderTitle}"
-        >${groupData.property.name$.value}</span
+        ? html `<span class="${groupHeaderTitle}"
+        >${groupData.property.name$.value}</span
       >`
         : nothing;
     const opsClass = clsx(ops.groupHover && show, groupHeaderOps);
-    return html `
-    <div class="${groupTitleRow}">
-      ${icon} ${renderUniLit(view, props)} ${columnName}
-      ${GroupHeaderCount(groupData)}
-    </div>
+    return html `
+    <div class="${groupTitleRow}">
+      ${icon} ${renderUniLit(view, props)} ${columnName}
+      ${GroupHeaderCount(groupData)}
+    </div>
     ${!ops.readonly
-        ? html ` <div class="${opsClass}">
-          <div @click="${ops.clickAdd}" class="${groupHeaderOp}">
-            ${PlusIcon()}
-          </div>
-          <div @click="${ops.clickOps}" class="${groupHeaderOp}">
-            ${MoreHorizontalIcon()}
-          </div>
+        ? html ` <div class="${opsClass}">
+          <div @click="${ops.clickAdd}" class="${groupHeaderOp}">
+            ${PlusIcon()}
+          </div>
+          <div @click="${ops.clickOps}" class="${groupHeaderOp}">
+            ${MoreHorizontalIcon()}
+          </div>
         </div>`
-        : nothing}
+        : nothing}
   `;
 };

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/row/cell.d.ts

@@ -17,6 +17,9 @@ export declare class DatabaseCellContainer extends DatabaseCellContainer_base {
     isRowSelected$: import("@preact/signals-core").ReadonlySignal<boolean>;
     isSelected(selection: TableViewSelectionWithType): boolean;
     render(): import("lit-html").TemplateResult | undefined;
+    private _tagDraft;
+    setTagDraft(value: string): void;
+    consumeTagDraft(): string | undefined;
     isEditing$: import("@preact/signals-core").Signal<boolean>;
     rowIndex$: import("@preact/signals-core").ReadonlySignal<number>;
     columnIndex$: import("@preact/signals-core").ReadonlySignal<number>;

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/row/cell.js

@@ -147,6 +147,14 @@ let DatabaseCellContainer = (() => {
                 },
             });
         }
+        setTagDraft(value) {
+            this._tagDraft = value;
+        }
+        consumeTagDraft() {
+            const value = this._tagDraft;
+            this._tagDraft = undefined;
+            return value;
+        }
         get rowId() {
             return this.gridCell.row.rowId;
         }

package/dist/_pkgs/data-view/view-presets/table/table-view-manager.js

@@ -154,7 +154,9 @@ export class TableSingleView extends SingleViewBase {
     }
     isShow(rowId) {
         if (this.filter$.value?.conditions.length) {
-            const rowMap = Object.fromEntries(this.properties$.value.map(column => [
+            // Filters are evaluated against every property of the view, hidden ones
+            // included: hiding a column must not silently drop the condition on it.
+            const rowMap = Object.fromEntries(this.propertiesRaw$.value.map(column => [
                 column.id,
                 column.cellGetOrCreate(rowId).jsonValue$.value,
             ]));

package/dist/_pkgs/data-view/view-presets/table/utils.d.ts

@@ -1,9 +1,12 @@
+import type { ReadonlySignal } from '@preact/signals-core';
 import type { TableViewSelectionWithType } from './selection.js';
 export interface TableCell {
     rowId: string;
+    setTagDraft?(value: string): void;
 }
 export type ColumnAccessor<T extends TableCell> = (cell: T) => {
     valueSetFromString(rowId: string, value: string): void;
+    type$: ReadonlySignal<string>;
 } | undefined;
 export interface StartEditOptions<T extends TableCell> {
     event: KeyboardEvent;

package/dist/_pkgs/data-view/view-presets/table/utils.js

@@ -1,4 +1,10 @@
+import { multiSelectPropertyType } from '../../property-presets/multi-select/define.js';
+import { selectPropertyType } from '../../property-presets/select/define.js';
 import { TableViewRowSelection } from './selection.js';
+const TAG_COLUMN_TYPES = new Set([
+    selectPropertyType.type,
+    multiSelectPropertyType.type,
+]);
 export function handleCharStartEdit(options) {
     const { event, selection, getCellContainer, updateSelection, getColumn } = options;
     const target = event.target;
@@ -15,7 +21,16 @@ export function handleCharStartEdit(options) {
         const cell = getCellContainer(selection.groupKey, selection.focus.rowIndex, selection.focus.columnIndex);
         if (cell) {
             const column = getColumn(cell);
-            column?.valueSetFromString(cell.rowId, event.key);
+            if (column) {
+                if (TAG_COLUMN_TYPES.has(column.type$.value) && cell.setTagDraft) {
+                    // A tag cell has no free-text value to write into: hand the typed
+                    // character to the cell so the tag picker opens searching for it.
+                    cell.setTagDraft(event.key);
+                }
+                else {
+                    column.valueSetFromString(cell.rowId, event.key);
+                }
+            }
             updateSelection({ ...selection, isEditing: true });
             event.preventDefault();
             return true;

package/dist/_pkgs/data-view/widget-presets/tools/presets/view-options/view-options.js

@@ -236,7 +236,9 @@ export const popViewOptions = (target, dataViewLogic, onClose) => {
                   `,
                                 select: () => {
                                     const id = view.manager.currentViewId$.value;
-                                    if (!id) {
+                                    // Re-picking the current layout would reset the view to the
+                                    // defaults of its own type, dropping widths and filters.
+                                    if (!id || meta.type === view.type) {
                                         return;
                                     }
                                     view.manager.viewChangeType(id, meta.type);

package/dist/_pkgs/global/gfx/curve.js

@@ -102,9 +102,10 @@ export function getBezierNearestPoint(values, point) {
     return pointOnCurve;
 }
 export function getBezierParameters(points) {
-    // Fallback for degenerate Bezier curve (all points are at the same position)
-    if (points.length === 1) {
-        const point = points[0];
+    // Fallback for degenerate Bezier curve (empty path or all points at the
+    // same position)
+    if (points.length <= 1) {
+        const point = points[0] ?? new PointLocation();
         return [point, point, point, point];
     }
     return [points[0], points[0].absOut, points[1].absIn, points[1]];

package/dist/_pkgs/std/clipboard/clipboard.js

@@ -5,7 +5,7 @@ import rehypeParse from 'rehype-parse';
 import { unified } from 'unified';
 import { LifeCycleWatcher } from '../extension/index.js';
 import { ClipboardAdapterConfigIdentifier } from './clipboard-adapter.js';
-import { onlyContainImgElement } from './utils.js';
+import { escapeHTML, onlyContainImgElement } from './utils.js';
 export class Clipboard extends LifeCycleWatcher {
     constructor() {
         super(...arguments);
@@ -206,11 +206,21 @@ export class Clipboard extends LifeCycleWatcher {
         }
         const hasInnerHTML = Boolean(innerHTML.length);
         const isEmpty = Object.keys(clipboardItems).length === 0;
+        // Whatever is left in `items` is a BlockSuite payload (a block snapshot, a
+        // surface slice, a database slice). It only travels through the
+        // `text/html` flavour, so it has to be written even when the adapters
+        // produced plain text and no HTML — otherwise pasting into another
+        // document silently degrades to the plain-text fallback and every block /
+        // element property is lost.
+        const hasSnapshotPayload = Object.values(items).some(value => typeof value === 'string' ? value.length > 0 : Boolean(value));
         // If there are no items, fall back to snapshot.
-        if (hasInnerHTML || isEmpty) {
+        if (hasInnerHTML || isEmpty || hasSnapshotPayload) {
             const type = 'text/html';
             const snapshot = lz.compressToEncodedURIComponent(JSON.stringify(items));
-            const html = `<div data-blocksuite-snapshot='${snapshot}'>${innerHTML}</div>`;
+            // Keep the plain text readable for external targets that prefer the
+            // `text/html` flavour; internal pastes only read the attribute.
+            const body = hasInnerHTML ? innerHTML : escapeHTML(text);
+            const html = `<div data-blocksuite-snapshot="${snapshot}">${body}</div>`;
             clipboardItems[type] = new Blob([html], { type });
         }
         await navigator.clipboard.write([new ClipboardItem(clipboardItems)]);

package/dist/_pkgs/std/clipboard/utils.d.ts

@@ -1,4 +1,9 @@
 import type { RootContentMap } from 'hast';
 type HastUnionType<K extends keyof RootContentMap, V extends RootContentMap[K]> = V;
+/**
+ * Escapes the characters that would break out of an HTML text node.
+ * Used to embed plain text in the clipboard snapshot wrapper.
+ */
+export declare function escapeHTML(value: string): string;
 export declare function onlyContainImgElement(ast: HastUnionType<keyof RootContentMap, RootContentMap[keyof RootContentMap]>): 'yes' | 'no' | 'maybe';
 export {};

package/dist/_pkgs/std/clipboard/utils.js

@@ -1,3 +1,13 @@
+/**
+ * Escapes the characters that would break out of an HTML text node.
+ * Used to embed plain text in the clipboard snapshot wrapper.
+ */
+export function escapeHTML(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
 export function onlyContainImgElement(ast) {
     if (ast.type === 'element') {
         switch (ast.tagName) {

package/dist/_pkgs/std/event/dispatcher.js

@@ -49,6 +49,15 @@ const eventNames = [
     'nativeDragLeave',
     ...bypassEventNames,
 ];
+/**
+ * Events the dispatcher synthesizes itself: `click`, `doubleClick` and
+ * `tripleClick` are all derived from a single native `pointerup`. Stopping
+ * propagation of that shared native event when a synthetic handler consumes
+ * the click would also silence unrelated pointer listeners bound higher up
+ * (document-level drag/pan/auto-complete teardown), so it is skipped for them.
+ * Consuming a synthetic event still stops the dispatcher's own runner chain.
+ */
+const syntheticEventNames = new Set(['click', 'doubleClick', 'tripleClick']);
 export class UIEventDispatcher extends LifeCycleWatcher {
     static { this._activeDispatcher = null; }
     static { this.key = 'UIEventDispatcher'; }
@@ -157,6 +166,20 @@ export class UIEventDispatcher extends LifeCycleWatcher {
                 this._setActive(false);
             }
         });
+        // When the selection is outside the host, the event dispatcher should be
+        // inactive. Selecting text in a plain (non-focusable) element outside the
+        // editor fires neither `focusout` with a relatedTarget nor `blur`, so
+        // without this the editor would keep handling keystrokes aimed elsewhere.
+        this.disposables.addFromEvent(document, 'selectionchange', () => {
+            const sel = document.getSelection();
+            if (!sel || sel.rangeCount === 0)
+                return;
+            const { anchorNode, focusNode } = sel;
+            if ((anchorNode && !this.host.contains(anchorNode)) ||
+                (focusNode && !this.host.contains(focusNode))) {
+                this._setActive(false);
+            }
+        });
     }
     _buildEventScopeBySelection(name) {
         const handlers = this._handlersMap[name];
@@ -321,7 +344,10 @@ export class UIEventDispatcher extends LifeCycleWatcher {
             const { fn } = runner;
             const result = fn(context);
             if (result) {
-                context.get('defaultState').event.stopPropagation();
+                // Only stop propagation for non-synthetic events
+                if (!syntheticEventNames.has(name)) {
+                    context.get('defaultState').event.stopPropagation();
+                }
                 return;
             }
         }

package/dist/_pkgs/std/event/keymap.js

@@ -197,13 +197,23 @@ export function bindKeymap(bindings, interceptors) {
                 return true;
             }
         }
-        // none standard keyboard, fallback to keyCode
-        const special = event.shiftKey ||
-            event.altKey ||
-            event.metaKey ||
-            name.charCodeAt(0) > 127;
+        // For non-standard keyboards, fallback to keyCode only when modifier keys
+        // are pressed. Do NOT fallback when the key produces a non-ASCII character
+        // (e.g. Cyrillic 'х' on a Russian layout), because the user intends to type
+        // that character, not to trigger a shortcut bound to the physical key.
+        // See: https://github.com/toeverything/AFFiNE/issues/14059
+        const hasModifier = event.shiftKey || event.altKey || event.ctrlKey || event.metaKey;
         const baseName = base[event.keyCode];
-        if (special && baseName && baseName !== name) {
+        const isSingleAscii = name.length === 1 && name.charCodeAt(0) <= 0x7e;
+        const isAltInputChar = event.altKey && !event.ctrlKey && !event.metaKey && !isSingleAscii;
+        // Keep supporting existing Alt+digit shortcuts (e.g. Alt-0/1/2 in edgeless)
+        // while preventing Alt-based locale input characters from triggering letter
+        // shortcuts.
+        const isDigitBaseKey = baseName != null && baseName.length === 1 && /[0-9]/.test(baseName);
+        if (hasModifier &&
+            baseName &&
+            baseName !== name &&
+            !(isAltInputChar && !isDigitBaseKey)) {
             const fromCode = map[modifiers(baseName, event)];
             if (fromCode && fromCode(ctx)) {
                 return true;