@formicoidea/labre-core 0.40.0 → 0.42.0

package/dist/_pkgs/affine-gfx-mindmap/toolbar/basket-elements.js

@@ -3,10 +3,11 @@ import { addImages } from '../../affine-block-image/index.js';
 import { CanvasElementType, EdgelessCRUDIdentifier, } from '../../affine-block-surface/index.js';
 import { insertEdgelessTextCommand, mountTextElementEditor, } from '../../affine-gfx-text/index.js';
 import { MAX_IMAGE_WIDTH, TextElementModel, } from '../../affine-model/index.js';
-import { FeatureFlagService, TelemetryProvider, } from '../../affine-shared/services/index.js';
+import { FeatureFlagService, TelemetryProvider, translateKey, } from '../../affine-shared/services/index.js';
 import { openSingleFileWith } from '../../affine-shared/utils/index.js';
 import { Bound } from '../../global/gfx/index.js';
 import * as Y from 'yjs';
+import { MINDMAP_SEED_CHILD, MINDMAP_SEED_ROOT } from '../translations.js';
 const unitMap = { x: 'px', y: 'px', r: 'deg', s: '', z: '', o: '' };
 export const textConfig = {
     default: { x: -20, y: -8, r: 7.74, s: 0.92, z: 3 },
@@ -35,9 +36,12 @@ export const getMindmapRender = (mindmapStyle) => async (bound, edgeless) => {
     const centerVertical = y + h / 2;
     const rootX = x;
     const rootY = centerVertical - rootH / 2;
+    // Translated HERE and once: the captions are document content the moment
+    // they land (ADR 0023), so the host's catalogue is asked at placement and
+    // never again.
     const root = {
         children: [],
-        text: 'Mind Map',
+        text: translateKey(edgeless.std, ...MINDMAP_SEED_ROOT),
         xywh: `[${rootX},${rootY},${rootW},${rootH}]`,
     };
     for (let i = 0; i < 3; i++) {
@@ -45,7 +49,7 @@ export const getMindmapRender = (mindmapStyle) => async (bound, edgeless) => {
         const nodeY = centerVertical - nodeH / 2 + (i - 1) * 50;
         root.children.push({
             children: [],
-            text: 'Text',
+            text: translateKey(edgeless.std, ...MINDMAP_SEED_CHILD),
             xywh: `[${nodeX},${nodeY},${nodeW},${nodeH}]`,
         });
     }

package/dist/_pkgs/affine-gfx-mindmap/toolbar/config.js

@@ -1,8 +1,9 @@
 import { hasGrouped } from '../../affine-gfx-shape/index.js';
 import { LayoutType, MindmapElementModel, MindmapStyle, ShapeElementModel, } from '../../affine-model/index.js';
-import { ToolbarModuleExtension, } from '../../affine-shared/services/index.js';
+import { STYLE_MENU_LABEL, ToolbarModuleExtension, } from '../../affine-shared/services/index.js';
 import { getMostCommonValue } from '../../affine-shared/utils/index.js';
 import { renderMenu, } from '../../affine-widget-edgeless-toolbar/index.js';
+import { MINDMAP_LAYOUT_LABEL, MINDMAP_LAYOUT_LEFT, MINDMAP_LAYOUT_RADIAL, MINDMAP_LAYOUT_RIGHT, } from '../translations.js';
 import { RadiantIcon, RightLayoutIcon, StyleIcon } from '@blocksuite/icons/lit';
 import { BlockFlavourIdentifier } from '../../std/index.js';
 import { MindmapStyleFour, MindmapStyleOne, MindmapStyleThree, MindmapStyleTwo, } from '../view/index.js';
@@ -27,6 +28,7 @@ const MINDMAP_STYLE_LIST = [
 const MINDMAP_LAYOUT_LIST = [
     {
         key: 'Left',
+        keyWording: MINDMAP_LAYOUT_LEFT,
         value: LayoutType.LEFT,
         icon: RightLayoutIcon({
             style: 'transform: rotate(0.5turn); transform-origin: center;',
@@ -34,11 +36,13 @@ const MINDMAP_LAYOUT_LIST = [
     },
     {
         key: 'Radial',
+        keyWording: MINDMAP_LAYOUT_RADIAL,
         value: LayoutType.BALANCE,
         icon: RadiantIcon(),
     },
     {
         key: 'Right',
+        keyWording: MINDMAP_LAYOUT_RIGHT,
         value: LayoutType.RIGHT,
         icon: RightLayoutIcon(),
     },
@@ -53,10 +57,12 @@ export const createMindmapStyleActionMenu = (ctx, models) => {
     };
     return renderMenu({
         label: 'Style',
+        labelWording: STYLE_MENU_LABEL,
         icon: StyleIcon(),
         items: MINDMAP_STYLE_LIST,
         currentValue: style,
         onPick,
+        std: ctx.std,
     });
 };
 export const createMindmapLayoutActionMenu = (ctx, models) => {
@@ -70,9 +76,11 @@ export const createMindmapLayoutActionMenu = (ctx, models) => {
     };
     return renderMenu({
         label: 'Layout',
+        labelWording: MINDMAP_LAYOUT_LABEL,
         items: MINDMAP_LAYOUT_LIST,
         currentValue: layoutType,
         onPick,
+        std: ctx.std,
     });
 };
 export const mindmapToolbarConfig = {

package/dist/_pkgs/affine-gfx-mindmap/toolbar/mindmap-importing-placeholder.d.ts

@@ -1,5 +1,9 @@
+import type { BlockStdScope } from '../../std/index.js';
 import { ShadowlessElement } from '../../std/index.js';
 export declare class MindMapPlaceholder extends ShadowlessElement {
+    /** Set by the caller that has one (`mindmap-menu.ts`) — optional so this
+     * element still renders (in English) when created with none. */
+    accessor std: BlockStdScope | undefined;
     static styles: import("lit").CSSResult;
     render(): import("lit-html").TemplateResult<1>;
 }

package/dist/_pkgs/affine-gfx-mindmap/toolbar/mindmap-importing-placeholder.js

@@ -1,10 +1,63 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
 import { LoadingIcon } from '../../affine-components/icons/index.js';
+import { translateKey } from '../../affine-shared/services/index.js';
 import { unsafeCSSVarV2 } from '../../affine-shared/theme/index.js';
 import { ShadowlessElement } from '../../std/index.js';
 import { css, html } from 'lit';
+import { property } from 'lit/decorators.js';
+import { MINDMAP_IMPORTING_PLACEHOLDER } from '../translations.js';
 import { importMindMapIcon } from './icons.js';
-export class MindMapPlaceholder extends ShadowlessElement {
-    static { this.styles = css `
+let MindMapPlaceholder = (() => {
+    let _classSuper = ShadowlessElement;
+    let _std_decorators;
+    let _std_initializers = [];
+    let _std_extraInitializers = [];
+    return class MindMapPlaceholder extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _std_decorators = [property({ attribute: false })];
+            __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 });
+        }
+        #std_accessor_storage = __runInitializers(this, _std_initializers, undefined);
+        /** Set by the caller that has one (`mindmap-menu.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; }
+        static { this.styles = css `
     mindmap-import-placeholder {
       display: flex;
       flex-direction: column;
@@ -39,13 +92,23 @@ export class MindMapPlaceholder extends ShadowlessElement {
       align-items: center;
     }
   `; }
-    render() {
-        return html `<div class="placeholder-container">
+        render() {
+            return html `<div class="placeholder-container">
       <div class="preview-icon">${importMindMapIcon}</div>
       <div class="description">
         ${LoadingIcon()}
-        <span>Importing mind map...</span>
+        <span
+          >${this.std
+                ? translateKey(this.std, ...MINDMAP_IMPORTING_PLACEHOLDER)
+                : MINDMAP_IMPORTING_PLACEHOLDER[1]}</span
+        >
       </div>
     </div>`;
-    }
-}
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _std_extraInitializers);
+        }
+    };
+})();
+export { MindMapPlaceholder };

package/dist/_pkgs/affine-gfx-mindmap/toolbar/mindmap-menu.js

@@ -45,10 +45,12 @@ import { computed } from '@preact/signals-core';
 import { css, html, LitElement, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
+import { translateKey } from '../../affine-shared/services/index.js';
 import { getMindMaps } from './assets.js';
 import { mediaRender, textRender } from './basket-elements.js';
 import { importMindMapIcon, mindmapMenuMediaIcon, textIcon } from './icons.js';
 import { MindMapPlaceholder } from './mindmap-importing-placeholder.js';
+import { MINDMAP_ADD_MEDIA_TOOLTIP, MINDMAP_EDGELESS_TEXT_TOOLTIP, MINDMAP_IMPORT_FAILED_TOAST, MINDMAP_IMPORT_TOOLTIP, MINDMAP_TOOLTIP, } from '../translations.js';
 const textItem = { type: 'text', icon: textIcon, render: textRender };
 const mediaItem = {
     type: 'media',
@@ -187,13 +189,14 @@ let EdgelessMindmapMenu = (() => {
       </button>
       <affine-tooltip tip-position="top" .offset=${12}>
         <affine-tooltip-content-with-shortcut
-          data-tip="${'Support import of FreeMind,OPML.'}"
+          data-tip="${translateKey(this.std, ...MINDMAP_IMPORT_TOOLTIP)}"
         ></affine-tooltip-content-with-shortcut>
       </affine-tooltip>
     </div>`;
         }
         _onImportMindMap(bound) {
             const placeholder = new MindMapPlaceholder();
+            placeholder.std = this.std;
             placeholder.style.position = 'absolute';
             placeholder.style.left = `${bound.x}px`;
             placeholder.style.top = `${bound.y}px`;
@@ -216,7 +219,7 @@ let EdgelessMindmapMenu = (() => {
                     other: 'failed',
                     module: 'toolbar',
                 });
-                toast(this.edgeless.host, 'Import failed, please try again');
+                toast(this.edgeless.host, translateKey(this.std, ...MINDMAP_IMPORT_FAILED_TOAST));
                 console.error(e);
             })
                 .finally(() => {
@@ -310,7 +313,7 @@ let EdgelessMindmapMenu = (() => {
               </button>
               <affine-tooltip tip-position="top" .offset=${12}>
                 <affine-tooltip-content-with-shortcut
-                  data-tip="${'Add media'}"
+                  data-tip="${translateKey(this.std, ...MINDMAP_ADD_MEDIA_TOOLTIP)}"
                 ></affine-tooltip-content-with-shortcut>
               </affine-tooltip>
             </div>
@@ -339,7 +342,7 @@ let EdgelessMindmapMenu = (() => {
               </button>
               <affine-tooltip tip-position="top" .offset=${12}>
                 <affine-tooltip-content-with-shortcut
-                  data-tip="${'Edgeless Text'}"
+                  data-tip="${translateKey(this.std, ...MINDMAP_EDGELESS_TEXT_TOOLTIP)}"
                   data-shortcup="${'T'}"
                 ></affine-tooltip-content-with-shortcut>
               </affine-tooltip>
@@ -386,7 +389,7 @@ let EdgelessMindmapMenu = (() => {
                   </button>
                   <affine-tooltip tip-position="top" .offset=${12}>
                     <affine-tooltip-content-with-shortcut
-                      data-tip="${'Mind Map'}"
+                      data-tip="${translateKey(this.std, ...MINDMAP_TOOLTIP)}"
                       data-shortcup="${'M'}"
                     ></affine-tooltip-content-with-shortcut>
                   </affine-tooltip>

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

@@ -44,7 +44,9 @@ import { property, query, state } from 'lit/decorators.js';
 import { classMap } from 'lit/directives/class-map.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
+import { translateKey } from '../../affine-shared/services/index.js';
 import { getMindMaps } from './assets.js';
+import { MINDMAP_TOOLTIP } from '../translations.js';
 import { getMindmapRender, mediaConfig, mediaRender, mindmapConfig, textConfig, textRender, toolConfig2StyleObj, } from './basket-elements.js';
 import { mindmapMenuMediaIcon, textIcon } from './icons.js';
 import { importMindmap } from './utils/import-mindmap.js';
@@ -179,7 +181,7 @@ let EdgelessMindmapToolButton = (() => {
                     });
                 },
                 onImportMindMap: (bound) => {
-                    return importMindmap(bound).then(mindmap => {
+                    return importMindmap(bound, this.edgeless.std).then(mindmap => {
                         const id = this.crud.addElement('mindmap', {
                             children: mindmap,
                             layoutType: mindmap?.layoutType === 'left' ? 1 : 0,
@@ -317,7 +319,7 @@ let EdgelessMindmapToolButton = (() => {
       .tooltip=${popper
                 ? ''
                 : this.variant === 'mindmap'
-                    ? 'Mind Map'
+                    ? translateKey(this.edgeless.std, ...MINDMAP_TOOLTIP)
                     : 'Others'}
       .tooltipOffset=${4}
       @click=${this._toggleMenu}

package/dist/_pkgs/affine-gfx-mindmap/toolbar/senior-tool.js

@@ -1,11 +1,14 @@
+import { translateKey, TOOL_NAME_TEXT } from '../../affine-shared/services/index.js';
 import { SeniorToolExtension } from '../../affine-widget-edgeless-toolbar/index.js';
 import { Bound } from '../../global/gfx/index.js';
 import { html } from 'lit';
 import { mediaRender, textRender } from './basket-elements.js';
 import { mindmapMenuMediaIcon, textIcon } from './icons.js';
+import { MINDMAP_ADD_FILE_TOOL, MINDMAP_TOOLTIP } from '../translations.js';
 export const mindMapSeniorTool = SeniorToolExtension('mindMap', ({ block, toolbarContainer }) => {
     return {
         name: 'Mind Map',
+        labelKey: MINDMAP_TOOLTIP[0],
         content: html `<edgeless-mindmap-tool-button
         .edgeless=${block}
         .toolbarContainer=${toolbarContainer}
@@ -55,7 +58,8 @@ const slot = (icon, tooltip, onClick) => html `<style>
  */
 export const textSeniorTool = SeniorToolExtension('edgeless-text', ({ block, gfx }) => ({
     name: 'Text',
-    content: slot(textIcon, 'Text', () => {
+    labelKey: TOOL_NAME_TEXT[0],
+    content: slot(textIcon, translateKey(block.std, ...TOOL_NAME_TEXT), () => {
         const { centerX, centerY } = gfx.viewport;
         void textRender(new Bound(centerX - 50, centerY - 16, 100, 32), block);
     }),
@@ -67,7 +71,8 @@ export const textSeniorTool = SeniorToolExtension('edgeless-text', ({ block, gfx
  */
 export const mediaSeniorTool = SeniorToolExtension('edgeless-media', ({ block, gfx }) => ({
     name: 'Add file',
-    content: slot(mindmapMenuMediaIcon, 'Add file', () => {
+    labelKey: MINDMAP_ADD_FILE_TOOL[0],
+    content: slot(mindmapMenuMediaIcon, translateKey(block.std, ...MINDMAP_ADD_FILE_TOOL), () => {
         const { centerX, centerY } = gfx.viewport;
         void mediaRender(new Bound(centerX - 50, centerY - 50, 100, 100), block);
     }),

package/dist/_pkgs/affine-gfx-mindmap/toolbar/utils/import-mindmap.d.ts

@@ -1,4 +1,5 @@
 import type { Bound } from '../../../global/gfx/index.js';
+import type { BlockStdScope } from '../../../std/index.js';
 type MindMapNode = {
     children: MindMapNode[];
     text: string;
@@ -6,5 +7,5 @@ type MindMapNode = {
     title?: string;
     layoutType?: 'left' | 'right';
 };
-export declare function importMindmap(bound: Bound): Promise<MindMapNode>;
+export declare function importMindmap(bound: Bound, std: BlockStdScope): Promise<MindMapNode>;
 export {};

package/dist/_pkgs/affine-gfx-mindmap/toolbar/utils/import-mindmap.js

@@ -1,17 +1,19 @@
+import { translateKey } from '../../../affine-shared/services/index.js';
 import { openSingleFileWith } from '../../../affine-shared/utils/index.js';
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import c from 'simple-xml-to-json';
-export async function importMindmap(bound) {
+import { MINDMAP_SEED_IMPORTED_NODE } from '../../translations.js';
+export async function importMindmap(bound, std) {
     const file = await openSingleFileWith('MindMap');
     if (!file) {
         throw new BlockSuiteError(ErrorCode.UserAbortError, 'Aborted by user');
     }
     let result;
     if (file.name.endsWith('.mm')) {
-        result = await parseMmFile(file);
+        result = await parseMmFile(file, std);
     }
     else if (file.name.endsWith('.opml') || file.name.endsWith('.xml')) {
-        result = await parseOPMLFile(file);
+        result = await parseOPMLFile(file, std);
     }
     else {
         throw new BlockSuiteError(ErrorCode.ParsingError, 'Unsupported file type');
@@ -24,8 +26,11 @@ export async function importMindmap(bound) {
 function readAsText(file) {
     return file.text();
 }
-async function parseMmFile(file) {
+async function parseMmFile(file, std) {
     const content = await readAsText(file);
+    // Translated HERE and once: a node with no text is document content the
+    // moment the import lands (ADR 0023).
+    const untitled = translateKey(std, ...MINDMAP_SEED_IMPORTED_NODE);
     try {
         const parsed = c.convertXML(content);
         const map = parsed.map.children[0];
@@ -36,13 +41,13 @@ async function parseMmFile(file) {
             return node.node.POSITION
                 ? {
                     layoutType: node.node.POSITION,
-                    text: node.node.TEXT ?? 'MINDMAP',
+                    text: node.node.TEXT ?? untitled,
                     children: node.node.children
                         ?.map(traverse)
                         .filter(node => node) ?? [],
                 }
                 : {
-                    text: node.node.TEXT ?? 'MINDMAP',
+                    text: node.node.TEXT ?? untitled,
                     children: node.node.children
                         ?.map(traverse)
                         .filter(node => node) ?? [],
@@ -59,8 +64,11 @@ async function parseMmFile(file) {
         throw new BlockSuiteError(ErrorCode.ParsingError, 'Failed to parse mm file');
     }
 }
-async function parseOPMLFile(file) {
+async function parseOPMLFile(file, std) {
     const content = await readAsText(file);
+    // Translated HERE and once: a node with no text is document content the
+    // moment the import lands (ADR 0023).
+    const untitled = translateKey(std, ...MINDMAP_SEED_IMPORTED_NODE);
     try {
         const parsed = c.convertXML(content);
         const outline = parsed.opml?.children[1].body?.children?.[0];
@@ -69,7 +77,7 @@ async function parseOPMLFile(file) {
                 return null;
             }
             return {
-                text: node.outline?.text ?? 'MINDMAP',
+                text: node.outline?.text ?? untitled,
                 children: node.outline.children
                     ? node.outline.children.map(traverse)
                     : [],

package/dist/_pkgs/affine-gfx-mindmap/translations.d.ts

@@ -0,0 +1,84 @@
+import { type ChromeWording } from '../affine-shared/services/index.js';
+/**
+ * The mindmap's own seeds: the captions a freshly placed mindmap is written
+ * with, wherever the gesture draws one directly (the toolbar's built-in
+ * templates, the drag-from-basket tool, a `.mm`/`.opml` import that meets an
+ * empty node). Resolved at PLACEMENT and never again (ADR 0023) — a node
+ * renamed by its author keeps its name, and a mindmap created before these
+ * keys existed keeps the plain text it was given.
+ *
+ * `root` and `child` are shared by every gesture that draws a plain mindmap
+ * with no real content yet (the built-in templates and the basket tool both
+ * write the same two words); `topic1`–`topic3` are the three placeholder
+ * children the STARTER TEMPLATES draw, one key per position; `imported-node`
+ * is what a `.mm` / `.opml` file's own untitled node becomes.
+ */
+export declare const MINDMAP_SEED_ROOT: ChromeWording;
+export declare const MINDMAP_SEED_CHILD: ChromeWording;
+export declare const MINDMAP_SEED_TOPIC_1: ChromeWording;
+export declare const MINDMAP_SEED_TOPIC_2: ChromeWording;
+export declare const MINDMAP_SEED_TOPIC_3: ChromeWording;
+export declare const MINDMAP_SEED_IMPORTED_NODE: ChromeWording;
+/**
+ * The mindmap model's `addNode` (`packages/affine/model`, a red zone this
+ * package never edits) defaults an untitled node's text to the literal
+ * `'New node'` when no caller supplies one. Declared here — a seed, resolved
+ * at the gesture that calls `addNode`, never again — so every call site that
+ * relied on the model's own default can pass this instead:
+ * `{ text: translateKey(std, ...MINDMAP_SEED_NEW_NODE) }`. Used by this
+ * package's own gestures and by `widgets/edgeless-selected-rect`'s
+ * "add sibling / child node" action (`edgeless-auto-complete.ts`);
+ * `blocks/root` imports it directly for its own call sites onto the same
+ * model.
+ */
+export declare const MINDMAP_SEED_NEW_NODE: ChromeWording;
+/**
+ * This package's contribution to the translation-key manifest, listed in
+ * `PACKAGE_SEED_WORDINGS` under source `seed`
+ * (`packages/affine/all/src/translations.ts`).
+ */
+export declare const MINDMAP_SEED_WORDINGS: readonly ChromeWording[];
+/**
+ * "Mind Map" said as chrome rather than as a seed: the template-panel
+ * category tab, the senior/quick tool's own name, and every tooltip that
+ * names the mindmap tool — one word, one key, reused across every drawer in
+ * this package.
+ */
+export declare const MINDMAP_TOOLTIP: ChromeWording;
+/** The Templates panel's "Mind Map" category tab (`TemplateCategory.nameKey`). */
+export declare const MINDMAP_TEMPLATE_CATEGORY: ChromeWording;
+/**
+ * The four starter templates' own tile names (`Template.nameKey`) — chrome,
+ * resolved by the panel widget every time it opens, distinct from the seeds
+ * ({@link MINDMAP_SEED_WORDINGS}) each starter WRITES into the document.
+ */
+export declare const MINDMAP_TEMPLATE_NAME_STYLE_1: ChromeWording;
+export declare const MINDMAP_TEMPLATE_NAME_STYLE_2: ChromeWording;
+export declare const MINDMAP_TEMPLATE_NAME_STYLE_3: ChromeWording;
+export declare const MINDMAP_TEMPLATE_NAME_STYLE_4: ChromeWording;
+export declare const MINDMAP_LAYOUT_LABEL: ChromeWording;
+/**
+ * The three layout directions — a different concept from `gfx/text`'s own
+ * "Left" / "Right" text alignment (`TEXT_ALIGN_LEFT`/`RIGHT`), so kept as
+ * this package's own keys: the English word coincides, the meaning (which
+ * way the tree grows vs. how a line of text sits) does not.
+ */
+export declare const MINDMAP_LAYOUT_LEFT: ChromeWording;
+export declare const MINDMAP_LAYOUT_RADIAL: ChromeWording;
+export declare const MINDMAP_LAYOUT_RIGHT: ChromeWording;
+export declare const MINDMAP_IMPORT_TOOLTIP: ChromeWording;
+export declare const MINDMAP_IMPORT_FAILED_TOAST: ChromeWording;
+export declare const MINDMAP_IMPORTING_PLACEHOLDER: ChromeWording;
+export declare const MINDMAP_ADD_MEDIA_TOOLTIP: ChromeWording;
+export declare const MINDMAP_EDGELESS_TEXT_TOOLTIP: ChromeWording;
+/** The promoted "Add file" senior tool's own name/tooltip. */
+export declare const MINDMAP_ADD_FILE_TOOL: ChromeWording;
+/**
+ * This package's chrome contribution to the manifest, listed in
+ * `PACKAGE_WORDINGS` under source `chrome`. `STYLE_MENU_LABEL` and
+ * `TOOL_NAME_TEXT` (this package's own "Style" menu and standalone "Text"
+ * senior tool) are declared once in `chrome.ts` — shared with `gfx/shape` and
+ * `widgets/edgeless-selected-rect` — and imported directly at their call
+ * sites rather than re-declared here.
+ */
+export declare const MINDMAP_CHROME_WORDINGS: readonly ChromeWording[];