@formicoidea/labre-core 0.45.0 → 0.46.1

package/dist/_pkgs/affine-block-callout/commands/turn-callout-into.d.ts

@@ -0,0 +1,43 @@
+import { CalloutBlockModel } from '../../affine-model/index.js';
+import { type Command } from '../../std/index.js';
+import { type BlockModel, type Store } from '../../store/index.js';
+/**
+ * The selected callouts "Turn into → <text kind>" would unwrap, or none at all.
+ *
+ * Decided BEFORE anything is written, and all-or-nothing: if one callout
+ * cannot be converted, none is (#468). A callout cannot be when its parent
+ * does not accept the target flavour (a code block under a database row),
+ * or when a grandchild could not live under the block its own parent becomes
+ * — and a code block keeps no children at all, so a callout whose content
+ * has nested blocks is not turned into code (the merge would drop them).
+ * Anything that is not a callout is skipped, and a callout nested in another
+ * selected callout moves with it rather than being converted twice.
+ */
+export declare function calloutUnwrapTargets(store: Store, models: BlockModel[], flavour: string): CalloutBlockModel[];
+/**
+ * "Turn into → <text kind>" on a selected callout (#468): the exact inverse of
+ * `turnIntoCalloutCommand`. The callout is a HUB whose own `text` is unused
+ * and whose words live in its children, so the conversion UNWRAPS: each child
+ * becomes a block of the target kind at the callout's place, in order, its
+ * own children moved under it; a target of `affine:code` merges a callout's
+ * children into one code block, the way `mergeToCodeModel` merges a
+ * selection; an empty callout yields one empty block. The callout's emoji is
+ * dropped with it — it belongs to the frame being removed.
+ *
+ * Add first, prove with `getModelById`, delete only after (#418, #423): every
+ * new block is built before anything moves, and if one cannot be, the ones
+ * already built are deleted and every callout stays as it was. Only then are
+ * the grandchildren moved (validated up front by `calloutUnwrapTargets`) and
+ * the callouts deleted. The lifted blocks are therefore NEW blocks carrying
+ * the text, like the paragraph `turnIntoCalloutCommand` creates, while the
+ * grandchildren keep their identity.
+ */
+export declare const turnCalloutIntoCommand: Command<{
+    models: BlockModel[];
+    flavour: string;
+    props?: {
+        type?: string;
+    };
+}, {
+    updatedBlocks: BlockModel[];
+}>;

package/dist/_pkgs/affine-block-callout/commands/turn-callout-into.js

@@ -0,0 +1,109 @@
+import { CalloutBlockModel } from '../../affine-model/index.js';
+import { matchModels } from '../../affine-shared/utils/index.js';
+import { BlockSelection } from '../../std/index.js';
+import { Text } from '../../store/index.js';
+const isAncestor = (store, ancestor, block) => {
+    for (let at = store.getParent(block); at; at = store.getParent(at)) {
+        if (at === ancestor)
+            return true;
+    }
+    return false;
+};
+/**
+ * The selected callouts "Turn into → <text kind>" would unwrap, or none at all.
+ *
+ * Decided BEFORE anything is written, and all-or-nothing: if one callout
+ * cannot be converted, none is (#468). A callout cannot be when its parent
+ * does not accept the target flavour (a code block under a database row),
+ * or when a grandchild could not live under the block its own parent becomes
+ * — and a code block keeps no children at all, so a callout whose content
+ * has nested blocks is not turned into code (the merge would drop them).
+ * Anything that is not a callout is skipped, and a callout nested in another
+ * selected callout moves with it rather than being converted twice.
+ */
+export function calloutUnwrapTargets(store, models, flavour) {
+    const { schema } = store;
+    const callouts = models.filter((model) => matchModels(model, [CalloutBlockModel]));
+    const outermost = callouts.filter(callout => !callouts.some(other => isAncestor(store, other, callout)));
+    const feasible = outermost.every(callout => {
+        const parent = store.getParent(callout);
+        if (!parent || !schema.isValid(flavour, parent.flavour))
+            return false;
+        return callout.children.every(child => flavour === 'affine:code'
+            ? child.children.length === 0
+            : child.children.every(grandchild => schema.isValid(grandchild.flavour, flavour)));
+    });
+    return feasible ? outermost : [];
+}
+/**
+ * "Turn into → <text kind>" on a selected callout (#468): the exact inverse of
+ * `turnIntoCalloutCommand`. The callout is a HUB whose own `text` is unused
+ * and whose words live in its children, so the conversion UNWRAPS: each child
+ * becomes a block of the target kind at the callout's place, in order, its
+ * own children moved under it; a target of `affine:code` merges a callout's
+ * children into one code block, the way `mergeToCodeModel` merges a
+ * selection; an empty callout yields one empty block. The callout's emoji is
+ * dropped with it — it belongs to the frame being removed.
+ *
+ * Add first, prove with `getModelById`, delete only after (#418, #423): every
+ * new block is built before anything moves, and if one cannot be, the ones
+ * already built are deleted and every callout stays as it was. Only then are
+ * the grandchildren moved (validated up front by `calloutUnwrapTargets`) and
+ * the callouts deleted. The lifted blocks are therefore NEW blocks carrying
+ * the text, like the paragraph `turnIntoCalloutCommand` creates, while the
+ * grandchildren keep their identity.
+ */
+export const turnCalloutIntoCommand = (ctx, next) => {
+    const { std, models, flavour, props } = ctx;
+    const store = std.store;
+    if (store.readonly)
+        return;
+    const callouts = calloutUnwrapTargets(store, models, flavour);
+    if (callouts.length === 0)
+        return;
+    store.captureSync();
+    const created = [];
+    const adoptions = [];
+    const add = (callout, text) => {
+        const parent = store.getParent(callout);
+        // Inserted right before the callout, so the blocks keep their order.
+        const block = parent
+            ? store.getModelById(store.addBlock(flavour, { ...props, ...(text && { text }) }, parent, parent.children.indexOf(callout)))
+            : null;
+        if (block)
+            created.push(block);
+        return block;
+    };
+    // `addBlock` returns an id even for a block the store refused, so only
+    // `getModelById` proves the block exists (`add` above).
+    const build = (callout) => {
+        const sources = callout.children;
+        if (flavour === 'affine:code') {
+            const joined = sources
+                .map(source => source.text?.toString())
+                .filter(Boolean)
+                .join('\n');
+            return add(callout, new Text(joined)) !== null;
+        }
+        if (sources.length === 0)
+            return add(callout) !== null;
+        return sources.every(source => {
+            const block = add(callout, source.text?.clone());
+            if (block && source.children.length > 0)
+                adoptions.push([source.children, block]);
+            return block !== null;
+        });
+    };
+    if (!callouts.every(build)) {
+        created.forEach(block => store.deleteBlock(block));
+        return;
+    }
+    adoptions.forEach(([children, block]) => store.moveBlocks(children, block));
+    callouts.forEach(callout => store.deleteBlock(callout));
+    // The gesture started from a block selection (the callout's handle), so it
+    // ends on one; deferred a frame so the new blocks have rendered.
+    requestAnimationFrame(() => {
+        std.selection.setGroup('note', created.map(block => std.selection.create(BlockSelection, { blockId: block.id })));
+    });
+    return next({ updatedBlocks: created });
+};

package/dist/_pkgs/affine-block-callout/commands/turn-into-callout.d.ts

@@ -14,7 +14,7 @@ import type { BlockModel, Store } from '../../store/index.js';
  */
 export declare function calloutConversionTargets(store: Store, models: BlockModel[]): BlockModel[];
 /**
- * Wraps each selected paragraph, list item or code block in a callout (#418).
+ * Turns each selected paragraph, list item or code block into a callout (#418).
  *
  * A callout is a hub with no text of its own, so this cannot be
  * `transformModel`: the callout takes the block's place, a paragraph inside it

package/dist/_pkgs/affine-block-callout/commands/turn-into-callout.js

@@ -37,7 +37,7 @@ export function calloutConversionTargets(store, models) {
     return convertible.filter(model => !convertible.some(other => isAncestor(store, other, model)));
 }
 /**
- * Wraps each selected paragraph, list item or code block in a callout (#418).
+ * Turns each selected paragraph, list item or code block into a callout (#418).
  *
  * A callout is a hub with no text of its own, so this cannot be
  * `transformModel`: the callout takes the block's place, a paragraph inside it

package/dist/_pkgs/affine-block-callout/configs/slash-menu.js

@@ -42,10 +42,12 @@ export const calloutSlashMenuConfig = {
                 if (index === -1)
                     return;
                 const calloutId = store.addBlock('affine:callout', {}, parent, index + 1);
-                if (!calloutId)
+                // `addBlock` returns an id even when the schema refused the block
+                // (`transact` swallows the throw, #418): only the model proves it.
+                if (!store.getModelById(calloutId))
                     return;
                 const paragraphId = store.addBlock('affine:paragraph', {}, calloutId);
-                if (!paragraphId)
+                if (!store.getModelById(paragraphId))
                     return;
                 std.host.updateComplete
                     .then(() => {

package/dist/_pkgs/affine-block-callout/configs/toolbar.d.ts

@@ -0,0 +1,65 @@
+import { ActionPlacement, type ToolbarContext } from '../../affine-shared/services/index.js';
+/**
+ * The callout's block toolbar, opened by its drag handle (#468). Without a
+ * module for `affine:callout` the toolbar widget shows no row for a selected
+ * callout at all, so a callout could not be converted back. Copy, duplicate
+ * and delete are the note row's, restricted to the block selection — except
+ * that they take the selection in `flat` mode, descendants included, where
+ * the note row's Duplicate takes `highest`: a callout is a hub, and drafted
+ * without its children it would copy as an empty frame.
+ *
+ * Centred above the block (`top`) like the note row a paragraph or a code
+ * block opens; without a placement of its own the widget sets a block's row
+ * at `top-start`, which left the callout's row hanging off its left edge.
+ */
+export declare const calloutToolbarConfig: {
+    readonly placement: "top";
+    readonly actions: [{
+        readonly id: "a.conversions";
+        readonly when: (ctx: ToolbarContext) => boolean;
+        readonly content: (ctx: ToolbarContext) => import("lit-html").TemplateResult<1> | null;
+    }, {
+        readonly variant?: "destructive";
+        readonly content?: ((cx: ToolbarContext) => import("lit-html").TemplateResult | null) | (import("lit-html").TemplateResult | null);
+        readonly label?: string;
+        readonly icon?: import("lit-html").TemplateResult;
+        readonly active?: ((cx: ToolbarContext) => boolean) | boolean;
+        readonly disabled?: ((cx: ToolbarContext) => boolean) | boolean;
+        readonly placement?: ActionPlacement;
+        readonly tooltip?: string | import("lit-html").TemplateResult;
+        readonly score?: number;
+        readonly when?: ((cx: ToolbarContext) => boolean) | boolean;
+        readonly priority?: number;
+        readonly labelWording?: import("../../affine-shared/services/index.js").ChromeWording;
+        readonly showLabel?: boolean;
+        readonly tooltipWording?: import("../../affine-shared/services/index.js").ChromeWording;
+        readonly run?: (cx: ToolbarContext) => void;
+        readonly id: "g.comment";
+    }, {
+        readonly placement: ActionPlacement.More;
+        readonly id: "a.clipboard";
+        readonly actions: [{
+            readonly id: "copy";
+            readonly labelWording: import("../../affine-shared/services/index.js").ChromeWording;
+            readonly icon: import("lit-html").TemplateResult<1>;
+            readonly run: ({ chain, host, std }: ToolbarContext) => void;
+        }, {
+            readonly id: "duplicate";
+            readonly labelWording: import("../../affine-shared/services/index.js").ChromeWording;
+            readonly icon: import("lit-html").TemplateResult<1>;
+            readonly run: (ctx: ToolbarContext) => void;
+        }];
+        readonly when: (ctx: ToolbarContext) => boolean;
+    }, {
+        readonly placement: ActionPlacement.More;
+        readonly id: "c.delete";
+        readonly actions: [{
+            readonly id: "delete";
+            readonly labelWording: import("../../affine-shared/services/index.js").ChromeWording;
+            readonly icon: import("lit-html").TemplateResult<1>;
+            readonly variant: "destructive";
+            readonly run: ({ chain }: ToolbarContext) => void;
+        }];
+        readonly when: (ctx: ToolbarContext) => boolean;
+    }];
+};

package/dist/_pkgs/affine-block-callout/configs/toolbar.js

@@ -0,0 +1,178 @@
+import { toast } from '../../affine-components/toast/index.js';
+import { EditorChevronDown } from '../../affine-components/toolbar/index.js';
+import { CalloutBlockModel } from '../../affine-model/index.js';
+import { textConversionConfigs } from '../../affine-rich-text/index.js';
+import { copySelectedModelsCommand, deleteSelectedModelsCommand, draftSelectedModelsCommand, duplicateSelectedModelsCommand, getSelectedModelsCommand, } from '../../affine-shared/commands/index.js';
+import { ActionPlacement, blockCommentToolbarButton, TOAST_COPIED_TO_CLIPBOARD, TOOLBAR_CONVERSIONS_ARIA, TOOLBAR_COPY, TOOLBAR_DELETE, TOOLBAR_DUPLICATE, TOOLBAR_TURN_INTO, translateKey, } from '../../affine-shared/services/index.js';
+import { matchModels } from '../../affine-shared/utils/index.js';
+import { CopyIcon, DeleteIcon, DuplicateIcon, FontIcon, } from '@blocksuite/icons/lit';
+import { html } from 'lit';
+import { repeat } from 'lit/directives/repeat.js';
+import { calloutUnwrapTargets, turnCalloutIntoCommand, } from '../commands/turn-callout-into.js';
+/** The block-selected callouts — the row only opens on a block selection. */
+const selectedCallouts = ({ chain }) => {
+    const [ok, { selectedModels = [] }] = chain
+        .pipe(getSelectedModelsCommand, { types: ['block'], mode: 'highest' })
+        .run();
+    return ok
+        ? selectedModels.filter(model => matchModels(model, [CalloutBlockModel]))
+        : [];
+};
+/**
+ * "Turn into" on a callout (#468): the text kinds of the note's own row, minus
+ * the divider (which is not a conversion of a block's words), each offered
+ * only when `calloutUnwrapTargets` says the whole conversion can complete —
+ * a refusal is an absent entry, never a click that does nothing.
+ *
+ * Like the note row, which offers "Turn into" on a paragraph or a code block
+ * only once it holds words (`isFormatSupported`), the entry waits for the
+ * callout to hold some: an empty callout shows the "⋮" menu alone (PO
+ * recette of #468, for one behaviour across blocks).
+ */
+const conversionsAction = {
+    id: 'a.conversions',
+    when: ctx => !ctx.readonly,
+    content(ctx) {
+        const { std, store } = ctx;
+        const callouts = selectedCallouts(ctx);
+        if (callouts.length === 0)
+            return null;
+        const holdsWords = callouts.some(callout => callout.children.some(child => (child.text?.length ?? 0) > 0));
+        if (!holdsWords)
+            return null;
+        const conversions = textConversionConfigs.filter(({ flavour }) => flavour !== 'affine:divider' &&
+            calloutUnwrapTargets(store, callouts, flavour).length > 0);
+        if (conversions.length === 0)
+            return null;
+        return html `
+      <editor-menu-button
+        .contentPadding="${'8px'}"
+        .button=${html `
+          <editor-icon-button
+            aria-label="${translateKey(std, ...TOOLBAR_CONVERSIONS_ARIA)}"
+            .tooltip="${translateKey(std, ...TOOLBAR_TURN_INTO)}"
+          >
+            ${FontIcon()} ${EditorChevronDown}
+          </editor-icon-button>
+        `}
+      >
+        <div data-size="large" data-orientation="vertical">
+          ${repeat(conversions, item => item.name, ({ flavour, type, name, nameWording, icon }) => {
+            const label = nameWording
+                ? translateKey(std, ...nameWording)
+                : name;
+            return html `
+                <editor-menu-action
+                  aria-label=${label}
+                  @click=${() => std.command.exec(turnCalloutIntoCommand, {
+                models: callouts,
+                flavour,
+                ...(type && { props: { type } }),
+            })}
+                >
+                  ${icon}<span class="label">${label}</span>
+                </editor-menu-action>
+              `;
+        })}
+        </div>
+      </editor-menu-button>
+    `;
+    },
+};
+/**
+ * The callout's block toolbar, opened by its drag handle (#468). Without a
+ * module for `affine:callout` the toolbar widget shows no row for a selected
+ * callout at all, so a callout could not be converted back. Copy, duplicate
+ * and delete are the note row's, restricted to the block selection — except
+ * that they take the selection in `flat` mode, descendants included, where
+ * the note row's Duplicate takes `highest`: a callout is a hub, and drafted
+ * without its children it would copy as an empty frame.
+ *
+ * Centred above the block (`top`) like the note row a paragraph or a code
+ * block opens; without a placement of its own the widget sets a block's row
+ * at `top-start`, which left the callout's row hanging off its left edge.
+ */
+export const calloutToolbarConfig = {
+    placement: 'top',
+    actions: [
+        conversionsAction,
+        {
+            id: 'g.comment',
+            ...blockCommentToolbarButton,
+        },
+        {
+            placement: ActionPlacement.More,
+            id: 'a.clipboard',
+            actions: [
+                {
+                    id: 'copy',
+                    labelWording: TOOLBAR_COPY,
+                    icon: CopyIcon(),
+                    run({ chain, host, std }) {
+                        // `flat`, not `highest`: the callout's words are its children,
+                        // and the draft keeps only the children that are selected too.
+                        const [ok] = chain
+                            .pipe(getSelectedModelsCommand, {
+                            types: ['block'],
+                            mode: 'flat',
+                        })
+                            .pipe(draftSelectedModelsCommand)
+                            .pipe(copySelectedModelsCommand)
+                            .run();
+                        if (!ok)
+                            return;
+                        toast(host, translateKey(std, ...TOAST_COPIED_TO_CLIPBOARD));
+                    },
+                },
+                {
+                    id: 'duplicate',
+                    labelWording: TOOLBAR_DUPLICATE,
+                    icon: DuplicateIcon(),
+                    run(ctx) {
+                        const { chain, store } = ctx;
+                        // The copy lands right after the (last) callout. Said explicitly:
+                        // the command's default anchors on the LAST selected model, which
+                        // in `flat` mode is one of the callout's descendants.
+                        const last = selectedCallouts(ctx).at(-1);
+                        const parentModel = last && store.getParent(last);
+                        if (!last || !parentModel)
+                            return;
+                        store.captureSync();
+                        // `flat`, not `highest`, for the same reason as Copy: a callout
+                        // drafted without its children duplicates as an empty frame.
+                        chain
+                            .pipe(getSelectedModelsCommand, {
+                            types: ['block'],
+                            mode: 'flat',
+                        })
+                            .pipe(duplicateSelectedModelsCommand, {
+                            parentModel,
+                            index: parentModel.children.indexOf(last) + 1,
+                        })
+                            .run();
+                    },
+                },
+            ],
+            when: ctx => !ctx.flags.isNative(),
+        },
+        {
+            placement: ActionPlacement.More,
+            id: 'c.delete',
+            actions: [
+                {
+                    id: 'delete',
+                    labelWording: TOOLBAR_DELETE,
+                    icon: DeleteIcon(),
+                    variant: 'destructive',
+                    run({ chain }) {
+                        chain
+                            .pipe(getSelectedModelsCommand, { types: ['block'] })
+                            .pipe(deleteSelectedModelsCommand)
+                            .run();
+                    },
+                },
+            ],
+            when: ctx => !ctx.flags.isNative(),
+        },
+    ],
+};

package/dist/_pkgs/affine-block-callout/view.d.ts

@@ -1,6 +1,35 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '../affine-ext-loader/index.js';
-export declare class CalloutViewExtension extends ViewExtensionProvider {
+/**
+ * Callout rendering — ALWAYS registered, independent of the `callout` flag
+ * (ADR 0009, #418). A document that already holds callouts must paint them,
+ * let them be edited and let them be turned back into text whatever the flag
+ * says: until 2026-10-11 the whole view sat behind the flag, and
+ * `{ callout: false }` left every stored callout rendered as nothing.
+ *
+ * What lives here is what an EXISTING callout needs, the mirror of
+ * `WardleyRenderViewExtension`:
+ * - `effects()` whole: `affine-callout` paints the block, and
+ *   `affine-emoji-menu` opens from a rendered callout's icon — both are
+ *   render-side, so unlike the frameworks' this `effects()` is not tooling;
+ * - the flavour and the block view, the lookup `lit-host` performs;
+ * - the keymap: Enter and Backspace inside a callout edit stored content, they
+ *   create nothing;
+ * - the block toolbar (#468): Turn into text, copy, duplicate, delete — the
+ *   way OUT of a stored callout, as the Wardley contextual toolbar stays with
+ *   a stored map.
+ */
+export declare class CalloutRenderViewExtension extends ViewExtensionProvider {
     name: string;
     effect(): void;
     setup(context: ViewExtensionContext): void;
 }
+/**
+ * Callout creation tooling — flag-gated (`callout`, ADR 0009): the slash-menu
+ * item and the "Turn into → Callout" entry, the two ways to CREATE a callout.
+ * With the flag off no new callout can be made; the ones already written keep
+ * rendering through {@link CalloutRenderViewExtension}.
+ */
+export declare class CalloutViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}

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

@@ -1,16 +1,37 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { TextConversionEntryExtension } from '../affine-rich-text/index.js';
+import { ToolbarModuleExtension } from '../affine-shared/services/index.js';
 import { SlashMenuConfigExtension } from '../affine-widget-slash-menu/index.js';
-import { BlockViewExtension, FlavourExtension } from '../std/index.js';
+import { BlockFlavourIdentifier, BlockViewExtension, FlavourExtension, } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { CalloutKeymapExtension } from './callout-keymap.js';
 import { calloutSlashMenuConfig } from './configs/slash-menu.js';
+import { calloutToolbarConfig } from './configs/toolbar.js';
 import { calloutTurnIntoEntry } from './configs/turn-into.js';
 import { effects } from './effects.js';
-export class CalloutViewExtension extends ViewExtensionProvider {
+/**
+ * Callout rendering — ALWAYS registered, independent of the `callout` flag
+ * (ADR 0009, #418). A document that already holds callouts must paint them,
+ * let them be edited and let them be turned back into text whatever the flag
+ * says: until 2026-10-11 the whole view sat behind the flag, and
+ * `{ callout: false }` left every stored callout rendered as nothing.
+ *
+ * What lives here is what an EXISTING callout needs, the mirror of
+ * `WardleyRenderViewExtension`:
+ * - `effects()` whole: `affine-callout` paints the block, and
+ *   `affine-emoji-menu` opens from a rendered callout's icon — both are
+ *   render-side, so unlike the frameworks' this `effects()` is not tooling;
+ * - the flavour and the block view, the lookup `lit-host` performs;
+ * - the keymap: Enter and Backspace inside a callout edit stored content, they
+ *   create nothing;
+ * - the block toolbar (#468): Turn into text, copy, duplicate, delete — the
+ *   way OUT of a stored callout, as the Wardley contextual toolbar stays with
+ *   a stored map.
+ */
+export class CalloutRenderViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
-        this.name = 'affine-callout-block';
+        this.name = 'affine-callout-render-block';
     }
     effect() {
         super.effect();
@@ -22,6 +43,27 @@ export class CalloutViewExtension extends ViewExtensionProvider {
             FlavourExtension('affine:callout'),
             BlockViewExtension('affine:callout', literal `affine-callout`),
             CalloutKeymapExtension,
+            ToolbarModuleExtension({
+                id: BlockFlavourIdentifier('affine:callout'),
+                config: calloutToolbarConfig,
+            }),
+        ]);
+    }
+}
+/**
+ * Callout creation tooling — flag-gated (`callout`, ADR 0009): the slash-menu
+ * item and the "Turn into → Callout" entry, the two ways to CREATE a callout.
+ * With the flag off no new callout can be made; the ones already written keep
+ * rendering through {@link CalloutRenderViewExtension}.
+ */
+export class CalloutViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-callout-block';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register([
             SlashMenuConfigExtension('affine:callout', calloutSlashMenuConfig),
             TextConversionEntryExtension(calloutTurnIntoEntry),
         ]);

package/dist/_pkgs/affine-block-code/code-toolbar/components/lang-button.js

@@ -118,7 +118,7 @@ let LanguageListButton = (() => {
             const plainText = {
                 label: translateKey(this.blockComponent.std, ...CODE_PLAIN_TEXT_LANGUAGE),
                 name: PLAIN_TEXT_ITEM_NAME,
-                aliases: ['plain', 'text', 'none'],
+                aliases: ['plain', 'text', 'plaintext', 'txt', 'none'],
             };
             const index = languages.findIndex(item => item.name === PLAIN_TEXT_ITEM_NAME);
             if (index === -1) {

package/dist/_pkgs/affine-block-frame/commands.d.ts

@@ -0,0 +1,27 @@
+import type { AnyCommandDescriptor } from '../std/index.js';
+import { z } from 'zod';
+/**
+ * The frames' commands, `owner: 'core'`: a frame belongs to no framework, and
+ * `'core'` owners are exempt from the id-prefix rule (ADR 0008).
+ *
+ * They live here and not beside the selection pane's: `blocks/surface` cannot
+ * import `blocks/frame` (the dependency runs the other way), and the action
+ * reads the frame manager's presentation order.
+ */
+export declare const reorderFramesParams: z.ZodObject<{
+    /** The frames to move, as one block, keeping their relative order. */
+    ids: z.ZodArray<z.ZodString, "many">;
+    /**
+     * The frame they land directly BEFORE in the presentation order; `null`
+     * puts them at the end.
+     */
+    before: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    before: string | null;
+    ids: string[];
+}, {
+    before: string | null;
+    ids: string[];
+}>;
+export type ReorderFramesParams = z.infer<typeof reorderFramesParams>;
+export declare const frameCommands: AnyCommandDescriptor[];

package/dist/_pkgs/affine-block-frame/commands.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { reorderFramePresentation } from './frame-order.js';
+/**
+ * The frames' commands, `owner: 'core'`: a frame belongs to no framework, and
+ * `'core'` owners are exempt from the id-prefix rule (ADR 0008).
+ *
+ * They live here and not beside the selection pane's: `blocks/surface` cannot
+ * import `blocks/frame` (the dependency runs the other way), and the action
+ * reads the frame manager's presentation order.
+ */
+export const reorderFramesParams = z.object({
+    /** The frames to move, as one block, keeping their relative order. */
+    ids: z.array(z.string().min(1)).min(1),
+    /**
+     * The frame they land directly BEFORE in the presentation order; `null`
+     * puts them at the end.
+     */
+    before: z.string().min(1).nullable(),
+});
+/**
+ * Reorder the presentation (ADR 0034). The frame panel's drag, the
+ * presentation toolbar's order menu and a host's own slide panel all run it
+ * through `runCommand`, so the read-only refusal, the no-op check and the one
+ * undo step live in the action, once.
+ */
+const reorderFrames = {
+    id: 'canvas.frame.reorder',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.frame.reorder',
+    labelFallback: 'Reorder frames',
+    descriptionKey: 'com.labre.command.canvas.frame.reorder.description',
+    descriptionFallback: 'Move frames before another frame in the presentation order, or to its end.',
+    // Agent only: without an explicit target there is nothing to say where.
+    surfaces: ['agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'editable',
+    params: reorderFramesParams,
+    run: (std, _invocation, params) => {
+        const parsed = reorderFramesParams.safeParse(params);
+        if (!parsed.success) {
+            console.error('canvas.frame.reorder: invalid params', parsed.error);
+            return;
+        }
+        reorderFramePresentation(std, parsed.data.ids, parsed.data.before);
+    },
+};
+export const frameCommands = [reorderFrames];