@formicoidea/labre-core 0.58.0 → 0.59.0

package/dist/_pkgs/affine-block-table/adapters/html.js

@@ -42,12 +42,12 @@ export const tableBlockHtmlAdapterMatcher = {
     fromBlockSnapshot: {
         enter: (o, context) => {
             const { walkerContext } = context;
-            const { columns, rows, cells } = o.node
+            const { columns, rows, cells, headerRow, headerColumn } = o.node
                 .props;
             const table = processTable(columns, rows, cells);
-            const createAstTableCell = (children) => ({
+            const createAstTableCell = (children, header) => ({
                 type: 'element',
-                tagName: 'td',
+                tagName: header ? 'th' : 'td',
                 properties: Object.create(null),
                 children: [
                     {
@@ -67,18 +67,30 @@ export const tableBlockHtmlAdapterMatcher = {
                 children: cells,
             });
             const { deltaConverter } = context;
-            const tableBodyAst = {
+            // ADR 0043: the header row goes in a `thead`, header cells are `th`.
+            const hasHeaderRow = headerRow === true && table.rows.length > 0;
+            const hasHeaderColumn = headerColumn === true;
+            const astRows = table.rows.map((v, rowIndex) => {
+                return createAstTableRow(v.cells.map((cell, columnIndex) => {
+                    return createAstTableCell(typeof cell.value === 'string'
+                        ? [{ type: 'text', value: cell.value }]
+                        : deltaConverter.deltaToAST(cell.value.delta), (hasHeaderRow && rowIndex === 0) ||
+                        (hasHeaderColumn && columnIndex === 0));
+                }));
+            });
+            const section = (tagName, children) => ({
                 type: 'element',
-                tagName: 'tbody',
+                tagName,
                 properties: Object.create(null),
-                children: table.rows.map(v => {
-                    return createAstTableRow(v.cells.map(cell => {
-                        return createAstTableCell(typeof cell.value === 'string'
-                            ? [{ type: 'text', value: cell.value }]
-                            : deltaConverter.deltaToAST(cell.value.delta));
-                    }));
-                }),
-            };
+                children,
+            });
+            const tableChildren = hasHeaderRow
+                ? [section('thead', astRows.slice(0, 1))]
+                : [];
+            const bodyRows = hasHeaderRow ? astRows.slice(1) : astRows;
+            if (!hasHeaderRow || bodyRows.length > 0) {
+                tableChildren.push(section('tbody', bodyRows));
+            }
             walkerContext
                 .openNode({
                 type: 'element',
@@ -87,7 +99,7 @@ export const tableBlockHtmlAdapterMatcher = {
                     border: true,
                     style: 'border-collapse: collapse;border-spacing: 0;',
                 },
-                children: [tableBodyAst],
+                children: tableChildren,
             })
                 .closeNode();
             walkerContext.skipAllChildren();

package/dist/_pkgs/affine-block-table/adapters/utils.d.ts

@@ -28,6 +28,7 @@ export declare const createTableProps: (deltasLists: RichTextType[][]) => {
 };
 export declare const parseTableFromHtml: (element: Element, astToDelta: (ast: HtmlAST) => RichTextType) => TableBlockPropsSerialized;
 export declare const parseTableFromMarkdown: (node: MarkdownTable, astToDelta: (ast: MarkdownAST) => RichTextType) => {
+    headerRow: true;
     columns: {
         [k: string]: TableColumn;
     };

package/dist/_pkgs/affine-block-table/adapters/utils.js

@@ -115,11 +115,23 @@ export const createTableProps = (deltasLists) => {
         cells,
     };
 };
+/**
+ * A row's cells in order, `td` and `th` alike: a body row may open on a `th`
+ * (a header column, which the HTML export writes since ADR 0043), and keeping
+ * only `td` dropped that cell.
+ */
+const rowCells = (tr) => tr.children.filter((child) => HastUtils.isElement(child) &&
+    (child.tagName === 'td' || child.tagName === 'th'));
 export const parseTableFromHtml = (element, astToDelta) => {
-    const headerRows = getAllTag(element, 'thead').flatMap(node => getAllTag(node, 'tr').map(tr => getAllTag(tr, 'th')));
-    const bodyRows = getAllTag(element, 'tbody').flatMap(node => getAllTag(node, 'tr').map(tr => getAllTag(tr, 'td')));
-    const footerRows = getAllTag(element, 'tfoot').flatMap(node => getAllTag(node, 'tr').map(tr => getAllTag(tr, 'td')));
+    const heads = getAllTag(element, 'thead');
+    const headerRows = heads.flatMap(node => getAllTag(node, 'tr').map(rowCells));
+    const bodyRows = getAllTag(element, 'tbody').flatMap(node => getAllTag(node, 'tr').map(rowCells));
+    const footerRows = getAllTag(element, 'tfoot').flatMap(node => getAllTag(node, 'tr').map(rowCells));
     const allRows = [...headerRows, ...bodyRows, ...footerRows];
+    // ADR 0043: a `thead` is a header row; a body whose every row opens on a
+    // `th` is a header column. `true` or absent, never `false`.
+    const headerRow = heads.length > 0;
+    const headerColumn = bodyRows.length > 0 && bodyRows.every(cells => cells[0]?.tagName === 'th');
     const rowTextLists = [];
     allRows.forEach(cells => {
         const row = [];
@@ -128,7 +140,11 @@ export const parseTableFromHtml = (element, astToDelta) => {
         });
         rowTextLists.push(row);
     });
-    return createTableProps(rowTextLists);
+    return {
+        ...createTableProps(rowTextLists),
+        ...(headerRow ? { headerRow: true } : {}),
+        ...(headerColumn ? { headerColumn: true } : {}),
+    };
 };
 /**
  * A cell holds rich text, and no inline matcher turns an `image` into a delta:
@@ -162,5 +178,7 @@ export const parseTableFromMarkdown = (node, astToDelta) => {
         });
         rowTextLists.push(rowText);
     });
-    return createTableProps(rowTextLists);
+    // GFM has no table without a header row: the first row always was one
+    // (ADR 0043).
+    return { ...createTableProps(rowTextLists), headerRow: true };
 };

package/dist/_pkgs/affine-block-table/header-menu.d.ts

@@ -0,0 +1,13 @@
+import type { BlockStdScope } from '../std/index.js';
+/**
+ * The "Header row" / "Header column" item of the first row's / first
+ * column's menu (ADR 0043): a plain action with the menu's check mark, the
+ * toggle-switch row of `menu.toggleSwitch` hands its click the value it was
+ * built with.
+ *
+ * Kept out of `table-cell.ts` on purpose: the literal guard treats every
+ * literal of a file that calls `translateKey` as covered when it equals some
+ * fallback, and the cell menus' older labels ("Copy", "Delete"…) are still
+ * untranslated literals its baseline must keep seeing.
+ */
+export declare function headerToggleMenuItem(std: BlockStdScope | undefined, kind: 'row' | 'column', on: boolean, toggle: (on: boolean) => void): (menu: import("../affine-components/context-menu/menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;

package/dist/_pkgs/affine-block-table/header-menu.js

@@ -0,0 +1,25 @@
+import { menu } from '../affine-components/context-menu/index.js';
+import { translateKey } from '../affine-shared/services/index.js';
+import { HeaderColumnIcon, HeaderRowIcon } from '@blocksuite/icons/lit';
+import { TABLE_HEADER_COLUMN, TABLE_HEADER_ROW } from './translations.js';
+/**
+ * The "Header row" / "Header column" item of the first row's / first
+ * column's menu (ADR 0043): a plain action with the menu's check mark, the
+ * toggle-switch row of `menu.toggleSwitch` hands its click the value it was
+ * built with.
+ *
+ * Kept out of `table-cell.ts` on purpose: the literal guard treats every
+ * literal of a file that calls `translateKey` as covered when it equals some
+ * fallback, and the cell menus' older labels ("Copy", "Delete"…) are still
+ * untranslated literals its baseline must keep seeing.
+ */
+export function headerToggleMenuItem(std, kind, on, toggle) {
+    const wording = kind === 'row' ? TABLE_HEADER_ROW : TABLE_HEADER_COLUMN;
+    return menu.action({
+        name: std ? translateKey(std, ...wording) : wording[1],
+        prefix: kind === 'row' ? HeaderRowIcon() : HeaderColumnIcon(),
+        isSelected: on,
+        testId: `table-header-${kind}-toggle`,
+        select: () => toggle(!on),
+    });
+}

package/dist/_pkgs/affine-block-table/selection-controller.d.ts

@@ -2,6 +2,13 @@ import type { UIEventStateContext } from '../std/index.js';
 import type { ReactiveController } from 'lit';
 import { type TableAreaSelection, TableSelectionData } from './selection-schema.js';
 import type { TableBlockComponent } from './table-block.js';
+/**
+ * The width that makes a column end where the table's scroll box ends: what
+ * the box offers minus what the other columns already take, never below
+ * `ColumnMinWidth`. `undefined` when nothing is left to give, so the caller
+ * writes nothing.
+ */
+export declare function remainingColumnWidth(available: number, otherColumnsWidth: number): number | undefined;
 export declare class SelectionController implements ReactiveController {
     readonly host: TableBlockComponent;
     constructor(host: TableBlockComponent);
@@ -16,6 +23,14 @@ export declare class SelectionController implements ReactiveController {
     private get clipboard();
     private get scale();
     widthAdjust(dragHandle: HTMLElement, event: MouseEvent): void;
+    /**
+     * Double-click on a column's resize handle: the column takes the room left
+     * between the table and the right edge of its scroll box. Measured in the
+     * table's own unscaled pixels (`clientWidth` ignores the edgeless zoom, the
+     * cells' rects do not, hence `getScale()`); the container's own padding and
+     * the virtual padding around the table are not room a column can take.
+     */
+    fitColumnToRemainingSpace(columnId: string): void;
     dragListener(): void;
     startColumnDrag(x: number, columnDragHandle: HTMLElement): {
         onMove: (x: number) => void;

package/dist/_pkgs/affine-block-table/selection-controller.js

@@ -3,9 +3,23 @@ import { IS_MOBILE } from '../global/env/index.js';
 import { computed } from '@preact/signals-core';
 import { ColumnMinWidth, DefaultColumnWidth } from './consts.js';
 import { TableSelection, TableSelectionData, } from './selection-schema.js';
+import { tableContainer } from './table-block-css.js';
 import { createColumnDragPreview, createRowDragPreview, TableCellComponentName, } from './table-cell.js';
 import { cleanSelection, isTableDragHandle } from './utils.js';
 const TEXT = 'text/plain';
+/**
+ * The width that makes a column end where the table's scroll box ends: what
+ * the box offers minus what the other columns already take, never below
+ * `ColumnMinWidth`. `undefined` when nothing is left to give, so the caller
+ * writes nothing.
+ */
+export function remainingColumnWidth(available, otherColumnsWidth) {
+    const remainder = Math.floor(available - otherColumnsWidth);
+    if (!Number.isFinite(remainder) || remainder <= 0)
+        return;
+    return Math.max(ColumnMinWidth, remainder);
+}
+const px = (value) => parseFloat(value) || 0;
 export class SelectionController {
     constructor(host) {
         this.host = host;
@@ -221,10 +235,58 @@ export class SelectionController {
         window.addEventListener('mousemove', onMove);
         window.addEventListener('mouseup', onUp);
     }
+    /**
+     * Double-click on a column's resize handle: the column takes the room left
+     * between the table and the right edge of its scroll box. Measured in the
+     * table's own unscaled pixels (`clientWidth` ignores the edgeless zoom, the
+     * cells' rects do not, hence `getScale()`); the container's own padding and
+     * the virtual padding around the table are not room a column can take.
+     */
+    fitColumnToRemainingSpace(columnId) {
+        if (this.dataManager.readonly$.peek())
+            return;
+        const container = this.host.querySelector(`.${tableContainer}`);
+        const firstRow = this.host.querySelector('tr');
+        if (!container || !firstRow)
+            return;
+        const containerStyle = getComputedStyle(container);
+        const inner = container.firstElementChild;
+        const innerStyle = inner instanceof HTMLElement ? getComputedStyle(inner) : undefined;
+        const available = container.clientWidth -
+            px(containerStyle.paddingLeft) -
+            px(containerStyle.paddingRight) -
+            px(innerStyle?.paddingLeft ?? '') -
+            px(innerStyle?.paddingRight ?? '');
+        const scale = this.scale;
+        let others = 0;
+        firstRow
+            .querySelectorAll('td[data-column-id]')
+            .forEach(cell => {
+            if (cell.dataset['columnId'] === columnId)
+                return;
+            others += cell.getBoundingClientRect().width / scale;
+        });
+        const width = remainingColumnWidth(available, others);
+        if (width === undefined)
+            return;
+        this.dataManager.setColumnWidth(columnId, width);
+    }
     dragListener() {
         if (IS_MOBILE || this.dataManager.readonly$.value) {
             return;
         }
+        this.host.disposables.addFromEvent(this.host, 'dblclick', event => {
+            const target = event.target;
+            if (!(target instanceof HTMLElement))
+                return;
+            const handle = target.closest('[data-width-adjust-column-id]');
+            const columnId = handle?.dataset['widthAdjustColumnId'];
+            if (!columnId)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            this.fitColumnToRemainingSpace(columnId);
+        });
         // Keep the pointer sequence inside the table too: in edgeless the canvas
         // listens for `pointerdown` and would start dragging the block.
         this.host.disposables.addFromEvent(this.host, 'pointerdown', event => {

package/dist/_pkgs/affine-block-table/table-cell-css.d.ts

@@ -1,4 +1,11 @@
 export declare const cellContainerStyle: string;
+/**
+ * A header cell (ADR 0043). Only a class, so an explicit row or column
+ * background — written inline by `tdStyle` — still wins over the tint. Not
+ * `table.headerBackground.default`: that token is the page colour in both
+ * themes, so the tint would not show.
+ */
+export declare const headerCellStyle: string;
 export declare const columnOptionsCellStyle: string;
 export declare const columnOptionsStyle: string;
 export declare const rowOptionsCellStyle: string;

package/dist/_pkgs/affine-block-table/table-cell-css.js

@@ -10,6 +10,16 @@ export const cellContainerStyle = css({
     textAlign: 'start',
     verticalAlign: 'top',
 });
+/**
+ * A header cell (ADR 0043). Only a class, so an explicit row or column
+ * background — written inline by `tdStyle` — still wins over the tint. Not
+ * `table.headerBackground.default`: that token is the page colour in both
+ * themes, so the tint would not show.
+ */
+export const headerCellStyle = css({
+    fontWeight: 600,
+    backgroundColor: cssVarV2.layer.background.secondary,
+});
 export const columnOptionsCellStyle = css({
     position: 'absolute',
     height: '0',

package/dist/_pkgs/affine-block-table/table-cell.d.ts

@@ -23,6 +23,13 @@ export declare class TableCell extends TableCell_base {
     get hoverRowIndex$(): import("@preact/signals-core").Signal<number | undefined>;
     get inlineManager(): import("../std/inline/index.js").InlineManager<import("../affine-shared/types/index.js").AffineTextAttributes> | undefined;
     get topContenteditableElement(): import("../std/index.js").BlockComponent<import("../store/index.js").BlockModel<object>, import("../std/index.js").BlockService, string> | null | undefined;
+    /**
+     * The header toggle sits in the first row's / first column's menu only: the
+     * header is positional (ADR 0043), so no other row could be the one it
+     * marks.
+     */
+    private headerToggle;
+    private get isHeader();
     openColumnOptions(target: PopupTarget, column: TableColumn, columnIndex: number): void;
     openRowOptions(target: PopupTarget, row: TableRow, rowIndex: number): void;
     createColorPickerMenu(currentColor: string | undefined, select: (color?: string) => void): (menu: import("../affine-components/context-menu/menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;
@@ -43,6 +50,7 @@ export declare class TableCell extends TableCell_base {
     private readonly _handleKeyDown;
     connectedCallback(): void;
     firstUpdated(): void;
+    private tdClass;
     render(): import("lit-html").TemplateResult<1>;
 }
 export declare const createColumnDragPreview: (cells: TableCell[]) => HTMLDivElement;

package/dist/_pkgs/affine-block-table/table-cell.js

@@ -46,12 +46,14 @@ import { computed, effect, signal } from '@preact/signals-core';
 import { html, nothing } from 'lit';
 import { property, query } from 'lit/decorators.js';
 import { classMap } from 'lit/directives/class-map.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
 import { ref } from 'lit/directives/ref.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { colorList } from './color.js';
 import { ColumnMaxWidth, DefaultColumnWidth } from './consts.js';
+import { headerToggleMenuItem } from './header-menu.js';
 import { TableSelectionData, } from './selection-schema.js';
-import { cellContainerStyle, columnLeftIndicatorStyle, columnOptionsCellStyle, columnOptionsStyle, columnRightIndicatorStyle, rowBottomIndicatorStyle, rowOptionsCellStyle, rowOptionsStyle, rowTopIndicatorStyle, threePointerIconDotStyle, threePointerIconStyle, } from './table-cell-css.js';
+import { cellContainerStyle, columnLeftIndicatorStyle, columnOptionsCellStyle, columnOptionsStyle, columnRightIndicatorStyle, headerCellStyle, rowBottomIndicatorStyle, rowOptionsCellStyle, rowOptionsStyle, rowTopIndicatorStyle, threePointerIconDotStyle, threePointerIconStyle, } from './table-cell-css.js';
 export const TableCellComponentName = 'affine-table-cell';
 let TableCell = (() => {
     let _classSuper = SignalWatcher(WithDisposable(ShadowlessElement));
@@ -196,6 +198,22 @@ let TableCell = (() => {
             return this.closest('affine-table')
                 ?.topContenteditableElement;
         }
+        /**
+         * The header toggle sits in the first row's / first column's menu only: the
+         * header is positional (ADR 0043), so no other row could be the one it
+         * marks.
+         */
+        headerToggle(kind) {
+            const std = this.closest('affine-table')?.std;
+            const dataManager = this.dataManager;
+            return kind === 'row'
+                ? headerToggleMenuItem(std, kind, dataManager.headerRow$.peek(), on => dataManager.setHeaderRow(on))
+                : headerToggleMenuItem(std, kind, dataManager.headerColumn$.peek(), on => dataManager.setHeaderColumn(on));
+        }
+        get isHeader() {
+            return ((this.rowIndex === 0 && this.dataManager.headerRow$.value) ||
+                (this.columnIndex === 0 && this.dataManager.headerColumn$.value));
+        }
         openColumnOptions(target, column, columnIndex) {
             this.selectionController.setSelected({
                 type: 'column',
@@ -232,6 +250,7 @@ let TableCell = (() => {
                                         })),
                                     },
                                 }),
+                                ...(columnIndex === 0 ? [this.headerToggle('column')] : []),
                                 ...(column.backgroundColor
                                     ? [
                                         menu.action({
@@ -345,6 +364,7 @@ let TableCell = (() => {
                                         })),
                                     },
                                 }),
+                                ...(rowIndex === 0 ? [this.headerToggle('row')] : []),
                                 ...(row.backgroundColor
                                     ? [
                                         menu.action({
@@ -706,9 +726,20 @@ let TableCell = (() => {
             })
                 .catch(console.error);
         }
+        tdClass() {
+            return classMap({
+                [cellContainerStyle]: true,
+                [headerCellStyle]: this.isHeader,
+            });
+        }
         render() {
+            const header = this.isHeader ? '' : undefined;
             if (!this.text) {
-                return html `<td class=${cellContainerStyle} style=${this.tdStyle()}>
+                return html `<td
+        class=${this.tdClass()}
+        data-header=${ifDefined(header)}
+        style=${this.tdStyle()}
+      >
         <div
           style=${styleMap({
                     padding: '8px 12px',
@@ -729,7 +760,8 @@ let TableCell = (() => {
                 this.tdMouseLeave();
             }}
         @contextmenu=${this.onContextMenu}
-        class=${cellContainerStyle}
+        class=${this.tdClass()}
+        data-header=${ifDefined(header)}
         style=${this.tdStyle()}
       >
         <rich-text

package/dist/_pkgs/affine-block-table/table-data-manager.d.ts

@@ -20,6 +20,9 @@ export declare class TableDataManager {
         width: number;
     } | undefined>;
     readonly cellCountTips$: ReadonlySignal<string>;
+    /** ADR 0043: anything but a stored `true` reads as off. */
+    readonly headerRow$: ReadonlySignal<boolean>;
+    readonly headerColumn$: ReadonlySignal<boolean>;
     readonly rows$: ReadonlySignal<import("../affine-model/index.js").TableRow[]>;
     readonly columns$: ReadonlySignal<import("../affine-model/index.js").TableColumn[]>;
     readonly uiRows$: ReadonlySignal<(import("../affine-model/index.js").TableRow | {
@@ -43,7 +46,18 @@ export declare class TableDataManager {
     updateColumnOrder(columnId: string, newOrder: string): void;
     setRowBackgroundColor(rowId: string, color?: string): void;
     setColumnBackgroundColor(columnId: string, color?: string): void;
+    /**
+     * One call per gesture (a resize drag writes once, on release; a fit writes
+     * once), so the `captureSync` here makes each gesture its own undo step.
+     */
     setColumnWidth(columnId: string, width: number): void;
+    setHeaderRow(on: boolean): void;
+    setHeaderColumn(on: boolean): void;
+    /**
+     * `true` or absent, never `false` (ADR 0043): turning a header off deletes
+     * the key, so an off table stores exactly what a pre-0043 table stored.
+     */
+    private setHeader;
     clearRow(rowId: string): void;
     clearColumn(columnId: string): void;
     clearCellsBySelection(selection: TableAreaSelection): void;

package/dist/_pkgs/affine-block-table/table-data-manager.js

@@ -19,6 +19,9 @@ export class TableDataManager {
         this.virtualRowCount$ = signal(0);
         this.virtualWidth$ = signal();
         this.cellCountTips$ = computed(() => `${this.virtualRowCount$.value + this.rows$.value.length} x ${this.virtualColumnCount$.value + this.columns$.value.length}`);
+        /** ADR 0043: anything but a stored `true` reads as off. */
+        this.headerRow$ = computed(() => this.model.props.headerRow$.value === true);
+        this.headerColumn$ = computed(() => this.model.props.headerColumn$.value === true);
         this.rows$ = computed(() => {
             return Object.values(this.model.props.rows$.value).sort((a, b) => a.order > b.order ? 1 : -1);
         });
@@ -201,10 +204,48 @@ export class TableDataManager {
             }
         });
     }
+    /**
+     * One call per gesture (a resize drag writes once, on release; a fit writes
+     * once), so the `captureSync` here makes each gesture its own undo step.
+     */
     setColumnWidth(columnId, width) {
-        this.model.store.transact(() => {
-            if (this.model.props.columns[columnId]) {
-                this.model.props.columns[columnId].width = width;
+        const store = this.model.store;
+        if (store.readonly)
+            return;
+        const column = this.model.props.columns[columnId];
+        if (!column || column.width === width)
+            return;
+        store.captureSync();
+        store.transact(() => {
+            const target = this.model.props.columns[columnId];
+            if (target) {
+                target.width = width;
+            }
+        });
+    }
+    setHeaderRow(on) {
+        this.setHeader('headerRow', on);
+    }
+    setHeaderColumn(on) {
+        this.setHeader('headerColumn', on);
+    }
+    /**
+     * `true` or absent, never `false` (ADR 0043): turning a header off deletes
+     * the key, so an off table stores exactly what a pre-0043 table stored.
+     */
+    setHeader(key, on) {
+        const store = this.model.store;
+        if (store.readonly)
+            return;
+        if ((this.model.props[key] === true) === on)
+            return;
+        store.captureSync();
+        store.transact(() => {
+            if (on) {
+                this.model.props[key] = true;
+            }
+            else {
+                delete this.model.props[key];
             }
         });
     }

package/dist/_pkgs/affine-block-table/translations.d.ts

@@ -0,0 +1,14 @@
+import type { ChromeWording } from '../affine-shared/services/index.js';
+/**
+ * This package's own wordings, declared beside the code that renders them —
+ * the two header toggles of the row and column menus (ADR 0043). The menus'
+ * older labels ("Insert Left", "Delete"…) are still literals held by
+ * `literals.baseline.json`; they move here in their own pass.
+ */
+export declare const TABLE_HEADER_ROW: ChromeWording;
+export declare const TABLE_HEADER_COLUMN: ChromeWording;
+/**
+ * Every wording declared above, in declaration order — walked by
+ * `PACKAGE_WORDINGS` in `packages/affine/all/src/translations.ts`.
+ */
+export declare const TABLE_WORDINGS: readonly ChromeWording[];

package/dist/_pkgs/affine-block-table/translations.js

@@ -0,0 +1,22 @@
+/**
+ * This package's own wordings, declared beside the code that renders them —
+ * the two header toggles of the row and column menus (ADR 0043). The menus'
+ * older labels ("Insert Left", "Delete"…) are still literals held by
+ * `literals.baseline.json`; they move here in their own pass.
+ */
+export const TABLE_HEADER_ROW = [
+    'com.labre.table.header-row',
+    'Header row',
+];
+export const TABLE_HEADER_COLUMN = [
+    'com.labre.table.header-column',
+    'Header column',
+];
+/**
+ * Every wording declared above, in declaration order — walked by
+ * `PACKAGE_WORDINGS` in `packages/affine/all/src/translations.ts`.
+ */
+export const TABLE_WORDINGS = [
+    TABLE_HEADER_ROW,
+    TABLE_HEADER_COLUMN,
+];

package/dist/_pkgs/affine-gfx-mindmap/toolbar/mindmap-tool-button.d.ts

@@ -1,4 +1,4 @@
-import { EmptyTool } from '../../affine-gfx-pointer/index.js';
+import { TextTool } from '../../affine-gfx-text/index.js';
 import { EdgelessDraggableElementController } from '../../affine-widget-edgeless-toolbar/index.js';
 import { LitElement } from 'lit';
 import { type DraggableTool } from './basket-elements.js';
@@ -8,7 +8,7 @@ export declare class EdgelessMindmapToolButton extends EdgelessMindmapToolButton
     private readonly _style$;
     draggableController: EdgelessDraggableElementController<DraggableTool>;
     enableActiveBackground: boolean;
-    type: (typeof EmptyTool)[];
+    type: (typeof TextTool)[];
     get draggableTools(): DraggableTool[];
     get mindmaps(): import("./assets.js").ToolbarMindmapItem[];
     get crud(): import("../../affine-block-surface/index.js").EdgelessCRUDExtension;

package/dist/_pkgs/affine-gfx-template/builtin/other.d.ts

@@ -1,2 +1,6 @@
+import { type ChromeWording, type TranslationParams } from '../../affine-shared/services/index.js';
+import type { BlockStdScope } from '../../std/index.js';
 import type { TemplateCategory } from '../toolbar/template-type.js';
+/** Resolve a wording through the host, or its English fallback with no host. */
+export declare function tr(std: BlockStdScope | undefined, wording: ChromeWording, params?: TranslationParams): string;
 export declare const otherTemplateCategory: TemplateCategory;

package/dist/_pkgs/affine-gfx-template/builtin/other.js

@@ -66,7 +66,7 @@ function line(x1, y1, x2, y2, opts = {}) {
     };
 }
 /** Resolve a wording through the host, or its English fallback with no host. */
-function tr(std, wording, params) {
+export function tr(std, wording, params) {
     return std
         ? translateKey(std, ...wording, params)
         : fillPlaceholders(wording[1], params);