@formicoidea/labre-core 0.47.1 → 0.49.0

package/dist/_pkgs/affine-block-database/view.js

@@ -1,34 +1,78 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { DatabaseBlockModel } from '../affine-model/index.js';
 import { SlashMenuConfigExtension } from '../affine-widget-slash-menu/index.js';
+import { StandaloneCellMetaExtension } from '../data-view/index.js';
 import { BlockViewExtension, FlavourExtension } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { z } from 'zod';
 import { DatabaseConfigExtension } from './config.js';
 import { databaseSlashMenuConfig } from './configs/slash-menu.js';
 import { effects } from './effects.js';
+import { linkColumnConfig } from './properties/link/cell-renderer.js';
+import { DatabaseViewCreationExtension } from './view-creation.js';
 const optionsSchema = z.object({
     configure: z
         .function()
         .args(z.instanceof(DatabaseBlockModel), z.custom())
         .returns(z.custom()),
 });
-export class DatabaseViewExtension extends ViewExtensionProvider {
+/**
+ * Database rendering — ALWAYS registered, independent of the `database` and
+ * `data-view` flags (ADR 0009, ADR 0035 §5, issue B4). A document that holds a
+ * database must show it, let its cells be edited and its rows be opened
+ * whatever the flags say: until 0.48 the whole view sat behind `database`, and
+ * `{ database: false }` left every stored database rendered as nothing.
+ *
+ * What lives here is what an EXISTING database needs, the mirror of
+ * `CalloutRenderViewExtension`:
+ * - `effects()` whole: every element it defines draws a stored database (the
+ *   block, its title, the cells, the row detail and its peek);
+ * - the flavour and the block view, the lookup `lit-host` performs; the block
+ *   brings the presets, the cells and the row opening with it;
+ * - the link cell for the title band (ADR 0035 §11): a `link` value already
+ *   stored on a page is drawn with it.
+ */
+export class DatabaseRenderViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
-        this.name = 'affine-database-block';
-        this.schema = optionsSchema;
+        this.name = 'affine-database-render-block';
     }
     effect() {
         super.effect();
         effects();
     }
-    setup(context, options) {
+    setup(context) {
         super.setup(context);
         context.register([
             FlavourExtension('affine:database'),
             BlockViewExtension('affine:database', literal `affine-database`),
+            // The title band draws a `link` / `url` property with the table's link
+            // cell; it sits below this package and cannot import it (ADR 0035 §11).
+            StandaloneCellMetaExtension(linkColumnConfig),
+        ]);
+    }
+}
+/**
+ * Database creation tooling — flag-gated (`database`, ADR 0009, ADR 0035 §5):
+ * the slash-menu entries that insert a database, the "+ view" of a rendered
+ * one (`DatabaseViewCreationIdentifier`, `./view-creation.ts`), and the host's additions to
+ * the block's "⋯" menu (`configure`, kept on this class so a host's
+ * `viewManager.configure(DatabaseViewExtension, …)` still compiles and its
+ * entries follow the flag). With the flag off no database and no view can be
+ * made; the stored ones keep rendering through
+ * {@link DatabaseRenderViewExtension}.
+ */
+export class DatabaseViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-database-block';
+        this.schema = optionsSchema;
+    }
+    setup(context, options) {
+        super.setup(context);
+        context.register([
             SlashMenuConfigExtension('affine:database', databaseSlashMenuConfig),
+            DatabaseViewCreationExtension,
         ]);
         if (options) {
             context.register(DatabaseConfigExtension({ configure: options.configure }));

package/dist/_pkgs/affine-block-database/views/index.d.ts

@@ -1,6 +1,33 @@
 import type { ViewMeta } from '../../data-view/index.js';
+/**
+ * Every preset a stored `affine:database` view can be drawn with (ADR 0035
+ * §6). Calendar stays here: calendar views were creatable until 0.48, so
+ * documents hold them, and a stored calendar keeps rendering and editing as a
+ * calendar. Never shrink this list: a mode that leaves it falls back to a
+ * table on every document that stores it.
+ */
+export declare const databaseBlockRenderableViews: ViewMeta[];
+/**
+ * The presets a user can CREATE, a subset of the renderable ones: what the
+ * data source answers as `viewMetas`, so the views bar ("+", "Create …") and
+ * the Layout switch list only these. Calendar left it after 0.48 (ADR 0035 §6,
+ * labre ADR-0046 §8): no new calendar, the stored ones still render.
+ */
 export declare const databaseBlockViews: ViewMeta[];
-export declare const databaseBlockViewMap: {
-    [k: string]: ViewMeta;
-};
+/** The preset a mode with none of its own is drawn with. */
+export declare const databaseBlockFallbackView: ViewMeta;
+export declare const databaseBlockViewMap: Record<string, ViewMeta | undefined>;
+/**
+ * The preset that draws a stored `mode`. Never throws: a mode this client has
+ * no preset for (a `timeline`, a newer client's view, an import) is drawn as a
+ * table over the source's properties, and its stored data stays as it is
+ * (`SingleView.shownAsFallback$`). Up to 0.48 it threw `Unknown view type`
+ * and the whole database rendered nothing.
+ */
+export declare function databaseBlockViewMetaGet(mode: string): ViewMeta;
+/**
+ * Conversions INTO a creatable preset only: switching a view's layout to
+ * calendar would create a calendar. The conversions out of calendar stay, so a
+ * stored calendar can still become a table or a board.
+ */
 export declare const databaseBlockViewConverts: import("../index.js").ViewConvertConfig[];

package/dist/_pkgs/affine-block-database/views/index.js

@@ -1,8 +1,49 @@
 import { viewConverts, viewPresets } from '../../data-view/view-presets/index.js';
-export const databaseBlockViews = [
+/**
+ * Every preset a stored `affine:database` view can be drawn with (ADR 0035
+ * §6). Calendar stays here: calendar views were creatable until 0.48, so
+ * documents hold them, and a stored calendar keeps rendering and editing as a
+ * calendar. Never shrink this list: a mode that leaves it falls back to a
+ * table on every document that stores it.
+ */
+export const databaseBlockRenderableViews = [
     viewPresets.tableViewMeta,
     viewPresets.kanbanViewMeta,
     viewPresets.calendarViewMeta,
+    viewPresets.galleryViewMeta,
+    viewPresets.listViewMeta,
+];
+/**
+ * The presets a user can CREATE, a subset of the renderable ones: what the
+ * data source answers as `viewMetas`, so the views bar ("+", "Create …") and
+ * the Layout switch list only these. Calendar left it after 0.48 (ADR 0035 §6,
+ * labre ADR-0046 §8): no new calendar, the stored ones still render.
+ */
+export const databaseBlockViews = [
+    viewPresets.tableViewMeta,
+    viewPresets.kanbanViewMeta,
+    viewPresets.galleryViewMeta,
+    viewPresets.listViewMeta,
 ];
-export const databaseBlockViewMap = Object.fromEntries(databaseBlockViews.map(view => [view.type, view]));
-export const databaseBlockViewConverts = [...viewConverts];
+/** The preset a mode with none of its own is drawn with. */
+export const databaseBlockFallbackView = viewPresets.tableViewMeta;
+// No prototype: a stored mode is any string, and `'constructor'` or
+// `'__proto__'` must find no preset rather than Object's own members.
+export const databaseBlockViewMap = Object.assign(Object.create(null), Object.fromEntries(databaseBlockRenderableViews.map(v => [v.type, v])));
+/**
+ * The preset that draws a stored `mode`. Never throws: a mode this client has
+ * no preset for (a `timeline`, a newer client's view, an import) is drawn as a
+ * table over the source's properties, and its stored data stays as it is
+ * (`SingleView.shownAsFallback$`). Up to 0.48 it threw `Unknown view type`
+ * and the whole database rendered nothing.
+ */
+export function databaseBlockViewMetaGet(mode) {
+    return databaseBlockViewMap[mode] ?? databaseBlockFallbackView;
+}
+const creatableModes = new Set(databaseBlockViews.map(view => view.type));
+/**
+ * Conversions INTO a creatable preset only: switching a view's layout to
+ * calendar would create a calendar. The conversions out of calendar stay, so a
+ * stored calendar can still become a table or a board.
+ */
+export const databaseBlockViewConverts = viewConverts.filter(convert => creatableModes.has(convert.to));

package/dist/_pkgs/affine-block-embed-doc/embed-linked-doc-block/configs/new-doc.d.ts

@@ -0,0 +1,25 @@
+import type { BlockStdScope } from '../../../std/index.js';
+import type { BlockModel } from '../../../store/index.js';
+/**
+ * Whether the slash menu offers "New Page" here: the card's schema is
+ * registered, and the host, if it creates docs, does not refuse it on this
+ * editor (`LinkedDocCreationProvider.canCreateLinkedDoc`).
+ */
+export declare function canCreateDocHere(std: BlockStdScope, model: BlockModel): boolean;
+/**
+ * The slash menu's "New Page": creates a page and leaves a CARD of it
+ * (`affine:embed-linked-doc`) right after the block the gesture was typed in.
+ * A paragraph the gesture left empty is replaced by the card, as Notion turns
+ * the line into the page. A card shows a child where its parent places it; an
+ * inline mention is only a reference (Labre ADR-0045 §9, host side).
+ *
+ * The page comes from the host's `LinkedDocCreationProvider` when there is
+ * one (the host persists it, registers it, decides its parent), else from the
+ * workspace (`createDefaultDoc`, the playground and standalone editors).
+ *
+ * One undo step for the card and the removed line. When no card can go there
+ * (a parent whose schema refuses it, an edgeless text for one), the gesture
+ * falls back on the inline mention it used to leave, so it always yields a way
+ * to the page. Returns the new page's id, or null on a read-only store.
+ */
+export declare function createDocFromSlash(std: BlockStdScope, model: BlockModel): string | null;

package/dist/_pkgs/affine-block-embed-doc/embed-linked-doc-block/configs/new-doc.js

@@ -0,0 +1,71 @@
+import { insertContent } from '../../../affine-rich-text/index.js';
+import { REFERENCE_NODE } from '../../../affine-shared/consts/index.js';
+import { LinkedDocCreationProvider, TelemetryProvider, } from '../../../affine-shared/services/index.js';
+import { createDefaultDoc, writeDefaultDocBlocks, } from '../../../affine-shared/utils/index.js';
+const LINKED_DOC = 'affine:embed-linked-doc';
+/**
+ * Whether the slash menu offers "New Page" here: the card's schema is
+ * registered, and the host, if it creates docs, does not refuse it on this
+ * editor (`LinkedDocCreationProvider.canCreateLinkedDoc`).
+ */
+export function canCreateDocHere(std, model) {
+    if (!model.store.schema.flavourSchemaMap.has(LINKED_DOC))
+        return false;
+    const creation = std.getOptional(LinkedDocCreationProvider);
+    return creation?.canCreateLinkedDoc?.(std.host) ?? true;
+}
+/**
+ * The slash menu's "New Page": creates a page and leaves a CARD of it
+ * (`affine:embed-linked-doc`) right after the block the gesture was typed in.
+ * A paragraph the gesture left empty is replaced by the card, as Notion turns
+ * the line into the page. A card shows a child where its parent places it; an
+ * inline mention is only a reference (Labre ADR-0045 §9, host side).
+ *
+ * The page comes from the host's `LinkedDocCreationProvider` when there is
+ * one (the host persists it, registers it, decides its parent), else from the
+ * workspace (`createDefaultDoc`, the playground and standalone editors).
+ *
+ * One undo step for the card and the removed line. When no card can go there
+ * (a parent whose schema refuses it, an edgeless text for one), the gesture
+ * falls back on the inline mention it used to leave, so it always yields a way
+ * to the page. Returns the new page's id, or null on a read-only store.
+ */
+export function createDocFromSlash(std, model) {
+    const { store } = std;
+    if (store.readonly)
+        return null;
+    const pageId = createNewDoc(std).id;
+    store.captureSync();
+    if (insertCard(store, model, pageId)) {
+        std.getOptional(TelemetryProvider)?.track('BlockCreated', {
+            blockType: LINKED_DOC,
+        });
+    }
+    else {
+        insertContent(std, model, REFERENCE_NODE, {
+            reference: { type: 'LinkedPage', pageId },
+        });
+    }
+    return pageId;
+}
+function createNewDoc(std) {
+    const creation = std.getOptional(LinkedDocCreationProvider);
+    if (!creation)
+        return createDefaultDoc(std.store.workspace);
+    const doc = creation.createLinkedDoc(std.host, '');
+    doc.load(() => writeDefaultDocBlocks(doc));
+    // The new page's first undo must not empty it (as in `createDefaultDoc`).
+    doc.resetHistory();
+    return doc;
+}
+function insertCard(store, anchor, pageId) {
+    const parent = store.getParent(anchor);
+    if (!parent || !store.schema.isValid(LINKED_DOC, parent.flavour)) {
+        return null;
+    }
+    const cardId = store.addBlock(LINKED_DOC, { pageId }, parent, parent.children.indexOf(anchor) + 1);
+    if (anchor.flavour === 'affine:paragraph' && anchor.text?.length === 0) {
+        store.deleteBlock(anchor);
+    }
+    return cardId;
+}

package/dist/_pkgs/affine-block-embed-doc/embed-linked-doc-block/configs/slash-menu.js

@@ -1,11 +1,9 @@
 import { EmbedLinkedDocBlockSchema } from '../../../affine-model/index.js';
-import { insertContent } from '../../../affine-rich-text/index.js';
-import { REFERENCE_NODE } from '../../../affine-shared/consts/index.js';
-import { createDefaultDoc } from '../../../affine-shared/utils/index.js';
 import { SlashMenuConfigIdentifier, } from '../../../affine-widget-slash-menu/index.js';
 import { LinkedPageIcon, PlusIcon } from '@blocksuite/icons/lit';
 import {} from '../../../store/index.js';
 import { EMBED_DOC_SLASH_LINKED_DOC_CAPTION, EMBED_DOC_SLASH_LINKED_DOC_DESCRIPTION, EMBED_DOC_SLASH_LINKED_DOC_NAME, EMBED_DOC_SLASH_NEW_DOC_DESCRIPTION, EMBED_DOC_SLASH_NEW_DOC_NAME, } from '../../translations.js';
+import { canCreateDocHere, createDocFromSlash } from './new-doc.js';
 import { LinkDocTooltip, NewDocTooltip } from './tooltips.js';
 const linkedDocSlashMenuConfig = {
     items: [
@@ -21,15 +19,9 @@ const linkedDocSlashMenuConfig = {
                 captionWording: EMBED_DOC_SLASH_NEW_DOC_NAME,
             },
             group: '3_Page@0',
-            when: ({ model }) => model.store.schema.flavourSchemaMap.has('affine:embed-linked-doc'),
+            when: ({ std, model }) => canCreateDocHere(std, model),
             action: ({ std, model }) => {
-                const newDoc = createDefaultDoc(std.host.store.workspace);
-                insertContent(std, model, REFERENCE_NODE, {
-                    reference: {
-                        type: 'LinkedPage',
-                        pageId: newDoc.id,
-                    },
-                });
+                createDocFromSlash(std, model);
             },
         },
         {

package/dist/_pkgs/affine-components/date-picker/date-picker.d.ts

@@ -1,4 +1,13 @@
+import type { ChromeWording } from '../../affine-shared/services/index.js';
 import { LitElement, type PropertyValues, type TemplateResult } from 'lit';
+/**
+ * The week header, Sunday first, in two letters: `Intl` short weekdays cut to
+ * two (`Su Mo…` in `en-US`, `Di Lu…` in `fr`), so the default reads as it
+ * did before the names came from `Intl`.
+ */
+export declare function weekdayLabels(locale: string): string[];
+/** The month names of the header and the month grid (`Jan…` in `en-US`). */
+export declare function monthLabels(locale: string): string[];
 export interface DateCell {
     date: Date;
     label: string;
@@ -95,6 +104,17 @@ export declare class DatePicker extends DatePicker_base {
     accessor size: number;
     /** Checked date timestamp */
     accessor value: number | undefined;
+    /**
+     * The BCP-47 locale of the day and month names (`formatLocale(std)` at the
+     * caller). `en-US` by default, which reads as the picker always did.
+     */
+    accessor locale: string;
+    /**
+     * Resolves the picker's own wordings: it renders in a popup, outside the
+     * editor, so its caller holds the catalogue. Absent, English.
+     */
+    accessor wording: ((wording: ChromeWording) => string) | undefined;
+    private say;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/_pkgs/affine-components/date-picker/date-picker.js

@@ -39,24 +39,29 @@ import { html, LitElement, nothing, } from 'lit';
 import { property } from 'lit/decorators.js';
 import { classMap } from 'lit/directives/class-map.js';
 import { styleMap } from 'lit/directives/style-map.js';
+import { DATE_PICKER_CLEAR, DATE_PICKER_NEXT, DATE_PICKER_PREVIOUS, DATE_PICKER_TODAY, } from '../translations.js';
 import { arrowLeftIcon } from './icons.js';
 import { datePickerStyle } from './style.js';
 import { getMonthMatrix, toDate } from './utils.js';
-const days = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];
-const months = [
-    'Jan',
-    'Feb',
-    'Mar',
-    'Apr',
-    'May',
-    'Jun',
-    'Jul',
-    'Aug',
-    'Sep',
-    'Oct',
-    'Nov',
-    'Dec',
-];
+/**
+ * The week header, Sunday first, in two letters: `Intl` short weekdays cut to
+ * two (`Su Mo…` in `en-US`, `Di Lu…` in `fr`), so the default reads as it
+ * did before the names came from `Intl`.
+ */
+export function weekdayLabels(locale) {
+    const format = new Intl.DateTimeFormat(locale, { weekday: 'short' });
+    // 2023-01-01 is a Sunday.
+    return Array.from({ length: 7 }, (_, i) => {
+        const name = format.format(new Date(2023, 0, 1 + i)).slice(0, 2);
+        return name.charAt(0).toLocaleUpperCase(locale) + name.slice(1);
+    });
+}
+/** The month names of the header and the month grid (`Jan…` in `en-US`). */
+export function monthLabels(locale) {
+    const format = new Intl.DateTimeFormat(locale, { month: 'short' });
+    return Array.from({ length: 12 }, (_, i) => format.format(new Date(2023, i, 1)));
+}
+const englishWording = (wording) => wording[1];
 /**
  * Date picker
  */
@@ -107,6 +112,12 @@ let DatePicker = (() => {
     let _value_decorators;
     let _value_initializers = [];
     let _value_extraInitializers = [];
+    let _locale_decorators;
+    let _locale_initializers = [];
+    let _locale_extraInitializers = [];
+    let _wording_decorators;
+    let _wording_initializers = [];
+    let _wording_extraInitializers = [];
     return class DatePicker extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -125,6 +136,8 @@ let DatePicker = (() => {
             _popup_decorators = [property({ type: Boolean })];
             _size_decorators = [property({ type: Number })];
             _value_decorators = [property({ type: Number })];
+            _locale_decorators = [property({ attribute: false })];
+            _wording_decorators = [property({ attribute: false })];
             __esDecorate(this, null, __matrix_decorators, { kind: "accessor", name: "_matrix", static: false, private: false, access: { has: obj => "_matrix" in obj, get: obj => obj._matrix, set: (obj, value) => { obj._matrix = value; } }, metadata: _metadata }, __matrix_initializers, __matrix_extraInitializers);
             __esDecorate(this, null, __mode_decorators, { kind: "accessor", name: "_mode", static: false, private: false, access: { has: obj => "_mode" in obj, get: obj => obj._mode, set: (obj, value) => { obj._mode = value; } }, metadata: _metadata }, __mode_initializers, __mode_extraInitializers);
             __esDecorate(this, null, __monthCursor_decorators, { kind: "accessor", name: "_monthCursor", static: false, private: false, access: { has: obj => "_monthCursor" in obj, get: obj => obj._monthCursor, set: (obj, value) => { obj._monthCursor = value; } }, metadata: _metadata }, __monthCursor_initializers, __monthCursor_extraInitializers);
@@ -140,6 +153,8 @@ let DatePicker = (() => {
             __esDecorate(this, null, _popup_decorators, { kind: "accessor", name: "popup", static: false, private: false, access: { has: obj => "popup" in obj, get: obj => obj.popup, set: (obj, value) => { obj.popup = value; } }, metadata: _metadata }, _popup_initializers, _popup_extraInitializers);
             __esDecorate(this, null, _size_decorators, { kind: "accessor", name: "size", static: false, private: false, access: { has: obj => "size" in obj, get: obj => obj.size, set: (obj, value) => { obj.size = value; } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
             __esDecorate(this, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+            __esDecorate(this, null, _locale_decorators, { kind: "accessor", name: "locale", static: false, private: false, access: { has: obj => "locale" in obj, get: obj => obj.locale, set: (obj, value) => { obj.locale = value; } }, metadata: _metadata }, _locale_initializers, _locale_extraInitializers);
+            __esDecorate(this, null, _wording_decorators, { kind: "accessor", name: "wording", static: false, private: false, access: { has: obj => "wording" in obj, get: obj => obj.wording, set: (obj, value) => { obj.wording = value; } }, metadata: _metadata }, _wording_initializers, _wording_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static { this.styles = datePickerStyle; }
@@ -168,7 +183,7 @@ let DatePicker = (() => {
             return this._cursor.getDay();
         }
         get dayLabel() {
-            return days[this.day];
+            return weekdayLabels(this.locale)[this.day];
         }
         get minHeight() {
             const rowNum = this._matrix.length;
@@ -178,7 +193,7 @@ let DatePicker = (() => {
             return this._cursor.getMonth();
         }
         get monthLabel() {
-            return months[this.month];
+            return monthLabels(this.locale)[this.month];
         }
         get year() {
             return this._cursor.getFullYear();
@@ -228,13 +243,13 @@ let DatePicker = (() => {
 
         ${this._navAction(() => this._moveMonth(-1), () => this._moveMonth(1), html `<button
             tabindex="0"
-            aria-label="today"
+            aria-label=${this.say(DATE_PICKER_TODAY)}
             class="action-label interactive today"
             @click=${() => {
                 this._onChange(new Date());
             }}
           >
-            <span>TODAY</span>
+            <span>${this.say(DATE_PICKER_TODAY)}</span>
           </button>`)}
       </div>
       ${this._dayHeaderRenderer()}
@@ -247,11 +262,11 @@ let DatePicker = (() => {
                 ? html `<div class="date-picker-footer">
             <button
               tabindex="0"
-              aria-label="clear"
+              aria-label=${this.say(DATE_PICKER_CLEAR)}
               class="footer-button interactive"
               @click=${() => this.onClear?.()}
             >
-              Clear
+              ${this.say(DATE_PICKER_CLEAR)}
             </button>
           </div>`
                 : nothing}`;
@@ -259,7 +274,7 @@ let DatePicker = (() => {
         /** Week header */
         _dayHeaderRenderer() {
             return html `<div class="days-header">
-      ${days.map(day => html `<div class="date-cell">${day}</div>`)}
+      ${weekdayLabels(this.locale).map(day => html `<div class="date-cell">${day}</div>`)}
     </div>`;
         }
         _getMatrix() {
@@ -307,7 +322,7 @@ let DatePicker = (() => {
             })}
       </div>
       <div class="date-picker-month">
-        ${months.map((month, index) => {
+        ${monthLabels(this.locale).map((month, index) => {
                 const isActive = this.value
                     ? isSameMonth(this.value, new Date(this._monthPickYearCursor, index, 1))
                     : false;
@@ -348,7 +363,7 @@ let DatePicker = (() => {
             });
             return html `<div class=${classes}>
       <button
-        aria-label="previous month"
+        aria-label=${this.say(DATE_PICKER_PREVIOUS)}
         class="date-picker-small-action interactive left"
         @click=${onPrev}
         ?disabled=${prevDisable}
@@ -357,7 +372,7 @@ let DatePicker = (() => {
       </button>
       ${slot ?? nothing}
       <button
-        aria-label="next month"
+        aria-label=${this.say(DATE_PICKER_NEXT)}
         class="date-picker-small-action interactive right"
         @click=${onNext}
         ?disabled=${nextDisable}
@@ -636,6 +651,23 @@ let DatePicker = (() => {
         /** Checked date timestamp */
         get value() { return this.#value_accessor_storage; }
         set value(value) { this.#value_accessor_storage = value; }
+        #locale_accessor_storage;
+        /**
+         * The BCP-47 locale of the day and month names (`formatLocale(std)` at the
+         * caller). `en-US` by default, which reads as the picker always did.
+         */
+        get locale() { return this.#locale_accessor_storage; }
+        set locale(value) { this.#locale_accessor_storage = value; }
+        #wording_accessor_storage;
+        /**
+         * Resolves the picker's own wordings: it renders in a popup, outside the
+         * editor, so its caller holds the catalogue. Absent, English.
+         */
+        get wording() { return this.#wording_accessor_storage; }
+        set wording(value) { this.#wording_accessor_storage = value; }
+        say(wording) {
+            return (this.wording ?? englishWording)(wording);
+        }
         constructor() {
             super(...arguments);
             /** current active month */
@@ -657,7 +689,9 @@ let DatePicker = (() => {
             this.#popup_accessor_storage = (__runInitializers(this, _padding_extraInitializers), __runInitializers(this, _popup_initializers, false));
             this.#size_accessor_storage = (__runInitializers(this, _popup_extraInitializers), __runInitializers(this, _size_initializers, 28));
             this.#value_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _value_initializers, undefined));
-            __runInitializers(this, _value_extraInitializers);
+            this.#locale_accessor_storage = (__runInitializers(this, _value_extraInitializers), __runInitializers(this, _locale_initializers, 'en-US'));
+            this.#wording_accessor_storage = (__runInitializers(this, _locale_extraInitializers), __runInitializers(this, _wording_initializers, undefined));
+            __runInitializers(this, _wording_extraInitializers);
         }
     };
 })();

package/dist/_pkgs/affine-components/date-picker/style.js

@@ -32,6 +32,7 @@ export const datePickerStyle = css `
   .interactive.date-picker-small-action,
   .interactive.action-label.today {
     color: var(--affine-icon-color);
+    text-transform: uppercase;
   }
 
   .date-picker-small-action:hover {

package/dist/_pkgs/affine-components/translations.d.ts

@@ -35,6 +35,10 @@ export { COLOR_LABEL, FILL_COLOR_LABEL };
 export declare const BORDER_COLOR_LABEL: ChromeWording;
 export declare const CONTEXT_MENU_NO_RESULTS: ChromeWording;
 export declare const CONTEXT_MENU_DONE: ChromeWording;
+export declare const DATE_PICKER_TODAY: ChromeWording;
+export declare const DATE_PICKER_CLEAR: ChromeWording;
+export declare const DATE_PICKER_PREVIOUS: ChromeWording;
+export declare const DATE_PICKER_NEXT: ChromeWording;
 export declare const LINE_STYLE_SOLID: ChromeWording;
 export declare const LINE_STYLE_DASH: ChromeWording;
 export declare const LINE_STYLE_NONE: ChromeWording;

package/dist/_pkgs/affine-components/translations.js

@@ -81,6 +81,28 @@ export const CONTEXT_MENU_DONE = [
     'com.labre.context-menu.done',
     'Done',
 ];
+/* ── Date picker (database date cells, the chips band, date filters) ─── */
+/*
+ * Its caller resolves them (the picker renders in a popup, outside the
+ * editor) and passes `wording`. Day and month names are not keys: they come
+ * from `Intl` in the caller's `locale` (`formatLocale(std)`).
+ */
+export const DATE_PICKER_TODAY = [
+    'com.labre.date-picker.today',
+    'Today',
+];
+export const DATE_PICKER_CLEAR = [
+    'com.labre.date-picker.clear',
+    'Clear',
+];
+export const DATE_PICKER_PREVIOUS = [
+    'com.labre.date-picker.previous-month',
+    'Previous month',
+];
+export const DATE_PICKER_NEXT = [
+    'com.labre.date-picker.next-month',
+    'Next month',
+];
 /* ── Edgeless line style / width panels ─────────────────────────────── */
 export const LINE_STYLE_SOLID = [
     'com.labre.line-style.solid',
@@ -415,6 +437,10 @@ export { ICON_BUTTON_COMING_SOON };
  * restated there.
  */
 export const COMPONENTS_WORDINGS = [
+    DATE_PICKER_TODAY,
+    DATE_PICKER_CLEAR,
+    DATE_PICKER_PREVIOUS,
+    DATE_PICKER_NEXT,
     CAPTION_PLACEHOLDER,
     CARD_STYLE_LABEL,
     FAVICON_ALT,

package/dist/_pkgs/affine-fragment-doc-title/doc-title.d.ts

@@ -4,6 +4,14 @@ declare const DocTitle_base: typeof ShadowlessElement & import("../global/utils/
 export declare class DocTitle extends DocTitle_base {
     static styles: import("lit").CSSResult;
     private _getOrCreateFirstPageVisibleNote;
+    /**
+     * Leaves the title for `bodyBlockId`: the title loses the caret (its text
+     * is already stored, so that is all "validating" it means), then the block
+     * takes the caret where it can, through its `focusFirstCell` (a database
+     * block's: the first cell of a table or kanban view). A block without one,
+     * or a view without cells, keeps nothing focused. Writes nothing.
+     */
+    private _leaveForBodyBlock;
     private readonly _onTitleKeyDown;
     private readonly _updateTitleInMeta;
     private get _std();
@@ -27,5 +35,15 @@ export declare class DocTitle extends DocTitle_base {
     private accessor _richTextElement;
     accessor doc: Store;
     accessor wrapText: boolean;
+    /**
+     * The block that is the page's body, when the document's note is not (a
+     * database's full page, ADR 0035 B13: the document holds the database
+     * block and its schema blocks in a note the page never draws). Set, the
+     * title has no body of its own: Enter and ArrowDown leave the title for
+     * this block and never add or focus a paragraph, so nothing is ever
+     * written to the note. Unset (the default), Enter splits the title into a
+     * first paragraph and ArrowDown focuses or creates one, as in 0.48.
+     */
+    accessor bodyBlockId: string | undefined;
 }
 export {};