@formicoidea/labre-core 0.39.3 → 0.41.0

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

@@ -0,0 +1,175 @@
+import { TOOLBAR_COPY, TOOLBAR_DELETE, TOOLBAR_DUPLICATE, TOOLBAR_MOVE_DOWN, TOOLBAR_MOVE_UP, } from '../affine-shared/services/index.js';
+/**
+ * The slash menu's own wordings — one `ChromeWording` per static config
+ * literal (`name`, `description`, a tooltip's `caption`) that
+ * `defaultSlashMenuConfig` (`./config.ts`) and `slashMenuToolTips`
+ * (`./tooltips/index.ts`) render, plus one per group header the widget draws
+ * itself (`./config.ts`'s own `Date` and `Actions` groups).
+ *
+ * This is the DEMONSTRATOR of the "static config rendered by a widget"
+ * pattern (`packages/affine/shared/src/services/translation-service/README.md`):
+ * the toolbar precedent resolves `labelWording` / `tooltipWording` in
+ * `combine`; the slash menu resolves `nameWording` / `descriptionWording` /
+ * `captionWording` in `slash-menu-popover.ts`, at render.
+ *
+ * Only the items THIS package declares are converted here — every other
+ * package's `configs/slash-menu.ts` keeps its own English literals until its
+ * own lot converts them, and registers its own table the same way.
+ */
+/* ── Date group ───────────────────────────────────────────────────────────
+ * One wording each: the item's `name` and its tooltip's `caption` say the
+ * exact same word ("Today" names the item AND captions its illustration), so
+ * one key serves both — the "un mot partagé = une clé" rule applied within a
+ * single item rather than across items.
+ */
+export const SLASH_MENU_TODAY = [
+    'com.labre.slash-menu.date.today',
+    'Today',
+];
+export const SLASH_MENU_TOMORROW = [
+    'com.labre.slash-menu.date.tomorrow',
+    'Tomorrow',
+];
+export const SLASH_MENU_YESTERDAY = [
+    'com.labre.slash-menu.date.yesterday',
+    'Yesterday',
+];
+export const SLASH_MENU_NOW = [
+    'com.labre.slash-menu.date.now',
+    'Now',
+];
+/* ── Actions group ─────────────────────────────────────────────────────── */
+/**
+ * "Move Up" and "Move Down" are shared with the note block's own move-up/down
+ * hotkey config (`packages/affine/blocks/note/src/move-block.ts`) — both this
+ * package and `blocks/note` are owned by the same lot, so the word moved to
+ * `chrome.ts` (`TOOLBAR_MOVE_UP` / `TOOLBAR_MOVE_DOWN`) rather than being
+ * declared here and reused there.
+ */
+export const SLASH_MENU_MOVE_UP = TOOLBAR_MOVE_UP;
+export const SLASH_MENU_MOVE_DOWN = TOOLBAR_MOVE_DOWN;
+export const SLASH_MENU_MOVE_UP_DESCRIPTION = [
+    'com.labre.slash-menu.actions.move-up.description',
+    'Shift this line up.',
+];
+export const SLASH_MENU_MOVE_DOWN_DESCRIPTION = [
+    'com.labre.slash-menu.actions.move-down.description',
+    'Shift this line down.',
+];
+/**
+ * "Copy", "Duplicate" and "Delete" are the editor's shared verbs, already
+ * declared once for every toolbar in `chrome.ts`: one word, one key.
+ */
+export const SLASH_MENU_COPY = TOOLBAR_COPY;
+export const SLASH_MENU_DUPLICATE = TOOLBAR_DUPLICATE;
+export const SLASH_MENU_DELETE = TOOLBAR_DELETE;
+export const SLASH_MENU_COPY_DESCRIPTION = [
+    'com.labre.slash-menu.actions.copy.description',
+    'Copy this line to clipboard.',
+];
+export const SLASH_MENU_DUPLICATE_DESCRIPTION = [
+    'com.labre.slash-menu.actions.duplicate.description',
+    'Create a duplicate of this line.',
+];
+/**
+ * The tooltip Copy and Duplicate share (`config.ts` points both items at
+ * `slashMenuToolTips['Copy']`): one caption, one key, reused by both items —
+ * exactly the case `CHROME_WORDINGS`' own doc comment describes.
+ */
+export const SLASH_MENU_COPY_DUPLICATE_CAPTION = [
+    'com.labre.slash-menu.actions.copy-duplicate.caption',
+    'Copy / Duplicate',
+];
+export const SLASH_MENU_DELETE_DESCRIPTION = [
+    'com.labre.slash-menu.actions.delete.description',
+    'Remove this line permanently.',
+];
+/* ── Group headers ─────────────────────────────────────────────────────── */
+/**
+ * One `ChromeWording` per group header the slash menu can draw — a closed
+ * set inventoried across every `configs/slash-menu.ts` in the repo (`group:
+ * '<n>_<Name>@<i>'`, the `<Name>` between `_` and `@`):
+ *
+ * - `Basic` — callout, latex, note (paragraph/heading/list/quote/divider).
+ * - `Content & Media` — attachment, bookmark, image, latex, the generic embed
+ *   (iframe) block, and (postponed, `blocks/table`) table.
+ * - `Page` — the linked-doc embed block.
+ * - `Edgeless Element` — surface-ref.
+ * - `Date`, `Actions` — this package's own groups (`./config.ts`).
+ *
+ * NOT included: `Database`, used only by the postponed `blocks/database` and
+ * `blocks/data-view` — the PO's decision excludes those surfaces, and
+ * `Database` has no other user today. A framework or a later lot that adds a
+ * group name not in this table is unaffected: `slashMenuGroupWording` returns
+ * `undefined` and the header renders the raw group name, same as before any
+ * of this existed.
+ */
+export const SLASH_MENU_GROUP_BASIC = [
+    'com.labre.slash-menu.group.basic',
+    'Basic',
+];
+export const SLASH_MENU_GROUP_CONTENT_MEDIA = [
+    'com.labre.slash-menu.group.content-media',
+    'Content & Media',
+];
+export const SLASH_MENU_GROUP_PAGE = [
+    'com.labre.slash-menu.group.page',
+    'Document',
+];
+export const SLASH_MENU_GROUP_EDGELESS_ELEMENT = [
+    'com.labre.slash-menu.group.edgeless-element',
+    'Canvas Element',
+];
+export const SLASH_MENU_GROUP_DATE = [
+    'com.labre.slash-menu.group.date',
+    'Date',
+];
+export const SLASH_MENU_GROUP_ACTIONS = [
+    'com.labre.slash-menu.group.actions',
+    'Actions',
+];
+/** The group table, keyed by the raw group name `parseGroup` extracts. */
+const SLASH_MENU_GROUP_WORDINGS = {
+    Basic: SLASH_MENU_GROUP_BASIC,
+    'Content & Media': SLASH_MENU_GROUP_CONTENT_MEDIA,
+    Page: SLASH_MENU_GROUP_PAGE,
+    'Edgeless Element': SLASH_MENU_GROUP_EDGELESS_ELEMENT,
+    Date: SLASH_MENU_GROUP_DATE,
+    Actions: SLASH_MENU_GROUP_ACTIONS,
+};
+/**
+ * The wording for a group header, or `undefined` for a group name outside the
+ * closed set above — rendered raw, same as before this table existed.
+ */
+export function slashMenuGroupWording(groupName) {
+    return SLASH_MENU_GROUP_WORDINGS[groupName];
+}
+/**
+ * Every wording declared above, in declaration order — walked by
+ * `PACKAGE_WORDINGS` in `packages/affine/all/src/translations.ts` rather than
+ * restated there.
+ *
+ * `SLASH_MENU_MOVE_UP` / `_MOVE_DOWN` (aliases of the chrome table's
+ * `TOOLBAR_MOVE_UP` / `_MOVE_DOWN`) are deliberately NOT listed here, exactly
+ * like `SLASH_MENU_COPY` / `_DUPLICATE` / `_DELETE` above: an alias is walked
+ * once, from `CHROME_WORDINGS`, and listing it again here would offer a host
+ * the same key twice.
+ */
+export const SLASH_MENU_WORDINGS = [
+    SLASH_MENU_TODAY,
+    SLASH_MENU_TOMORROW,
+    SLASH_MENU_YESTERDAY,
+    SLASH_MENU_NOW,
+    SLASH_MENU_MOVE_UP_DESCRIPTION,
+    SLASH_MENU_MOVE_DOWN_DESCRIPTION,
+    SLASH_MENU_COPY_DESCRIPTION,
+    SLASH_MENU_DUPLICATE_DESCRIPTION,
+    SLASH_MENU_COPY_DUPLICATE_CAPTION,
+    SLASH_MENU_DELETE_DESCRIPTION,
+    SLASH_MENU_GROUP_BASIC,
+    SLASH_MENU_GROUP_CONTENT_MEDIA,
+    SLASH_MENU_GROUP_PAGE,
+    SLASH_MENU_GROUP_EDGELESS_ELEMENT,
+    SLASH_MENU_GROUP_DATE,
+    SLASH_MENU_GROUP_ACTIONS,
+];

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

@@ -1,3 +1,4 @@
+import type { ChromeWording } from '../affine-shared/services/index.js';
 import type { BlockStdScope } from '../std/index.js';
 import type { BlockModel } from '../store/index.js';
 import type { TemplateResult } from 'lit';
@@ -8,10 +9,27 @@ export type SlashMenuContext = {
 export type SlashMenuTooltip = {
     figure: TemplateResult;
     caption: string;
+    /**
+     * {@link caption}, said as an i18n key with its English default — resolved
+     * against the host's catalogue when the tooltip renders, and shown instead
+     * of `caption` there. Mirrors `ToolbarAction.labelWording`: a static
+     * literal is the one wording a host cannot override.
+     */
+    captionWording?: ChromeWording;
 };
 type SlashMenuItemBase = {
     name: string;
+    /**
+     * The same word as {@link name}, said as an i18n key with its English
+     * default — resolved against the host's catalogue when the item renders,
+     * and shown instead of `name` there. `name` stays the item's English
+     * identity: it is what tests and `searchAlias` match against, and what
+     * `slashItemClassName` derives a CSS class from.
+     */
+    nameWording?: ChromeWording;
     description?: string;
+    /** {@link nameWording}, for {@link description}. */
+    descriptionWording?: ChromeWording;
     icon?: TemplateResult;
     /**
      * This field defines sorting and grouping of menu items like VSCode.

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

@@ -1,4 +1,5 @@
-import type { SlashMenuActionItem, SlashMenuConfig, SlashMenuContext, SlashMenuItem, SlashMenuSubMenu } from './types.js';
+import type { BlockStdScope } from '../std/index.js';
+import type { SlashMenuActionItem, SlashMenuConfig, SlashMenuContext, SlashMenuItem, SlashMenuSubMenu, SlashMenuTooltip } from './types.js';
 /**
  * Whether a keydown is the user typing one more character into the query.
  *
@@ -11,6 +12,24 @@ 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;
+/**
+ * What an item SAYS, whether it declared a wording or a literal `name`.
+ * Mirrors `toolbarActionLabel`: the widget resolves `nameWording` at render,
+ * `name` stays the English identity used by tests and `searchAlias`.
+ */
+export declare function resolveSlashItemName(std: BlockStdScope, item: SlashMenuItem): string;
+/** {@link resolveSlashItemName}, for `description`. */
+export declare function resolveSlashItemDescription(std: BlockStdScope, item: SlashMenuItem): string | undefined;
+/** {@link resolveSlashItemName}, for a tooltip's `caption`. */
+export declare function resolveSlashTooltipCaption(std: BlockStdScope, tooltip: SlashMenuTooltip): string;
+/**
+ * Whether `item` matches a slash-menu search `query` — against its RESOLVED
+ * (translated) name, its English `name`, and its `searchAlias`, so a French
+ * user typing the translated word and a habitual user typing the English one
+ * both find the item. With no `TranslationProvider` the resolved name equals
+ * `name`, so this is unchanged from before wordings existed.
+ */
+export declare function slashItemMatchesQuery(std: BlockStdScope, item: SlashMenuItem, query: string): boolean;
 export declare function parseGroup(group: NonNullable<SlashMenuItem['group']>): readonly [number, string, number];
 export declare function buildSlashMenuItems(items: SlashMenuItem[], context: SlashMenuContext, transform?: (item: SlashMenuItem) => SlashMenuItem): SlashMenuItem[];
 export declare function mergeSlashMenuConfigs(configs: Map<string, SlashMenuConfig>): SlashMenuConfig;

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

@@ -1,3 +1,5 @@
+import { translateKey } from '../affine-shared/services/index.js';
+import { isFuzzyMatch } from '../affine-shared/utils/index.js';
 /**
  * Whether a keydown is the user typing one more character into the query.
  *
@@ -31,6 +33,41 @@ export function isSubMenuItem(item) {
 export function slashItemClassName({ name }) {
     return name.split(' ').join('-').toLocaleLowerCase();
 }
+/**
+ * What an item SAYS, whether it declared a wording or a literal `name`.
+ * Mirrors `toolbarActionLabel`: the widget resolves `nameWording` at render,
+ * `name` stays the English identity used by tests and `searchAlias`.
+ */
+export function resolveSlashItemName(std, item) {
+    return item.nameWording ? translateKey(std, ...item.nameWording) : item.name;
+}
+/** {@link resolveSlashItemName}, for `description`. */
+export function resolveSlashItemDescription(std, item) {
+    return item.descriptionWording
+        ? translateKey(std, ...item.descriptionWording)
+        : item.description;
+}
+/** {@link resolveSlashItemName}, for a tooltip's `caption`. */
+export function resolveSlashTooltipCaption(std, tooltip) {
+    return tooltip.captionWording
+        ? translateKey(std, ...tooltip.captionWording)
+        : tooltip.caption;
+}
+/**
+ * Whether `item` matches a slash-menu search `query` — against its RESOLVED
+ * (translated) name, its English `name`, and its `searchAlias`, so a French
+ * user typing the translated word and a habitual user typing the English one
+ * both find the item. With no `TranslationProvider` the resolved name equals
+ * `name`, so this is unchanged from before wordings existed.
+ */
+export function slashItemMatchesQuery(std, item, query) {
+    const { name, searchAlias = [] } = item;
+    const resolvedName = resolveSlashItemName(std, item);
+    const candidates = resolvedName === name
+        ? [name, ...searchAlias]
+        : [name, resolvedName, ...searchAlias];
+    return candidates.some(str => isFuzzyMatch(str, query));
+}
 export function parseGroup(group) {
     return [
         parseInt(group.split('_')[0]),

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

@@ -0,0 +1,9 @@
+import type { ChromeWording } from '../affine-shared/services/index.js';
+/**
+ * The row's own "⋮" overflow menu button — its `aria-label` (naming the
+ * whole dropdown), distinct from `TOOLBAR_MORE` (`chrome.ts`, "More": the
+ * icon-button's own tooltip inside it).
+ */
+export declare const TOOLBAR_MORE_MENU_ARIA: ChromeWording;
+/** Every wording this package declares, in the order it renders them. */
+export declare const TOOLBAR_WIDGET_WORDINGS: readonly ChromeWording[];

package/dist/_pkgs/affine-widget-toolbar/translations.js

@@ -0,0 +1,13 @@
+/**
+ * The row's own "⋮" overflow menu button — its `aria-label` (naming the
+ * whole dropdown), distinct from `TOOLBAR_MORE` (`chrome.ts`, "More": the
+ * icon-button's own tooltip inside it).
+ */
+export const TOOLBAR_MORE_MENU_ARIA = [
+    'com.labre.toolbar.more-menu',
+    'More menu',
+];
+/** Every wording this package declares, in the order it renders them. */
+export const TOOLBAR_WIDGET_WORDINGS = [
+    TOOLBAR_MORE_MENU_ARIA,
+];

package/dist/_pkgs/affine-widget-toolbar/utils.js

@@ -14,6 +14,7 @@ import mergeWith from 'lodash-es/mergeWith.js';
 import orderBy from 'lodash-es/orderBy.js';
 import partition from 'lodash-es/partition.js';
 import toPairs from 'lodash-es/toPairs.js';
+import { TOOLBAR_MORE_MENU_ARIA } from './translations.js';
 export const sideMap = new Map([
     // includes frame element
     ['affine:surface:frame', { top: 28 }],
@@ -456,7 +457,7 @@ export function renderToolbar(toolbar, context, flavour, source = () => emptyToo
                 action: { id: 'more' },
                 template: html `${keyed(`${flavour}:${key}`, html `
             <editor-menu-button
-              aria-label="More menu"
+              aria-label="${translateKey(context.std, ...TOOLBAR_MORE_MENU_ARIA)}"
               .contentPadding="${'8px'}"
               .button=${html `
                 <editor-icon-button

package/dist/_pkgs/std/extension/translation-manifest.d.ts

@@ -13,6 +13,13 @@ import { type AnyCommandDescriptor } from './command-registry.js';
  * `packages/affine/all/src/commands.ts` and `scripts/build-bundles.mjs`).
  */
 export type TranslationKeySource = 'command' | 'framework' | 'role' | 'background' | 'rule' | 'nudge' | 'profile' | 'audit-criterion' | 'reading'
+/**
+ * A `UniverseTagDefs` tag or tag-value label (`@labre/affine-shared`'s
+ * `TagDef.labelKey` / `TagValueDef.labelKey`) — the library's OWN pack only
+ * (`WARDLEY_TAG_DEFS`). A host's app-seeded pack carries its own wording in
+ * `label` and needs no key at all.
+ */
+ | 'tag'
 /**
  * The words a framework WRITES ONTO THE CANVAS when an artefact is placed —
  * the "Task" a fresh BPMN task is captioned with, the "People" under an EDGY

package/dist/_pkgs/std/translations.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This package's own wordings, joined into `PACKAGE_WORDINGS` in
+ * `@labre/affine/translations` — see that file and
+ * `packages/affine/shared/src/services/translation-service/README.md`.
+ *
+ * A plain local tuple type, not `ChromeWording`
+ * (`@labre/affine-shared/services`): `@labre/std` must never import
+ * `@labre/affine-shared` (the dependency runs the other way — see
+ * `view/element/block-component.ts`'s own doc comment), so this package
+ * cannot reuse that type any more than it can reuse `translateKey` itself.
+ */
+type Wording = readonly [key: string, fallback: string];
+/**
+ * `BlockComponent.renderVersionMismatch`'s four wordings
+ * (`view/element/block-component.ts`) — the "Block Version Mismatched" card
+ * shown when a document carries a block flavour newer or older than this
+ * editor knows how to render.
+ */
+export declare const STD_VERSION_MISMATCH_TITLE: Wording;
+export declare const STD_VERSION_MISMATCH_BODY: Wording;
+export declare const STD_VERSION_MISMATCH_EDITOR_VERSION: Wording;
+export declare const STD_VERSION_MISMATCH_DATA_VERSION: Wording;
+export declare const STD_WORDINGS: readonly Wording[];
+export {};

package/dist/_pkgs/std/translations.js

@@ -0,0 +1,28 @@
+/**
+ * `BlockComponent.renderVersionMismatch`'s four wordings
+ * (`view/element/block-component.ts`) — the "Block Version Mismatched" card
+ * shown when a document carries a block flavour newer or older than this
+ * editor knows how to render.
+ */
+export const STD_VERSION_MISMATCH_TITLE = [
+    'com.labre.std.version-mismatch.title',
+    'Block Version Mismatched',
+];
+export const STD_VERSION_MISMATCH_BODY = [
+    'com.labre.std.version-mismatch.body',
+    'We can not render this {{flavour}} block because the version is mismatched.',
+];
+export const STD_VERSION_MISMATCH_EDITOR_VERSION = [
+    'com.labre.std.version-mismatch.editor-version',
+    'Editor version: {{version}}',
+];
+export const STD_VERSION_MISMATCH_DATA_VERSION = [
+    'com.labre.std.version-mismatch.data-version',
+    'Data version: {{version}}',
+];
+export const STD_WORDINGS = [
+    STD_VERSION_MISMATCH_TITLE,
+    STD_VERSION_MISMATCH_BODY,
+    STD_VERSION_MISMATCH_EDITOR_VERSION,
+    STD_VERSION_MISMATCH_DATA_VERSION,
+];

package/dist/_pkgs/std/view/element/block-component.js

@@ -32,6 +32,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
+import { createIdentifier } from '../../../global/di/index.js';
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import { SignalWatcher, WithDisposable } from '../../../global/lit/index.js';
 import { Store } from '../../../store/index.js';
@@ -44,10 +45,25 @@ import { when } from 'lit/directives/when.js';
 import { html } from 'lit/static-html.js';
 import { BlockServiceIdentifier } from '../../identifier.js';
 import { BlockSelection } from '../../selection/index.js';
+import { STD_VERSION_MISMATCH_BODY, STD_VERSION_MISMATCH_DATA_VERSION, STD_VERSION_MISMATCH_EDITOR_VERSION, STD_VERSION_MISMATCH_TITLE, } from '../../translations.js';
 import { PropTypes, requiredProperties } from '../decorators/index.js';
 import { blockComponentSymbol, modelContext, serviceContext, } from './consts.js';
 import { stdContext, storeContext } from './lit-host.js';
 import { ShadowlessElement } from './shadowless-element.js';
+const LocalTranslationProvider = createIdentifier('AffineTranslationService');
+/** `translateKey`'s own contract, replicated (see {@link LocalTranslationService}). */
+function localTranslate(std, key, fallback) {
+    const resolved = std.getOptional(LocalTranslationProvider)?.t(key);
+    return resolved !== undefined && resolved !== '' ? resolved : fallback;
+}
+const [VERSION_MISMATCH_TITLE_KEY, VERSION_MISMATCH_TITLE_FALLBACK] = STD_VERSION_MISMATCH_TITLE;
+const [VERSION_MISMATCH_BODY_KEY, VERSION_MISMATCH_BODY_FALLBACK] = STD_VERSION_MISMATCH_BODY;
+const [VERSION_MISMATCH_EDITOR_VERSION_KEY, VERSION_MISMATCH_EDITOR_VERSION_FALLBACK,] = STD_VERSION_MISMATCH_EDITOR_VERSION;
+const [VERSION_MISMATCH_DATA_VERSION_KEY, VERSION_MISMATCH_DATA_VERSION_FALLBACK,] = STD_VERSION_MISMATCH_DATA_VERSION;
+/** `translateKey`'s own `{{name}}` interpolation, replicated (see above). */
+function fillPlaceholder(template, name, value) {
+    return template.replace(new RegExp(`\\{\\{\\s*${name}\\s*\\}\\}`), value);
+}
 let BlockComponent = (() => {
     var _a;
     let _classDecorators = [requiredProperties({
@@ -259,18 +275,19 @@ let BlockComponent = (() => {
          * @param actualVersion The version of the block's crdt data.
          */
         renderVersionMismatch(expectedVersion, actualVersion) {
+            const title = localTranslate(this.std, VERSION_MISMATCH_TITLE_KEY, VERSION_MISMATCH_TITLE_FALLBACK);
+            const body = fillPlaceholder(localTranslate(this.std, VERSION_MISMATCH_BODY_KEY, VERSION_MISMATCH_BODY_FALLBACK), 'flavour', this.model.flavour);
+            const editorVersion = fillPlaceholder(localTranslate(this.std, VERSION_MISMATCH_EDITOR_VERSION_KEY, VERSION_MISMATCH_EDITOR_VERSION_FALLBACK), 'version', String(expectedVersion));
+            const dataVersion = fillPlaceholder(localTranslate(this.std, VERSION_MISMATCH_DATA_VERSION_KEY, VERSION_MISMATCH_DATA_VERSION_FALLBACK), 'version', String(actualVersion));
             return html `
       <dl class="version-mismatch-warning" contenteditable="false">
         <dt>
-          <h4>Block Version Mismatched</h4>
+          <h4>${title}</h4>
         </dt>
         <dd>
-          <p>
-            We can not render this <var>${this.model.flavour}</var> block
-            because the version is mismatched.
-          </p>
-          <p>Editor version: <var>${expectedVersion}</var></p>
-          <p>Data version: <var>${actualVersion}</var></p>
+          <p>${body}</p>
+          <p>${editorVersion}</p>
+          <p>${dataVersion}</p>
         </dd>
       </dl>
     `;

package/dist/translations.js

@@ -1,8 +1,59 @@
-import { EXEMPTION_FALLBACK, PROVENANCE_FALLBACK, SEVERITY_FALLBACK, } from './_pkgs/affine-block-surface/index.js';
-import { CHROME_WORDINGS } from './_pkgs/affine-shared/services/index.js';
+import { ATTACHMENT_WORDINGS } from './_pkgs/affine-block-attachment/translations.js';
+import { BOOKMARK_WORDINGS } from './_pkgs/affine-block-bookmark/translations.js';
+import { EMBED_WORDINGS } from './_pkgs/affine-block-embed/translations.js';
+import { EMBED_DOC_WORDINGS } from './_pkgs/affine-block-embed-doc/translations.js';
+import { FRAME_CHROME_WORDINGS, FRAME_WORDINGS, } from './_pkgs/affine-block-frame/translations.js';
+import { IMAGE_WORDINGS } from './_pkgs/affine-block-image/translations.js';
+import { EXEMPTION_FALLBACK, PROVENANCE_FALLBACK, SEVERITY_FALLBACK, SVG_SKETCH_WORDINGS, } from './_pkgs/affine-block-surface/index.js';
+import { SURFACE_REF_CHROME_WORDINGS, SURFACE_REF_WORDINGS, } from './_pkgs/affine-block-surface-ref/translations.js';
+import { ADAPTER_PANEL_WORDINGS } from './_pkgs/affine-fragment-adapter-panel/translations.js';
+import { DOC_TITLE_WORDINGS } from './_pkgs/affine-fragment-doc-title/translations.js';
+import { OUTLINE_WORDINGS } from './_pkgs/affine-fragment-outline/translations.js';
+import { COMPONENTS_WORDINGS } from './_pkgs/affine-components/translations.js';
+import { ROOT_CHROME_WORDINGS, ROOT_SEED_WORDINGS, } from './_pkgs/affine-block-root/translations.js';
+import { BRUSH_WORDINGS } from './_pkgs/affine-gfx-brush/translations.js';
+import { CONNECTOR_WORDINGS } from './_pkgs/affine-gfx-connector/translations.js';
+import { GROUP_CHROME_WORDINGS, GROUP_WORDINGS, } from './_pkgs/affine-gfx-group/translations.js';
+import { MINDMAP_CHROME_WORDINGS, MINDMAP_SEED_WORDINGS, } from './_pkgs/affine-gfx-mindmap/translations.js';
+import { SHAPE_WORDINGS } from './_pkgs/affine-gfx-shape/translations.js';
+import { POINTER_WORDINGS } from './_pkgs/affine-gfx-pointer/translations.js';
+import { FRAME_PANEL_WORDINGS } from './_pkgs/affine-fragment-frame-panel/translations.js';
+import { TEMPLATE_PACKAGE_WORDINGS, TEMPLATE_SEED_WORDINGS, } from './_pkgs/affine-gfx-template/translations.js';
+import { TEXT_WORDINGS } from './_pkgs/affine-gfx-text/translations.js';
+import { LATEX_WORDINGS as INLINE_LATEX_WORDINGS } from './_pkgs/affine-inline-latex/translations.js';
+import { LINK_WORDINGS } from './_pkgs/affine-inline-link/translations.js';
+import { MENTION_WORDINGS } from './_pkgs/affine-inline-mention/translations.js';
+import { PRESET_WORDINGS } from './_pkgs/affine-inline-preset/translations.js';
+import { REFERENCE_WORDINGS } from './_pkgs/affine-inline-reference/translations.js';
+import { CHROME_WORDINGS, } from './_pkgs/affine-shared/services/index.js';
+import { CALLOUT_WORDINGS } from './_pkgs/affine-block-callout/translations.js';
+import { CODE_WORDINGS } from './_pkgs/affine-block-code/translations.js';
+import { LATEX_WORDINGS } from './_pkgs/affine-block-latex/translations.js';
+import { NOTE_WORDINGS } from './_pkgs/affine-block-note/translations.js';
+import { PARAGRAPH_WORDINGS } from './_pkgs/affine-block-paragraph/translations.js';
+import { GFX_NOTE_WORDINGS } from './_pkgs/affine-gfx-note/translations.js';
+import { DRAG_HANDLE_WORDINGS } from './_pkgs/affine-widget-drag-handle/translations.js';
+import { AUTO_CONNECT_WORDINGS } from './_pkgs/affine-widget-edgeless-auto-connect/translations.js';
+import { EDGELESS_SELECTED_RECT_WORDINGS } from './_pkgs/affine-widget-edgeless-selected-rect/translations.js';
+import { EDGELESS_TOOLBAR_WORDINGS } from './_pkgs/affine-widget-edgeless-toolbar/translations.js';
+import { ZOOM_TOOLBAR_WORDINGS } from './_pkgs/affine-widget-edgeless-zoom-toolbar/translations.js';
+import { LINKED_DOC_WORDINGS } from './_pkgs/affine-widget-linked-doc/translations.js';
+import { REMOTE_SELECTION_WORDINGS } from './_pkgs/affine-widget-remote-selection/translations.js';
+import { SLASH_MENU_WORDINGS } from './_pkgs/affine-widget-slash-menu/translations.js';
+import { TOOLBAR_WIDGET_WORDINGS } from './_pkgs/affine-widget-toolbar/translations.js';
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from './_pkgs/std/index.js';
+import { STD_WORDINGS } from './_pkgs/std/translations.js';
 import { getCommands } from './commands.js';
 import { FRAMEWORK_DESCRIPTORS } from './frameworks.js';
+/**
+ * The auxiliary bundles' contributions (`AUXILIARY_BUNDLES` in `frameworks.ts`):
+ * packages that ship as their own bundle without being a framework. Same
+ * one-line `{ owner: '<label>', … }` shape as the framework groups, so
+ * `scripts/build-bundles.mjs` strips them from core's copy the same way.
+ */
+const AUXILIARY_TRANSLATION_GROUPS = [
+// One line per bundle: the bundler strips it by its `owner`.
+];
 const FRAMEWORK_TRANSLATION_GROUPS = [];
 /**
  * The chrome wordings that are TABLES: closed enumerations whose key is a
@@ -87,7 +138,10 @@ const CHROME_KEYS = [
     // Artefact catalogue sidepanel
     ['com.labre.catalogue.title', 'Artefacts'],
     ['com.labre.catalogue.close', 'Close'],
-    ['com.labre.catalogue.other', 'Other'],
+    // `com.labre.catalogue.other` USED to be here — L7 dedupe moved it to
+    // `chrome.ts` (`CATALOGUE_OTHER`), the same word as the templates-panel's
+    // own "Other" category tab, and its one call site now imports the constant
+    // instead of restating the literal.
     ['com.labre.catalogue.ranked', 'Recent & frequent'],
     // Qualify (tags) toolbar
     ['com.labre.tags.toolbar.label', 'Qualify'],
@@ -181,6 +235,82 @@ const CHROME_KEYS = [
     ['com.labre.interchange.import.carried', 'carried'],
     ['com.labre.interchange.import.quarantined', 'quarantined'],
 ];
+/**
+ * The block and widget packages' own wordings — one `readonly ChromeWording[]`
+ * per package, declared in that package's `translations.ts` beside the code
+ * that renders them, and walked here rather than restated.
+ *
+ * Per package and not one central table because the wordings belong to the
+ * package that renders them (an image toolbar's "Download" is the image
+ * block's), and because a single file every block edits is a file every
+ * parallel change conflicts on. Framework wordings do NOT go here: they travel
+ * in the framework's own `…TranslationEntries`, so a bundled host gets them
+ * with the framework bundle.
+ */
+const PACKAGE_WORDINGS = [
+    SLASH_MENU_WORDINGS,
+    OUTLINE_WORDINGS,
+    TEMPLATE_PACKAGE_WORDINGS,
+    NOTE_WORDINGS,
+    GFX_NOTE_WORDINGS,
+    CODE_WORDINGS,
+    LATEX_WORDINGS,
+    CALLOUT_WORDINGS,
+    PARAGRAPH_WORDINGS,
+    ADAPTER_PANEL_WORDINGS,
+    DOC_TITLE_WORDINGS,
+    SHAPE_WORDINGS,
+    TEXT_WORDINGS,
+    MINDMAP_CHROME_WORDINGS,
+    DRAG_HANDLE_WORDINGS,
+    AUTO_CONNECT_WORDINGS,
+    EDGELESS_SELECTED_RECT_WORDINGS,
+    EDGELESS_TOOLBAR_WORDINGS,
+    ZOOM_TOOLBAR_WORDINGS,
+    LINKED_DOC_WORDINGS,
+    REMOTE_SELECTION_WORDINGS,
+    TOOLBAR_WIDGET_WORDINGS,
+    COMPONENTS_WORDINGS,
+    INLINE_LATEX_WORDINGS,
+    LINK_WORDINGS,
+    MENTION_WORDINGS,
+    PRESET_WORDINGS,
+    REFERENCE_WORDINGS,
+    BRUSH_WORDINGS,
+    CONNECTOR_WORDINGS,
+    GROUP_CHROME_WORDINGS,
+    POINTER_WORDINGS,
+    ROOT_CHROME_WORDINGS,
+    SVG_SKETCH_WORDINGS,
+    STD_WORDINGS,
+    ATTACHMENT_WORDINGS,
+    BOOKMARK_WORDINGS,
+    IMAGE_WORDINGS,
+    EMBED_WORDINGS,
+    EMBED_DOC_WORDINGS,
+    SURFACE_REF_CHROME_WORDINGS,
+    FRAME_CHROME_WORDINGS,
+    FRAME_PANEL_WORDINGS,
+];
+/**
+ * Like {@link PACKAGE_WORDINGS}, for a non-framework package's SEEDS: text a
+ * creation action writes INTO the document, not chrome. Kept as its own
+ * source rather than folded into `PACKAGE_WORDINGS` under `chrome` — the two
+ * answer different questions for a host building a catalogue: a seed is
+ * translated once and becomes document content forever (a document created
+ * before the key existed keeps its plain text), while a chrome wording is
+ * re-rendered on every locale switch. `manifest.unit.spec.ts`'s "a placed
+ * artefact is seeded through the seam" pins a few of these by key, exactly as
+ * it does for a framework's own seeds.
+ */
+const PACKAGE_SEED_WORDINGS = [
+    FRAME_WORDINGS,
+    GROUP_WORDINGS,
+    MINDMAP_SEED_WORDINGS,
+    SURFACE_REF_WORDINGS,
+    TEMPLATE_SEED_WORDINGS,
+    ROOT_SEED_WORDINGS,
+];
 /**
  * Every i18n key THIS package can ask the host for, with its English fallback
  * where one ships.
@@ -195,13 +325,13 @@ const CHROME_KEYS = [
  * not filtered either.
  */
 export function getTranslationKeyManifest() {
-    return mergeTranslationEntries(commandTranslationEntries(getCommands()), collectTranslationKeys('framework', FRAMEWORK_DESCRIPTORS), ...FRAMEWORK_TRANSLATION_GROUPS.map(group => group.entries), chromeTableEntries(), catalogueCategoryEntries(), 
+    return mergeTranslationEntries(commandTranslationEntries(getCommands()), collectTranslationKeys('framework', FRAMEWORK_DESCRIPTORS), ...FRAMEWORK_TRANSLATION_GROUPS.map(group => group.entries), ...AUXILIARY_TRANSLATION_GROUPS.map(group => group.entries), chromeTableEntries(), catalogueCategoryEntries(), 
     // The editor's own shared vocabulary — the toasts, the toolbar verbs, the
     // view switcher, the board tooltips — DECLARED in
     // `@labre/affine-shared/services` beside nothing at all, and walked here
     // rather than restated. Same rule as the tables above: a wording added to
     // `CHROME_WORDINGS` reaches a host with no second edit.
-    CHROME_WORDINGS.map(([key, fallback]) => ({
+    [...CHROME_WORDINGS, ...PACKAGE_WORDINGS.flat()].map(([key, fallback]) => ({
         key,
         fallback,
         source: 'chrome',
@@ -209,5 +339,14 @@ export function getTranslationKeyManifest() {
         key,
         fallback,
         source: 'chrome',
+    })), 
+    // The non-framework packages' own SEEDS — text a creation action writes
+    // INTO the document (a frame's default title, a starter mindmap's
+    // captions), never re-rendered once placed. See
+    // `PACKAGE_SEED_WORDINGS`.
+    PACKAGE_SEED_WORDINGS.flat().map(([key, fallback]) => ({
+        key,
+        fallback,
+        source: 'seed',
     })));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-core",
   "description": "Labre editor — the full BlockSuite-derived editor as one package.",
-  "version": "0.39.3",
+  "version": "0.41.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",