@formicoidea/labre-core 0.39.3 → 0.41.0

package/dist/_pkgs/affine-shared/services/translation-service/index.d.ts

@@ -26,8 +26,14 @@ export interface TranslationService {
     /**
      * Resolve an i18n key. Return `undefined` when the catalogue has no entry,
      * so the caller can fall back rather than render an empty bubble.
+     *
+     * `params` carries the values of a sentence with holes in it ("Failed to
+     * upload {{name}}"). The host interpolates them — and pluralises on `count` —
+     * with its own i18n stack; the placeholders are i18next's `{{name}}`, so a
+     * catalogue seeded from the manifest's fallbacks works as is. A host that
+     * ignores `params` still type-checks and simply shows its unfilled wording.
      */
-    t(key: string): string | undefined;
+    t(key: string, params?: TranslationParams): string | undefined;
     /**
      * The language the catalogue is currently serving, as a BCP-47 tag
      * (`'fr'`, `'en-GB'`). Optional, and NOT locale negotiation — the library
@@ -51,6 +57,34 @@ export interface TranslationService {
  * framework has a convention that holds in `en-GB` and not in `en-US`.
  */
 export declare function hostLanguage(std: BlockStdScope): string | undefined;
+/**
+ * The host's full language tag (`'fr-CA'`), or `undefined` when no host said —
+ * for `Intl` formatting of dates and numbers, where the region matters
+ * (`en-GB` and `en-US` write a date differently). `undefined` hands `Intl` the
+ * runtime default, which is what the editor did before hosts could say.
+ */
+export declare function hostLocale(std: BlockStdScope): string | undefined;
+/**
+ * `hostLocale(std)`, defaulting to `'en-US'` when the host said nothing —
+ * the locale every `Intl.*Format` call in the library resolves against.
+ *
+ * Dates and numbers fall back to English like every string does, so a
+ * standalone playground stays deterministic: `Intl`'s own runtime-default
+ * fallback would instead read whatever locale the machine happens to have,
+ * which is not a fallback a test can assert on.
+ */
+export declare function formatLocale(std: BlockStdScope): string;
+/** The values of a wording's `{{name}}` placeholders. */
+export type TranslationParams = Record<string, string | number>;
+/**
+ * Fill `{{name}}` placeholders from `params`; a placeholder with no value is
+ * left as written, so a missing argument shows rather than vanishes.
+ *
+ * The library's side of interpolation only — used on the English fallback when
+ * the host has no entry. Pluralisation is the host's: a fallback stays neutral
+ * ("{{count}} element(s)").
+ */
+export declare function fillPlaceholders(wording: string, params?: TranslationParams): string;
 export declare const TranslationProvider: import("../../../global/di/types.js").ServiceIdentifier<TranslationService> & (<U extends TranslationService = TranslationService>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
 export declare const TranslationExtension: (service: TranslationService) => ExtensionType;
 /**
@@ -65,5 +99,9 @@ export declare const TranslationExtension: (service: TranslationService) => Exte
  *   made up.
  * - **Chrome** (the word "Warning" on a severity chip) passes an English
  *   default, so a standalone playground reads correctly without a catalogue.
+ *
+ * `params` fill the wording's `{{name}}` placeholders: handed to the host,
+ * which interpolates its own translation, and filled here into the fallback
+ * when the host has none.
  */
-export declare function translateKey(std: BlockStdScope, key: string, fallback?: string): string;
+export declare function translateKey(std: BlockStdScope, key: string, fallback?: string, params?: TranslationParams): string;

package/dist/_pkgs/affine-shared/services/translation-service/index.js

@@ -13,6 +13,41 @@ export function hostLanguage(std) {
         return undefined;
     return tag.split('-')[0].toLowerCase();
 }
+/**
+ * The host's full language tag (`'fr-CA'`), or `undefined` when no host said —
+ * for `Intl` formatting of dates and numbers, where the region matters
+ * (`en-GB` and `en-US` write a date differently). `undefined` hands `Intl` the
+ * runtime default, which is what the editor did before hosts could say.
+ */
+export function hostLocale(std) {
+    const tag = std.getOptional(TranslationProvider)?.language;
+    return typeof tag === 'string' && tag.length > 0 ? tag : undefined;
+}
+/**
+ * `hostLocale(std)`, defaulting to `'en-US'` when the host said nothing —
+ * the locale every `Intl.*Format` call in the library resolves against.
+ *
+ * Dates and numbers fall back to English like every string does, so a
+ * standalone playground stays deterministic: `Intl`'s own runtime-default
+ * fallback would instead read whatever locale the machine happens to have,
+ * which is not a fallback a test can assert on.
+ */
+export function formatLocale(std) {
+    return hostLocale(std) ?? 'en-US';
+}
+/**
+ * Fill `{{name}}` placeholders from `params`; a placeholder with no value is
+ * left as written, so a missing argument shows rather than vanishes.
+ *
+ * The library's side of interpolation only — used on the English fallback when
+ * the host has no entry. Pluralisation is the host's: a fallback stays neutral
+ * ("{{count}} element(s)").
+ */
+export function fillPlaceholders(wording, params) {
+    if (!params)
+        return wording;
+    return wording.replace(/\{\{\s*(\w+)\s*\}\}/g, (hole, name) => name in params ? String(params[name]) : hole);
+}
 export const TranslationProvider = createIdentifier('AffineTranslationService');
 export const TranslationExtension = (service) => {
     return {
@@ -33,8 +68,14 @@ export const TranslationExtension = (service) => {
  *   made up.
  * - **Chrome** (the word "Warning" on a severity chip) passes an English
  *   default, so a standalone playground reads correctly without a catalogue.
+ *
+ * `params` fill the wording's `{{name}}` placeholders: handed to the host,
+ * which interpolates its own translation, and filled here into the fallback
+ * when the host has none.
  */
-export function translateKey(std, key, fallback = key) {
-    const resolved = std.getOptional(TranslationProvider)?.t(key);
-    return resolved !== undefined && resolved !== '' ? resolved : fallback;
+export function translateKey(std, key, fallback = key, params) {
+    const resolved = std.getOptional(TranslationProvider)?.t(key, params);
+    return resolved !== undefined && resolved !== ''
+        ? resolved
+        : fillPlaceholders(fallback, params);
 }

package/dist/_pkgs/affine-shared/services/universe-tag-defs-service.d.ts

@@ -1,4 +1,4 @@
-import type { BlockStdScope, FrameworkId } from '../../std/index.js';
+import type { BlockStdScope, FrameworkId, TranslationKeyManifestEntry } from '../../std/index.js';
 import type { RoleDefs, RoleId } from '../../std/gfx/index.js';
 import type { ExtensionType } from '../../store/index.js';
 /**
@@ -15,9 +15,31 @@ export type TagValueId = string;
 export type TagValueDef = {
     /** `'<tagId>/<local>'`, e.g. `'wardley:nature/data'`. */
     id: TagValueId;
-    /** Display label, already localized by the host. */
+    /**
+     * Display label. For a HOST-seeded pack this is already localized — the app
+     * seeds a pack per deployment and `label` is that deployment's own wording,
+     * same as ever. For the library's OWN pack (`WARDLEY_TAG_DEFS`, the format's
+     * worked example) it is the ENGLISH fallback beside {@link labelKey}, on the
+     * same seam every other library string uses (ADR 0007 § 2bis's rule for role
+     * labels, extended here to tag values).
+     */
     label: string;
+    /**
+     * i18n key resolved by the host's catalogue, `label` its fallback — see
+     * {@link translateTagLabel}. Optional and additive: a pack seeded before this
+     * field existed (or a host pack that never sets it) still shows `label`
+     * exactly as it always has.
+     */
+    labelKey?: string;
     description?: string;
+    /**
+     * i18n key resolved by the host's catalogue, `description` its fallback —
+     * see {@link translateTagDescription}. Optional and additive, on the same
+     * seam as {@link labelKey}: a pack seeded before this field existed (or a
+     * host pack that never sets it) still shows `description` exactly as it
+     * always has.
+     */
+    descriptionKey?: string;
     /** Advisory colour token. The library may ignore it; it never affects layout. */
     color?: string;
     /** Hidden from pickers; still displayed when already present on an element. */
@@ -26,8 +48,13 @@ export type TagValueDef = {
 export type TagDef = {
     /** `'<framework>:<local>'`, e.g. `'wardley:nature'`. */
     id: QualifiedId;
+    /** See {@link TagValueDef.label}. */
     label: string;
+    /** See {@link TagValueDef.labelKey}. */
+    labelKey?: string;
     description?: string;
+    /** See {@link TagValueDef.descriptionKey}. */
+    descriptionKey?: string;
     /** How many values an element may carry for this tag. */
     cardinality: 'single' | 'multi';
     /** A closed list, or `'open'` for free-text values. */
@@ -68,8 +95,62 @@ export type UniverseTagDefs = {
     packId: string;
     framework: FrameworkId;
     label: string;
+    /**
+     * i18n key for the PACK's own `label` — see {@link TagValueDef.labelKey}
+     * for the seam. Optional and additive: a pack seeded before this field
+     * existed (or a host pack that never sets it) still shows `label` exactly
+     * as it always has.
+     */
+    labelKey?: string;
     tags: TagDef[];
 };
+/**
+ * The DISPLAYED wording of a tag def or a tag value def — {@link translateKey}
+ * over {@link TagDef.labelKey} / {@link TagValueDef.labelKey} when present,
+ * `label` unresolved otherwise (a host pack that never sets `labelKey` shows
+ * exactly what it always has).
+ *
+ * The one function every RENDERER of a tag label goes through — the "Qualify"
+ * toolbar's section titles and options (`tags-toolbar.ts`), the reading
+ * panel's nature value (`reading-widget.ts`). `resolveRecordNature` in
+ * `reading.ts` deliberately does NOT: it matches an external record's words
+ * against `label`, which is a comparison and not a display, and the wording it
+ * matches against is the one the record itself was written with.
+ *
+ * The same shape resolves a PACK's own `label` too (`UniverseTagDefs.label` /
+ * `.labelKey`): both carry an identical `{ label, labelKey? }` pair, so no
+ * second function is needed for it.
+ */
+export declare function translateTagLabel(std: BlockStdScope, def: Pick<TagDef | TagValueDef | UniverseTagDefs, 'label' | 'labelKey'>): string;
+/**
+ * The DISPLAYED description of a tag def or a tag value def —
+ * {@link translateKey} over {@link TagDef.descriptionKey} /
+ * {@link TagValueDef.descriptionKey} when present, `description` unresolved
+ * otherwise. The mirror of {@link translateTagLabel} for the `description`
+ * field, on the same seam: a def with no `descriptionKey` (a pack seeded
+ * before the field existed, or one that never sets it) keeps showing
+ * `description` exactly as it always has — including `undefined`, when the
+ * def carries no description at all.
+ */
+export declare function translateTagDescription(std: BlockStdScope, def: Pick<TagDef | TagValueDef, 'description' | 'descriptionKey'>): string | undefined;
+/**
+ * A pack's contribution to the translation-key manifest — every `labelKey`
+ * (the pack's own, a tag's, or a tag value's) and every `descriptionKey` (a
+ * tag's or a tag value's) it declares, paired with `label` / `description`
+ * as its English fallback.
+ *
+ * Manual, not `collectTranslationKeys('tag', pack)`: that generic walker pairs
+ * a `labelKey` with a sibling `labelFallback` (the roles' / rules' own
+ * convention), and this format's fallback field is named `label` — the same
+ * field a host-seeded pack's ALREADY-localized wording lives in. Walking it
+ * generically would either miss the fallback entirely or, worse, treat a
+ * host's own pack as a manifest contribution the library never asked for.
+ *
+ * For the library's own pack ONLY (`WARDLEY_TAG_DEFS` — see
+ * `wardleyTranslationEntries`); a host's app-seeded pack needs no entry here,
+ * because it carries no key at all unless the host itself decides to add one.
+ */
+export declare function tagDefsTranslationEntries(pack: UniverseTagDefs): TranslationKeyManifestEntry[];
 /** A seed-time problem, for a host diagnostics panel. Never thrown. */
 export type UniverseDefIssue = {
     severity: 'warning' | 'error';

package/dist/_pkgs/affine-shared/services/universe-tag-defs-service.js

@@ -24,11 +24,101 @@
 import { createIdentifier } from '../../global/di/index.js';
 import { FRAMEWORK_IDS } from '../../std/index.js';
 import { roleIsA } from '../../std/gfx/index.js';
+import { translateKey } from './translation-service/index.js';
 /**
  * Lower-kebab, case-sensitive, no unicode, no dots. Hyphenated framework ids
  * are legal, so `cynefin-estuarine:domain` is well formed.
  */
 const ID_PATTERN = /^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9-]*(\/[a-z0-9][a-z0-9-]*)?$/;
+/**
+ * The DISPLAYED wording of a tag def or a tag value def — {@link translateKey}
+ * over {@link TagDef.labelKey} / {@link TagValueDef.labelKey} when present,
+ * `label` unresolved otherwise (a host pack that never sets `labelKey` shows
+ * exactly what it always has).
+ *
+ * The one function every RENDERER of a tag label goes through — the "Qualify"
+ * toolbar's section titles and options (`tags-toolbar.ts`), the reading
+ * panel's nature value (`reading-widget.ts`). `resolveRecordNature` in
+ * `reading.ts` deliberately does NOT: it matches an external record's words
+ * against `label`, which is a comparison and not a display, and the wording it
+ * matches against is the one the record itself was written with.
+ *
+ * The same shape resolves a PACK's own `label` too (`UniverseTagDefs.label` /
+ * `.labelKey`): both carry an identical `{ label, labelKey? }` pair, so no
+ * second function is needed for it.
+ */
+export function translateTagLabel(std, def) {
+    return def.labelKey ? translateKey(std, def.labelKey, def.label) : def.label;
+}
+/**
+ * The DISPLAYED description of a tag def or a tag value def —
+ * {@link translateKey} over {@link TagDef.descriptionKey} /
+ * {@link TagValueDef.descriptionKey} when present, `description` unresolved
+ * otherwise. The mirror of {@link translateTagLabel} for the `description`
+ * field, on the same seam: a def with no `descriptionKey` (a pack seeded
+ * before the field existed, or one that never sets it) keeps showing
+ * `description` exactly as it always has — including `undefined`, when the
+ * def carries no description at all.
+ */
+export function translateTagDescription(std, def) {
+    if (!def.descriptionKey)
+        return def.description;
+    return translateKey(std, def.descriptionKey, def.description ?? '');
+}
+/**
+ * A pack's contribution to the translation-key manifest — every `labelKey`
+ * (the pack's own, a tag's, or a tag value's) and every `descriptionKey` (a
+ * tag's or a tag value's) it declares, paired with `label` / `description`
+ * as its English fallback.
+ *
+ * Manual, not `collectTranslationKeys('tag', pack)`: that generic walker pairs
+ * a `labelKey` with a sibling `labelFallback` (the roles' / rules' own
+ * convention), and this format's fallback field is named `label` — the same
+ * field a host-seeded pack's ALREADY-localized wording lives in. Walking it
+ * generically would either miss the fallback entirely or, worse, treat a
+ * host's own pack as a manifest contribution the library never asked for.
+ *
+ * For the library's own pack ONLY (`WARDLEY_TAG_DEFS` — see
+ * `wardleyTranslationEntries`); a host's app-seeded pack needs no entry here,
+ * because it carries no key at all unless the host itself decides to add one.
+ */
+export function tagDefsTranslationEntries(pack) {
+    const out = [];
+    if (pack.labelKey) {
+        out.push({ key: pack.labelKey, fallback: pack.label, source: 'tag' });
+    }
+    for (const tag of pack.tags) {
+        if (tag.labelKey) {
+            out.push({ key: tag.labelKey, fallback: tag.label, source: 'tag' });
+        }
+        if (tag.descriptionKey) {
+            out.push({
+                key: tag.descriptionKey,
+                fallback: tag.description ?? '',
+                source: 'tag',
+            });
+        }
+        if (tag.values !== 'open') {
+            for (const value of tag.values) {
+                if (value.labelKey) {
+                    out.push({
+                        key: value.labelKey,
+                        fallback: value.label,
+                        source: 'tag',
+                    });
+                }
+                if (value.descriptionKey) {
+                    out.push({
+                        key: value.descriptionKey,
+                        fallback: value.description ?? '',
+                        source: 'tag',
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}
 /**
  * Variant-parameterized: **one registration per pack, keyed by `packId`** —
  * the same mechanism as `SpotlightHostExtension(elementType)` and
@@ -158,6 +248,8 @@ function mergeTagDef(drafts, def, pack, issue, rank) {
     const draft = existing.def;
     if (def.label !== undefined)
         draft.label = def.label;
+    if (def.labelKey !== undefined)
+        draft.labelKey = def.labelKey;
     if (def.description !== undefined)
         draft.description = def.description;
     if (def.order !== undefined)

package/dist/_pkgs/affine-widget-drag-handle/components/edgeless-preview/preview.d.ts

@@ -1,3 +1,4 @@
+import type { BlockStdScope } from '../../../std/index.js';
 import { LitElement } from 'lit';
 declare global {
     interface HTMLElementTagNameMap {
@@ -10,6 +11,9 @@ export declare class EdgelessDndPreviewElement extends LitElement {
     accessor elementTypes: {
         type: string;
     }[];
+    /** Set by the caller that has one (`preview-helper.ts`) — optional so this
+     * element still renders (in English) when created with none. */
+    accessor std: BlockStdScope | undefined;
     private _getPreviewIcon;
     render(): import("lit-html").TemplateResult<1>;
 }

package/dist/_pkgs/affine-widget-drag-handle/components/edgeless-preview/preview.js

@@ -32,32 +32,34 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
+import { translateKey, } from '../../../affine-shared/services/index.js';
 import { unsafeCSSVarV2 } from '../../../affine-shared/theme/index.js';
 import { EmbedIcon, FrameIcon, ImageIcon, PageIcon, ShapeIcon, } from '@blocksuite/icons/lit';
 import { css, html, LitElement } from 'lit';
 import { property } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
+import { DRAG_PREVIEW_EMBED, DRAG_PREVIEW_FRAME, DRAG_PREVIEW_GENERIC, DRAG_PREVIEW_IMAGE, DRAG_PREVIEW_NOTE, DRAG_PREVIEW_SHAPE, } from '../../translations.js';
 const BLOCK_PREVIEW_ICON_MAP = {
     shape: {
         icon: ShapeIcon,
-        name: 'Edgeless shape',
+        wording: DRAG_PREVIEW_SHAPE,
     },
     'affine:image': {
         icon: ImageIcon,
-        name: 'Image block',
+        wording: DRAG_PREVIEW_IMAGE,
     },
     'affine:note': {
         icon: PageIcon,
-        name: 'Note block',
+        wording: DRAG_PREVIEW_NOTE,
     },
     'affine:frame': {
         icon: FrameIcon,
-        name: 'Frame block',
+        wording: DRAG_PREVIEW_FRAME,
     },
     'affine:embed-': {
         icon: EmbedIcon,
-        name: 'Embed block',
+        wording: DRAG_PREVIEW_EMBED,
     },
 };
 export const EDGELESS_DND_PREVIEW_ELEMENT = 'edgeless-dnd-preview-element';
@@ -66,11 +68,16 @@ let EdgelessDndPreviewElement = (() => {
     let _elementTypes_decorators;
     let _elementTypes_initializers = [];
     let _elementTypes_extraInitializers = [];
+    let _std_decorators;
+    let _std_initializers = [];
+    let _std_extraInitializers = [];
     return class EdgelessDndPreviewElement extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _elementTypes_decorators = [property({ type: Array })];
+            _std_decorators = [property({ attribute: false })];
             __esDecorate(this, null, _elementTypes_decorators, { kind: "accessor", name: "elementTypes", static: false, private: false, access: { has: obj => "elementTypes" in obj, get: obj => obj.elementTypes, set: (obj, value) => { obj.elementTypes = value; } }, metadata: _metadata }, _elementTypes_initializers, _elementTypes_extraInitializers);
+            __esDecorate(this, null, _std_decorators, { kind: "accessor", name: "std", static: false, private: false, access: { has: obj => "std" in obj, get: obj => obj.std, set: (obj, value) => { obj.std = value; } }, metadata: _metadata }, _std_initializers, _std_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static { this.styles = css `
@@ -115,6 +122,11 @@ let EdgelessDndPreviewElement = (() => {
         #elementTypes_accessor_storage = __runInitializers(this, _elementTypes_initializers, []);
         get elementTypes() { return this.#elementTypes_accessor_storage; }
         set elementTypes(value) { this.#elementTypes_accessor_storage = value; }
+        #std_accessor_storage = (__runInitializers(this, _elementTypes_extraInitializers), __runInitializers(this, _std_initializers, undefined));
+        /** Set by the caller that has one (`preview-helper.ts`) — optional so this
+         * element still renders (in English) when created with none. */
+        get std() { return this.#std_accessor_storage; }
+        set std(value) { this.#std_accessor_storage = value; }
         _getPreviewIcon(type) {
             if (BLOCK_PREVIEW_ICON_MAP[type]) {
                 return BLOCK_PREVIEW_ICON_MAP[type];
@@ -124,12 +136,13 @@ let EdgelessDndPreviewElement = (() => {
             }
             return {
                 icon: ShapeIcon,
-                name: 'Edgeless content',
+                wording: DRAG_PREVIEW_GENERIC,
             };
         }
         render() {
             const blocks = repeat(this.elementTypes.slice(0, 3), ({ type }, index) => {
-                const { icon, name } = this._getPreviewIcon(type);
+                const { icon, wording } = this._getPreviewIcon(type);
+                const name = this.std ? translateKey(this.std, ...wording) : wording[1];
                 return html `<div
         class="edgeless-dnd-preview-block"
         style=${styleMap({
@@ -145,7 +158,7 @@ let EdgelessDndPreviewElement = (() => {
         }
         constructor() {
             super(...arguments);
-            __runInitializers(this, _elementTypes_extraInitializers);
+            __runInitializers(this, _std_extraInitializers);
         }
     };
 })();

package/dist/_pkgs/affine-widget-drag-handle/helpers/preview-helper.js

@@ -126,6 +126,7 @@ export class PreviewHelper {
                 const blockTypes = this._extractBlockTypes(snapshot);
                 const edgelessPreview = new EdgelessDndPreviewElement();
                 edgelessPreview.elementTypes = blockTypes;
+                edgelessPreview.std = this.widget.std;
                 return {
                     left: 12,
                     top: 12,

package/dist/_pkgs/affine-widget-drag-handle/translations.d.ts

@@ -0,0 +1,14 @@
+import { type ChromeWording } from '../affine-shared/services/index.js';
+/**
+ * The drag-and-drop preview's own per-flavour labels, shown on the ghost
+ * card that follows the pointer while dragging edgeless content.
+ */
+export declare const DRAG_PREVIEW_SHAPE: ChromeWording;
+export declare const DRAG_PREVIEW_IMAGE: ChromeWording;
+export declare const DRAG_PREVIEW_NOTE: ChromeWording;
+export declare const DRAG_PREVIEW_FRAME: ChromeWording;
+export declare const DRAG_PREVIEW_EMBED: ChromeWording;
+/** An alias (L7 dedupe): the same word as {@link EDGELESS_CONTENT_LABEL}, one key. */
+export declare const DRAG_PREVIEW_GENERIC: ChromeWording;
+/** Every wording this package declares, in the order it renders them. */
+export declare const DRAG_HANDLE_WORDINGS: readonly ChromeWording[];

package/dist/_pkgs/affine-widget-drag-handle/translations.js

@@ -0,0 +1,35 @@
+import { EDGELESS_CONTENT_LABEL, } from '../affine-shared/services/index.js';
+/**
+ * The drag-and-drop preview's own per-flavour labels, shown on the ghost
+ * card that follows the pointer while dragging edgeless content.
+ */
+export const DRAG_PREVIEW_SHAPE = [
+    'com.labre.drag-handle.preview.shape',
+    'Canvas shape',
+];
+export const DRAG_PREVIEW_IMAGE = [
+    'com.labre.drag-handle.preview.image',
+    'Image block',
+];
+export const DRAG_PREVIEW_NOTE = [
+    'com.labre.drag-handle.preview.note',
+    'Note block',
+];
+export const DRAG_PREVIEW_FRAME = [
+    'com.labre.drag-handle.preview.frame',
+    'Frame block',
+];
+export const DRAG_PREVIEW_EMBED = [
+    'com.labre.drag-handle.preview.embed',
+    'Embed block',
+];
+/** An alias (L7 dedupe): the same word as {@link EDGELESS_CONTENT_LABEL}, one key. */
+export const DRAG_PREVIEW_GENERIC = EDGELESS_CONTENT_LABEL;
+/** Every wording this package declares, in the order it renders them. */
+export const DRAG_HANDLE_WORDINGS = [
+    DRAG_PREVIEW_SHAPE,
+    DRAG_PREVIEW_IMAGE,
+    DRAG_PREVIEW_NOTE,
+    DRAG_PREVIEW_FRAME,
+    DRAG_PREVIEW_EMBED,
+];

package/dist/_pkgs/affine-widget-edgeless-auto-connect/index.js

@@ -35,7 +35,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 import { EdgelessCRUDIdentifier, EdgelessLegacySlotIdentifier, isNoteBlock, } from '../affine-block-surface/index.js';
 import { SmallDocIcon } from '../affine-components/icons/index.js';
 import { FrameBlockModel, NoteBlockModel, NoteDisplayMode, SurfaceRefBlockModel, } from '../affine-model/index.js';
-import { FeatureFlagService } from '../affine-shared/services/index.js';
+import { FeatureFlagService, translateKey, } from '../affine-shared/services/index.js';
 import { matchModels, stopPropagation } from '../affine-shared/utils/index.js';
 import { Bound } from '../global/gfx/index.js';
 import { ArrowLeftSmallIcon, ArrowRightSmallIcon, InvisibleIcon, } from '@blocksuite/icons/lit';
@@ -46,6 +46,7 @@ import { state } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { literal, unsafeStatic } from 'lit/static-html.js';
+import { AUTO_CONNECT_HIDDEN_ON_PAGE, AUTO_CONNECT_PAGE_MODE_INDEX, } from './translations.js';
 const PAGE_VISIBLE_INDEX_LABEL_WIDTH = 44;
 const PAGE_VISIBLE_INDEX_LABEL_HEIGHT = 24;
 const EDGELESS_ONLY_INDEX_LABEL_WIDTH = 24;
@@ -246,7 +247,7 @@ let EdgelessAutoConnectWidget = (() => {
                 return html `<div style=${style} class="edgeless-only-index-label">
           ${InvisibleIcon({ width: '20px', height: '20px' })}
           <affine-tooltip tip-position="bottom">
-            ${getIndexLabelTooltip(SmallDocIcon, 'Hidden on page')}
+            ${getIndexLabelTooltip(SmallDocIcon, translateKey(this.std, ...AUTO_CONNECT_HIDDEN_ON_PAGE))}
           </affine-tooltip>
         </div>`;
             })}`;
@@ -424,7 +425,7 @@ let EdgelessAutoConnectWidget = (() => {
             >
               ${index}
               <affine-tooltip tip-position="bottom">
-                ${getIndexLabelTooltip(SmallDocIcon, 'Page mode index')}
+                ${getIndexLabelTooltip(SmallDocIcon, translateKey(this.std, ...AUTO_CONNECT_PAGE_MODE_INDEX))}
               </affine-tooltip>
             </div>
           `);

package/dist/_pkgs/affine-widget-edgeless-auto-connect/translations.d.ts

@@ -0,0 +1,6 @@
+import type { ChromeWording } from '../affine-shared/services/index.js';
+/** The note-index badge's two tooltips, in page vs. edgeless-only mode. */
+export declare const AUTO_CONNECT_HIDDEN_ON_PAGE: ChromeWording;
+export declare const AUTO_CONNECT_PAGE_MODE_INDEX: ChromeWording;
+/** Every wording this package declares, in the order it renders them. */
+export declare const AUTO_CONNECT_WORDINGS: readonly ChromeWording[];

package/dist/_pkgs/affine-widget-edgeless-auto-connect/translations.js

@@ -0,0 +1,14 @@
+/** The note-index badge's two tooltips, in page vs. edgeless-only mode. */
+export const AUTO_CONNECT_HIDDEN_ON_PAGE = [
+    'com.labre.auto-connect.hidden-on-page',
+    'Hidden on document',
+];
+export const AUTO_CONNECT_PAGE_MODE_INDEX = [
+    'com.labre.auto-connect.page-mode-index',
+    'Document mode index',
+];
+/** Every wording this package declares, in the order it renders them. */
+export const AUTO_CONNECT_WORDINGS = [
+    AUTO_CONNECT_HIDDEN_ON_PAGE,
+    AUTO_CONNECT_PAGE_MODE_INDEX,
+];

package/dist/_pkgs/affine-widget-edgeless-selected-rect/auto-complete-panel.js

@@ -38,7 +38,7 @@ import { FontFamilyIcon } from '../affine-components/icons/index.js';
 import { mountShapeTextEditor, SHAPE_OVERLAY_HEIGHT, SHAPE_OVERLAY_WIDTH, ShapeComponentConfig, } from '../affine-gfx-shape/index.js';
 import { insertEdgelessTextCommand, mountTextElementEditor, } from '../affine-gfx-text/index.js';
 import { DEFAULT_NOTE_WIDTH, DefaultTheme, FontFamily, FontStyle, FontWeight, getShapeName, GroupElementModel, NoteBlockModel, ShapeStyle, TextElementModel, } from '../affine-model/index.js';
-import { EditPropsStore, FeatureFlagService, ThemeProvider, } from '../affine-shared/services/index.js';
+import { EditPropsStore, FeatureFlagService, ThemeProvider, translateKey, } from '../affine-shared/services/index.js';
 import { captureEventTarget, matchModels, overlayScale, overlayViewportSize, toOverlayCoord, } from '../affine-shared/utils/index.js';
 import { Bound, clamp, normalizeDegAngle, serializeXYWH, toDegree, Vec, } from '../global/gfx/index.js';
 import { WithDisposable } from '../global/lit/index.js';
@@ -53,6 +53,7 @@ import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import * as Y from 'yjs';
 import { AutoCompleteFrameOverlay, AutoCompleteNoteOverlay, AutoCompleteShapeOverlay, AutoCompleteTextOverlay, capitalizeFirstLetter, createShapeElement, DEFAULT_NOTE_OVERLAY_HEIGHT, DEFAULT_TEXT_HEIGHT, DEFAULT_TEXT_WIDTH, Direction, isShape, PANEL_HEIGHT, PANEL_WIDTH, } from './utils.js';
+import { AUTO_COMPLETE_ADD_SAME_OBJECT, AUTO_COMPLETE_FRAME, AUTO_COMPLETE_NOTE, AUTO_COMPLETE_TEXT, } from './translations.js';
 let EdgelessAutoCompletePanel = (() => {
     let _classSuper = WithDisposable(LitElement);
     let _connector_decorators;
@@ -544,7 +545,7 @@ let EdgelessAutoCompletePanel = (() => {
       ${shapeButtons}
 
       <edgeless-tool-icon-button
-        .tooltip=${'Text'}
+        .tooltip=${translateKey(this.std, ...AUTO_COMPLETE_TEXT)}
         .iconSize=${'20px'}
         @pointerenter=${() => this._showOverlay('text')}
         @pointerleave=${() => this._removeOverlay()}
@@ -553,7 +554,7 @@ let EdgelessAutoCompletePanel = (() => {
         ${FontFamilyIcon}
       </edgeless-tool-icon-button>
       <edgeless-tool-icon-button
-        .tooltip=${'Note'}
+        .tooltip=${translateKey(this.std, ...AUTO_COMPLETE_NOTE)}
         .iconSize=${'20px'}
         @pointerenter=${() => this._showOverlay('note')}
         @pointerleave=${() => this._removeOverlay()}
@@ -562,7 +563,7 @@ let EdgelessAutoCompletePanel = (() => {
         ${PageIcon()}
       </edgeless-tool-icon-button>
       <edgeless-tool-icon-button
-        .tooltip=${'Frame'}
+        .tooltip=${translateKey(this.std, ...AUTO_COMPLETE_FRAME)}
         .iconSize=${'20px'}
         @pointerenter=${() => this._showOverlay('frame')}
         @pointerleave=${() => this._removeOverlay()}
@@ -578,7 +579,9 @@ let EdgelessAutoCompletePanel = (() => {
         @pointerleave=${() => this._removeOverlay()}
         @click=${() => this._autoComplete(currentSourceType)}
       >
-        <div class="row-button">Add a same object</div>
+        <div class="row-button">
+          ${translateKey(this.std, ...AUTO_COMPLETE_ADD_SAME_OBJECT)}
+        </div>
       </edgeless-tool-icon-button>
     </div>`;
         }

package/dist/_pkgs/affine-widget-edgeless-selected-rect/edgeless-auto-complete.js

@@ -34,9 +34,10 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { CanvasElementType, EdgelessCRUDIdentifier, getSurfaceBlock, getSurfaceComponent, isNoteBlock, Overlay, OverlayIdentifier, } from '../affine-block-surface/index.js';
 import { ConnectorPathGenerator, } from '../affine-gfx-connector/index.js';
+import { MINDMAP_SEED_NEW_NODE } from '../affine-gfx-mindmap/translations.js';
 import { mountShapeTextEditor } from '../affine-gfx-shape/index.js';
 import { DEFAULT_NOTE_HEIGHT, DefaultTheme, LayoutType, MindmapElementModel, ShapeElementModel, shapeMethods, } from '../affine-model/index.js';
-import { ToolbarRegistryIdentifier } from '../affine-shared/services/index.js';
+import { ToolbarRegistryIdentifier, translateKey, } from '../affine-shared/services/index.js';
 import { handleNativeRangeAtPoint, toClientCoord, } from '../affine-shared/utils/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
 import { Vec } from '../global/gfx/index.js';
@@ -228,7 +229,7 @@ let EdgelessAutoComplete = (() => {
             const parentNode = mindmap.getNode(parent.id);
             if (!parentNode)
                 return;
-            const newNode = mindmap.addNode(parentNode.id, target === 'sibling' ? this.current.id : undefined, undefined, undefined);
+            const newNode = mindmap.addNode(parentNode.id, target === 'sibling' ? this.current.id : undefined, undefined, { text: translateKey(this.std, ...MINDMAP_SEED_NEW_NODE) });
             if (parentNode.detail.collapsed) {
                 mindmap.toggleCollapse(parentNode);
             }