@formicoidea/labre-core 0.50.0 → 0.51.0

package/dist/_pkgs/affine-block-attachment/asset-picker.d.ts

@@ -0,0 +1,24 @@
+import { type AssetRef } from '../affine-shared/services/index.js';
+import type { IVec } from '../global/gfx/index.js';
+import type { BlockStdScope } from '../std/index.js';
+import type { BlockModel } from '../store/index.js';
+/**
+ * Adds one attachment card per ref next to `targetModel`, as one undo step.
+ * Nothing is written on a read-only document.
+ */
+export declare function addSiblingAttachmentBlocksFromAssets(std: BlockStdScope, assets: readonly AssetRef[], targetModel: BlockModel, placement?: 'before' | 'after'): string[];
+/**
+ * The canvas counterpart of {@link addSiblingAttachmentBlocksFromAssets}:
+ * places the cards like `addAttachments` does (around `point`, active layer,
+ * selected).
+ */
+export declare function addAttachmentsFromAssets(std: BlockStdScope, assets: readonly AssetRef[], point?: IVec, shouldTransformPoint?: boolean): string[];
+/**
+ * The attachment entries of the slash menu (Attachment, PDF) and of the
+ * mobile keyboard toolbar: the host's asset dialog when there is one, the
+ * system file chooser otherwise (the upload path, unchanged). An emptied
+ * line the gesture was typed on goes away once a card is in.
+ */
+export declare function pickAndAddSiblingAttachmentBlocks(std: BlockStdScope, targetModel: BlockModel): Promise<string[]>;
+/** The canvas's file button: the host's asset dialog, or the file chooser. */
+export declare function pickAndAddAttachments(std: BlockStdScope): Promise<string[]>;

package/dist/_pkgs/affine-block-attachment/asset-picker.js

@@ -0,0 +1,87 @@
+import { AssetPickerProvider, } from '../affine-shared/services/index.js';
+import { openSingleFileWith } from '../affine-shared/utils/index.js';
+import { addAttachments, addSiblingAttachmentBlocks, placeAttachmentsOnCanvas, } from './utils.js';
+/**
+ * Attachments from the host's asset library (`AssetPickerProvider`, labre
+ * P4): the card references a blob the host already stores, by its
+ * `sourceId`, with the ref's name, type and size. Nothing here calls
+ * `BlobSource.set`. Without a host every entry point keeps the system file
+ * chooser and the upload path of `utils.ts`; pasting and dropping never come
+ * here.
+ */
+function attachmentPropsFrom(assets) {
+    return assets.map(({ sourceId, name, type, size }) => ({
+        sourceId,
+        name,
+        type,
+        size,
+    }));
+}
+/**
+ * Adds one attachment card per ref next to `targetModel`, as one undo step.
+ * Nothing is written on a read-only document.
+ */
+export function addSiblingAttachmentBlocksFromAssets(std, assets, targetModel, placement = 'after') {
+    if (!assets.length || std.store.readonly)
+        return [];
+    std.store.captureSync();
+    return std.store.addSiblingBlocks(targetModel, attachmentPropsFrom(assets).map(props => ({
+        ...props,
+        flavour: 'affine:attachment',
+    })), placement);
+}
+/**
+ * The canvas counterpart of {@link addSiblingAttachmentBlocksFromAssets}:
+ * places the cards like `addAttachments` does (around `point`, active layer,
+ * selected).
+ */
+export function addAttachmentsFromAssets(std, assets, point, shouldTransformPoint) {
+    if (!assets.length || std.store.readonly)
+        return [];
+    std.store.captureSync();
+    return placeAttachmentsOnCanvas(std, attachmentPropsFrom(assets), point, shouldTransformPoint);
+}
+function pickFiles(std) {
+    const picker = std.getOptional(AssetPickerProvider);
+    if (!picker)
+        return null;
+    return picker.pick({
+        kind: 'file',
+        mode: 'insert',
+        multiple: false,
+        docId: std.store.id,
+    });
+}
+/**
+ * The attachment entries of the slash menu (Attachment, PDF) and of the
+ * mobile keyboard toolbar: the host's asset dialog when there is one, the
+ * system file chooser otherwise (the upload path, unchanged). An emptied
+ * line the gesture was typed on goes away once a card is in.
+ */
+export async function pickAndAddSiblingAttachmentBlocks(std, targetModel) {
+    const picked = pickFiles(std);
+    let ids;
+    if (picked) {
+        ids = addSiblingAttachmentBlocksFromAssets(std, (await picked) ?? [], targetModel);
+    }
+    else {
+        const file = await openSingleFileWith();
+        if (!file)
+            return [];
+        ids = await addSiblingAttachmentBlocks(std, [file], targetModel);
+    }
+    if (ids.length && targetModel.text?.length === 0) {
+        std.store.deleteBlock(targetModel);
+    }
+    return ids;
+}
+/** The canvas's file button: the host's asset dialog, or the file chooser. */
+export async function pickAndAddAttachments(std) {
+    const picked = pickFiles(std);
+    if (picked)
+        return addAttachmentsFromAssets(std, (await picked) ?? []);
+    const file = await openSingleFileWith();
+    if (!file)
+        return [];
+    return addAttachments(std, [file]);
+}

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

@@ -1,8 +1,7 @@
-import { openSingleFileWith } from '../../affine-shared/utils/index.js';
 import {} from '../../affine-widget-slash-menu/index.js';
 import { ExportToPdfIcon, FileIcon } from '@blocksuite/icons/lit';
+import { pickAndAddSiblingAttachmentBlocks } from '../asset-picker.js';
 import { ATTACHMENT_SLASH_DESCRIPTION, ATTACHMENT_SLASH_NAME, ATTACHMENT_SLASH_PDF_DESCRIPTION, ATTACHMENT_SLASH_PDF_NAME, } from '../translations.js';
-import { addSiblingAttachmentBlocks } from '../utils.js';
 import { AttachmentTooltip, PDFTooltip } from './tooltips.js';
 export const attachmentSlashMenuConfig = {
     items: [
@@ -21,15 +20,7 @@ export const attachmentSlashMenuConfig = {
             group: '4_Content & Media@3',
             when: ({ model }) => model.store.schema.flavourSchemaMap.has('affine:attachment'),
             action: ({ std, model }) => {
-                (async () => {
-                    const file = await openSingleFileWith();
-                    if (!file)
-                        return;
-                    await addSiblingAttachmentBlocks(std, [file], model);
-                    if (model.text?.length === 0) {
-                        std.store.deleteBlock(model);
-                    }
-                })().catch(console.error);
+                pickAndAddSiblingAttachmentBlocks(std, model).catch(console.error);
             },
         },
         {
@@ -46,15 +37,7 @@ export const attachmentSlashMenuConfig = {
             group: '4_Content & Media@4',
             when: ({ model }) => model.store.schema.flavourSchemaMap.has('affine:attachment'),
             action: ({ std, model }) => {
-                (async () => {
-                    const file = await openSingleFileWith();
-                    if (!file)
-                        return;
-                    await addSiblingAttachmentBlocks(std, [file], model);
-                    if (model.text?.length === 0) {
-                        std.store.deleteBlock(model);
-                    }
-                })().catch(console.error);
+                pickAndAddSiblingAttachmentBlocks(std, model).catch(console.error);
             },
         },
     ],

package/dist/_pkgs/affine-block-attachment/index.d.ts

@@ -1,4 +1,5 @@
 export * from './adapters/index.js';
+export { addAttachmentsFromAssets, addSiblingAttachmentBlocksFromAssets, pickAndAddAttachments, pickAndAddSiblingAttachmentBlocks, } from './asset-picker.js';
 export * from './attachment-block.js';
 export * from './attachment-service.js';
 export { attachmentViewDropdownMenu } from './configs/toolbar.js';

package/dist/_pkgs/affine-block-attachment/index.js

@@ -1,4 +1,5 @@
 export * from './adapters/index.js';
+export { addAttachmentsFromAssets, addSiblingAttachmentBlocksFromAssets, pickAndAddAttachments, pickAndAddSiblingAttachmentBlocks, } from './asset-picker.js';
 export * from './attachment-block.js';
 export * from './attachment-service.js';
 export { attachmentViewDropdownMenu } from './configs/toolbar.js';

package/dist/_pkgs/affine-block-attachment/utils.d.ts

@@ -1,4 +1,4 @@
-import { type AttachmentBlockModel } from '../affine-model/index.js';
+import { type AttachmentBlockModel, type AttachmentBlockProps } from '../affine-model/index.js';
 import { type IVec } from '../global/gfx/index.js';
 import type { BlockStdScope } from '../std/index.js';
 import type { BlockModel } from '../store/index.js';
@@ -16,3 +16,11 @@ export declare function getFileType(file: File): Promise<string>;
  */
 export declare function addSiblingAttachmentBlocks(std: BlockStdScope, files: File[], targetModel: BlockModel, placement?: 'before' | 'after', embed?: boolean): Promise<string[]>;
 export declare function addAttachments(std: BlockStdScope, files: File[], point?: IVec, shouldTransformPoint?: boolean): Promise<string[]>;
+export type AttachmentBlockSource = Pick<AttachmentBlockProps, 'name' | 'size' | 'type' | 'sourceId'>;
+/**
+ * Lays attachment cards out on the canvas around `point` (the viewport's
+ * centre without one), in the viewer's active layer, and selects them. Shared
+ * by the files path (`addAttachments`) and the asset path
+ * (`addAttachmentsFromAssets`).
+ */
+export declare function placeAttachmentsOnCanvas(std: BlockStdScope, propsArray: AttachmentBlockSource[], point?: IVec, shouldTransformPoint?: boolean): string[];

package/dist/_pkgs/affine-block-attachment/utils.js

@@ -121,6 +121,15 @@ export async function addAttachments(std, files, point, shouldTransformPoint //
     if (hasExceeded(std, files))
         return [];
     const propsArray = await Promise.all(files.map(file => buildPropsWith(std, file, undefined, 'whiteboard')));
+    return placeAttachmentsOnCanvas(std, propsArray, point, shouldTransformPoint);
+}
+/**
+ * Lays attachment cards out on the canvas around `point` (the viewport's
+ * centre without one), in the viewer's active layer, and selects them. Shared
+ * by the files path (`addAttachments`) and the asset path
+ * (`addAttachmentsFromAssets`).
+ */
+export function placeAttachmentsOnCanvas(std, propsArray, point, shouldTransformPoint) {
     const gfx = std.get(GfxControllerIdentifier);
     let { x, y } = gfx.viewport.center;
     if (point) {

package/dist/_pkgs/affine-block-bookmark/adapters/markdown/markdown.js

@@ -1,14 +1,27 @@
 import { createEmbedBlockMarkdownAdapterMatcher } from '../../../affine-block-embed/index.js';
 import { BookmarkBlockSchema, FootNoteReferenceParamsSchema, } from '../../../affine-model/index.js';
 import { BlockMarkdownAdapterExtension, FOOTNOTE_DEFINITION_PREFIX, getFootnoteDefinitionText, isFootnoteDefinitionNode, } from '../../../affine-shared/adapters/index.js';
+import { isSafeLinkUrl } from '../../../affine-shared/utils/index.js';
 import { nanoid } from '../../../store/index.js';
+const safeDecode = (value) => {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+};
 const isUrlFootnoteDefinitionNode = (node) => {
     if (!isFootnoteDefinitionNode(node))
         return false;
     const footnoteDefinition = getFootnoteDefinitionText(node);
     try {
         const footnoteDefinitionJson = FootNoteReferenceParamsSchema.parse(JSON.parse(footnoteDefinition));
-        return (footnoteDefinitionJson.type === 'url' && !!footnoteDefinitionJson.url);
+        // A refused scheme makes no bookmark: the definition is left to the
+        // reader's default, and no `javascript:` is stored as a bookmark `url`.
+        return (footnoteDefinitionJson.type === 'url' &&
+            !!footnoteDefinitionJson.url &&
+            isSafeLinkUrl(safeDecode(footnoteDefinitionJson.url)));
     }
     catch {
         return false;

package/dist/_pkgs/affine-block-bookmark/adapters/notion-html.js

@@ -1,5 +1,6 @@
 import { BookmarkBlockSchema } from '../../affine-model/index.js';
 import { BlockNotionHtmlAdapterExtension, HastUtils, } from '../../affine-shared/adapters/index.js';
+import { isSafeLinkUrl } from '../../affine-shared/utils/index.js';
 import { nanoid } from '../../store/index.js';
 export const bookmarkBlockNotionHtmlAdapterMatcher = {
     flavour: BookmarkBlockSchema.model.flavour,
@@ -33,7 +34,10 @@ export const bookmarkBlockNotionHtmlAdapterMatcher = {
                 flavour: BookmarkBlockSchema.model.flavour,
                 props: {
                     type: 'card',
-                    url: bookmarkURL ?? '',
+                    // A refused scheme is not stored, as a missing href is not.
+                    url: typeof bookmarkURL === 'string' && isSafeLinkUrl(bookmarkURL)
+                        ? bookmarkURL
+                        : '',
                     title: bookmarkTitle,
                     description: bookmarkDescription,
                     icon: bookmarkIconURL,

package/dist/_pkgs/affine-block-database/adapters/markdown.js

@@ -1,11 +1,13 @@
 import { DatabaseBlockSchema, } from '../../affine-model/index.js';
 import { BlockMarkdownAdapterExtension, } from '../../affine-shared/adapters/index.js';
 import { processTable } from './utils.js';
-const DATABASE_NODE_TYPES = new Set(['table', 'tableRow']);
-const isDatabaseNode = (node) => DATABASE_NODE_TYPES.has(node.type);
 export const databaseBlockMarkdownAdapterMatcher = {
     flavour: DatabaseBlockSchema.model.flavour,
-    toMatch: o => isDatabaseNode(o.node),
+    // A Markdown table is read by the table block only: pasted or imported,
+    // it becomes an inline table, never a database (labre REQ-IM-2). The
+    // database writes tables on export and reads none, like its HTML and
+    // plain-text matchers.
+    toMatch: () => false,
     fromMatch: o => o.node.flavour === DatabaseBlockSchema.model.flavour,
     toBlockSnapshot: {},
     fromBlockSnapshot: {

package/dist/_pkgs/affine-block-embed/common/adapters/html.js

@@ -1,3 +1,4 @@
+import { isSafeLinkUrl } from '../../../affine-shared/utils/index.js';
 export function createEmbedBlockHtmlAdapterMatcher(flavour, { toMatch = () => false, fromMatch = o => o.node.flavour === flavour, toBlockSnapshot = {}, fromBlockSnapshot = {
     enter: (o, context) => {
         const { walkerContext } = context;
@@ -18,9 +19,10 @@ export function createEmbedBlockHtmlAdapterMatcher(flavour, { toMatch = () => fa
             .openNode({
             type: 'element',
             tagName: 'a',
-            properties: {
-                href: o.node.props.url,
-            },
+            // A refused scheme keeps the title and loses the href.
+            properties: isSafeLinkUrl(o.node.props.url)
+                ? { href: o.node.props.url }
+                : {},
             children: [
                 {
                     type: 'text',

package/dist/_pkgs/affine-block-embed/common/adapters/markdown.js

@@ -1,3 +1,4 @@
+import { isSafeLinkUrl } from '../../../affine-shared/utils/index.js';
 export function createEmbedBlockMarkdownAdapterMatcher(flavour, { toMatch = () => false, fromMatch = o => o.node.flavour === flavour, toBlockSnapshot = {}, fromBlockSnapshot = {
     enter: (o, context) => {
         const { walkerContext } = context;
@@ -6,6 +7,16 @@ export function createEmbedBlockMarkdownAdapterMatcher(flavour, { toMatch = () =
             typeof o.node.props.url !== 'string') {
             return;
         }
+        // A url with a refused scheme is not written back out as a link: the
+        // title stays, as text.
+        if (!isSafeLinkUrl(o.node.props.url)) {
+            walkerContext
+                .openNode({ type: 'paragraph', children: [] }, 'children')
+                .openNode({ type: 'text', value: o.node.props.title }, 'children')
+                .closeNode()
+                .closeNode();
+            return;
+        }
         walkerContext
             .openNode({
             type: 'paragraph',

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

@@ -0,0 +1,58 @@
+import { type FrameBlockModel } from '../affine-model/index.js';
+import { type FrameTemplateService } from '../affine-shared/services/index.js';
+import { type BlockStdScope, LifeCycleWatcher } from '../std/index.js';
+import type { DocSnapshot, Store } from '../store/index.js';
+/**
+ * Serialize `frame` and everything it holds as a template snapshot, through
+ * the surface TRANSFORMER: every key of every element's Y.Map crosses as is
+ * (`SurfaceBlockTransformer._elementToJSON`), texts in their snapshot form,
+ * where `element.serialize()` would flatten them to strings. What is changed:
+ *
+ * - `layer` is dropped everywhere (see {@link dropLayer});
+ * - a member connector whose end is not a member gets that end as a free
+ *   position, as a copy-paste does (`serializeConnector`), since the template
+ *   job could not remap the id;
+ * - the frame's `childElementIds` keep only the members that exist.
+ *
+ * Read only: nothing is written to the store. `null` when the document has no
+ * surface or no root.
+ */
+export declare function frameTemplateSnapshot(store: Store, frame: FrameBlockModel): DocSnapshot | null;
+type BlockUpdate = {
+    type: 'add' | 'delete' | 'update';
+    id: string;
+    flavour: string;
+    isLocal: boolean;
+};
+/**
+ * The frame deletion cascade towards the host, pure so a test drives it with
+ * any payload: `frameDeleted` for a frame THIS viewer deleted on a writable
+ * document, `frameRestored` when the same viewer brings it back (an undo
+ * re-adds the block under its own id).
+ *
+ * `if (!local || readonly) return;` — a deletion that arrives from another
+ * peer was reported by that peer, and reporting it again here would make the
+ * host act once per connected viewer.
+ */
+export declare class FrameDeletionCascade {
+    private readonly _store;
+    private readonly _service;
+    private readonly _deleted;
+    constructor(_store: Pick<Store, 'id' | 'readonly'>, _service: FrameTemplateService);
+    handle(payload: BlockUpdate): void;
+}
+/** Mounts {@link FrameDeletionCascade} on the editor's store, if a host keeps templates. */
+export declare class FrameTemplateWatcher extends LifeCycleWatcher {
+    static readonly key = "frame-template-watcher";
+    private _subscription?;
+    mounted(): void;
+    unmounted(): void;
+}
+/**
+ * "Save as template": serialize the frame and hand it to the host. Reads the
+ * document and writes nothing to it, so a read-only viewer may save too: the
+ * host decides where the template goes and whether this viewer may write it.
+ * The viewer always learns the outcome, a rejection included.
+ */
+export declare function saveFrameAsTemplate(std: BlockStdScope, frame: FrameBlockModel): Promise<void>;
+export {};

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

@@ -0,0 +1,207 @@
+import { getSurfaceBlock } from '../affine-block-surface/index.js';
+import { toast } from '../affine-components/toast/index.js';
+import { ConnectorElementModel, } from '../affine-model/index.js';
+import { FrameTemplateProvider, NotificationProvider, translateKey, } from '../affine-shared/services/index.js';
+import { LifeCycleWatcher } from '../std/index.js';
+import { GfxBlockElementModel } from '../std/gfx/index.js';
+import { FRAME_TOAST_TEMPLATE_SAVE_FAILED, FRAME_TOAST_TEMPLATE_SAVED, } from './translations.js';
+/**
+ * Narrow a transformer to one frame's members: the surface keeps only the
+ * elements and child blocks in `ids` — the surface transformer's own
+ * `selectedElements` filter, the same one the drag handle uses
+ * (`widgets/drag-handle/src/middleware/blocks-filter.ts`).
+ */
+function onlyMembers(ids) {
+    return ({ slots, transformerConfigs }) => {
+        const subscription = slots.beforeExport.subscribe(payload => {
+            if (payload.type !== 'block')
+                return;
+            if (payload.model.flavour !== 'affine:surface')
+                return;
+            transformerConfigs.set('selectedElements', ids);
+            payload.model.children = payload.model.children.filter(child => ids.has(child.id));
+        });
+        return () => subscription.unsubscribe();
+    };
+}
+/**
+ * A layer id names a record of the SOURCE surface only. Dropped, so the
+ * template lands in the inserting viewer's active layer wherever it goes
+ * (ADR 0031 §6) — kept, it would land in its old layer when inserted back
+ * into its own document, possibly a hidden one.
+ */
+function dropLayer(props) {
+    delete props['layer'];
+}
+/**
+ * Serialize `frame` and everything it holds as a template snapshot, through
+ * the surface TRANSFORMER: every key of every element's Y.Map crosses as is
+ * (`SurfaceBlockTransformer._elementToJSON`), texts in their snapshot form,
+ * where `element.serialize()` would flatten them to strings. What is changed:
+ *
+ * - `layer` is dropped everywhere (see {@link dropLayer});
+ * - a member connector whose end is not a member gets that end as a free
+ *   position, as a copy-paste does (`serializeConnector`), since the template
+ *   job could not remap the id;
+ * - the frame's `childElementIds` keep only the members that exist.
+ *
+ * Read only: nothing is written to the store. `null` when the document has no
+ * surface or no root.
+ */
+export function frameTemplateSnapshot(store, frame) {
+    const surface = getSurfaceBlock(store);
+    const root = store.root;
+    if (!surface || !root)
+        return null;
+    const members = [frame, ...frame.descendantElements];
+    const ids = new Set(members.map(member => member.id));
+    const job = store.getTransformer([onlyMembers(ids)]);
+    const surfaceSnapshot = job.blockToSnapshot(surface);
+    if (!surfaceSnapshot)
+        return null;
+    const elements = surfaceSnapshot.props['elements'];
+    for (const member of members) {
+        if (!(member instanceof ConnectorElementModel))
+            continue;
+        const json = elements[member.id];
+        if (!json)
+            continue;
+        const path = member.absolutePath;
+        const sourceId = member.source?.id;
+        if (sourceId && !ids.has(sourceId) && path.length) {
+            json['source'] = { position: path[0].slice(0, 2) };
+        }
+        const targetId = member.target?.id;
+        if (targetId && !ids.has(targetId) && path.length) {
+            json['target'] = { position: path[path.length - 1].slice(0, 2) };
+        }
+    }
+    Object.values(elements).forEach(dropLayer);
+    // A note sits under the page, not the surface: serialized on its own.
+    const pageMembers = members
+        .filter(member => member instanceof GfxBlockElementModel &&
+        store.getParent(member.id)?.id === root.id)
+        .map(member => job.blockToSnapshot(member))
+        .filter((snapshot) => !!snapshot);
+    for (const block of [...surfaceSnapshot.children, ...pageMembers]) {
+        dropLayer(block.props);
+        if (block.id === frame.id) {
+            const childIds = (block.props['childElementIds'] ?? {});
+            block.props['childElementIds'] = Object.fromEntries(Object.entries(childIds).filter(([id]) => ids.has(id)));
+        }
+    }
+    const title = frame.props.title.toString();
+    return {
+        type: 'page',
+        meta: { id: store.id, title, createDate: Date.now(), tags: [] },
+        blocks: {
+            type: 'block',
+            id: root.id,
+            flavour: 'affine:page',
+            props: {
+                title: {
+                    '$blocksuite:internal:text$': true,
+                    delta: title ? [{ insert: title }] : [],
+                },
+            },
+            children: [surfaceSnapshot, ...pageMembers],
+        },
+    };
+}
+/**
+ * The frame deletion cascade towards the host, pure so a test drives it with
+ * any payload: `frameDeleted` for a frame THIS viewer deleted on a writable
+ * document, `frameRestored` when the same viewer brings it back (an undo
+ * re-adds the block under its own id).
+ *
+ * `if (!local || readonly) return;` — a deletion that arrives from another
+ * peer was reported by that peer, and reporting it again here would make the
+ * host act once per connected viewer.
+ */
+export class FrameDeletionCascade {
+    constructor(_store, _service) {
+        this._store = _store;
+        this._service = _service;
+        this._deleted = new Set();
+    }
+    handle(payload) {
+        if (payload.flavour !== 'affine:frame')
+            return;
+        if (!payload.isLocal || this._store.readonly)
+            return;
+        const ref = {
+            docId: this._store.id,
+            frameId: payload.id,
+        };
+        if (payload.type === 'delete') {
+            this._deleted.add(payload.id);
+            this._service.frameDeleted?.(ref);
+            return;
+        }
+        if (payload.type === 'add' && this._deleted.delete(payload.id)) {
+            this._service.frameRestored?.(ref);
+        }
+    }
+}
+/** Mounts {@link FrameDeletionCascade} on the editor's store, if a host keeps templates. */
+export class FrameTemplateWatcher extends LifeCycleWatcher {
+    static { this.key = 'frame-template-watcher'; }
+    mounted() {
+        const service = this.std.getOptional(FrameTemplateProvider);
+        if (!service)
+            return;
+        const cascade = new FrameDeletionCascade(this.std.store, service);
+        this._subscription = this.std.store.slots.blockUpdated.subscribe(payload => cascade.handle(payload));
+    }
+    unmounted() {
+        this._subscription?.unsubscribe();
+        this._subscription = undefined;
+    }
+}
+/** Frames whose save is in flight, per document: a double click saves once. */
+const saving = new Set();
+function tell(std, wording, success) {
+    const text = translateKey(std, ...wording);
+    const notification = std.getOptional(NotificationProvider);
+    if (notification) {
+        notification.notify({ title: text, accent: success ? 'success' : 'error' });
+        return;
+    }
+    toast(std.host, text);
+}
+/**
+ * "Save as template": serialize the frame and hand it to the host. Reads the
+ * document and writes nothing to it, so a read-only viewer may save too: the
+ * host decides where the template goes and whether this viewer may write it.
+ * The viewer always learns the outcome, a rejection included.
+ */
+export async function saveFrameAsTemplate(std, frame) {
+    const service = std.getOptional(FrameTemplateProvider);
+    if (!service)
+        return;
+    const key = `${std.store.id}:${frame.id}`;
+    if (saving.has(key))
+        return;
+    const snapshot = frameTemplateSnapshot(std.store, frame);
+    if (!snapshot) {
+        tell(std, FRAME_TOAST_TEMPLATE_SAVE_FAILED, false);
+        return;
+    }
+    saving.add(key);
+    try {
+        await service.save({
+            docId: std.store.id,
+            frameId: frame.id,
+            title: snapshot.meta.title,
+            snapshot,
+        });
+        tell(std, FRAME_TOAST_TEMPLATE_SAVED, true);
+    }
+    catch (error) {
+        console.error(error);
+        tell(std, FRAME_TOAST_TEMPLATE_SAVE_FAILED, false);
+    }
+    finally {
+        saving.delete(key);
+    }
+}

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

@@ -2,16 +2,17 @@ import { EdgelessCRUDIdentifier } from '../affine-block-surface/index.js';
 import { frameworkPaletteGroups, packColor, } from '../affine-components/color-picker/index.js';
 import { toast } from '../affine-components/toast/index.js';
 import { DEFAULT_NOTE_HEIGHT, DefaultTheme, FrameBlockModel, FrameBlockSchema, NoteBlockModel, NoteBlockSchema, NoteDisplayMode, resolveColor, SurfaceRefBlockSchema, } from '../affine-model/index.js';
-import { NotificationProvider, TOAST_FRAME_INSERTED_INTO_PAGE, TOOLBAR_RENAME, ToolbarModuleExtension, translateKey, } from '../affine-shared/services/index.js';
+import { FrameTemplateProvider, NotificationProvider, TOAST_FRAME_INSERTED_INTO_PAGE, TOOLBAR_RENAME, ToolbarModuleExtension, translateKey, } from '../affine-shared/services/index.js';
 import { getMostCommonResolvedValue, matchModels, } from '../affine-shared/utils/index.js';
 import { mountFrameTitleEditor } from '../affine-widget-frame-title/index.js';
 import { Bound } from '../global/gfx/index.js';
-import { EditIcon, InsertIntoPageIcon, UngroupIcon, } from '@blocksuite/icons/lit';
+import { EditIcon, InsertIntoPageIcon, TemplateIcon, UngroupIcon, } from '@blocksuite/icons/lit';
 import { BlockFlavourIdentifier } from '../std/index.js';
 import { GfxControllerIdentifier } from '../std/gfx/index.js';
 import { html } from 'lit';
 import { EdgelessFrameManagerIdentifier } from './frame-manager.js';
-import { FRAME_TOAST_INSERTED_MESSAGE, FRAME_TOOLBAR_BACKGROUND, FRAME_TOOLBAR_INSERT_INTO_PAGE, FRAME_TOOLBAR_UNGROUP, } from './translations.js';
+import { saveFrameAsTemplate } from './frame-template.js';
+import { FRAME_TOAST_INSERTED_MESSAGE, FRAME_TOOLBAR_BACKGROUND, FRAME_TOOLBAR_INSERT_INTO_PAGE, FRAME_TOOLBAR_SAVE_AS_TEMPLATE, FRAME_TOOLBAR_UNGROUP, } from './translations.js';
 function getRootBlock(ctx) {
     const rootModel = ctx.store.root;
     if (!rootModel)
@@ -75,6 +76,21 @@ const builtinSurfaceToolbarConfig = {
                 mountFrameTitleEditor(model, rootBlock);
             },
         },
+        {
+            id: 'b.save-as-template',
+            tooltip: 'Save as template',
+            tooltipWording: FRAME_TOOLBAR_SAVE_AS_TEMPLATE,
+            icon: TemplateIcon(),
+            // No host keeping templates, no button: a save that goes nowhere is a lie.
+            when: ctx => ctx.getSurfaceModelsByType(FrameBlockModel).length === 1 &&
+                !!ctx.std.getOptional(FrameTemplateProvider),
+            run(ctx) {
+                const model = ctx.getCurrentModelByType(FrameBlockModel);
+                if (!model)
+                    return;
+                saveFrameAsTemplate(ctx.std, model).catch(console.error);
+            },
+        },
         {
             id: 'b.ungroup',
             tooltip: 'Ungroup',

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

@@ -6,6 +6,7 @@ export * from './frame-highlight-manager.js';
 export * from './frame-manager.js';
 export * from './frame-order.js';
 export * from './frame-spec.js';
+export * from './frame-template.js';
 export * from './frame-tool.js';
 export * from './frame-toolbar.js';
 export * from './present-tool.js';

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

@@ -6,6 +6,7 @@ export * from './frame-highlight-manager.js';
 export * from './frame-manager.js';
 export * from './frame-order.js';
 export * from './frame-spec.js';
+export * from './frame-template.js';
 export * from './frame-tool.js';
 export * from './frame-toolbar.js';
 export * from './present-tool.js';

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

@@ -34,6 +34,13 @@ export declare const FRAME_TOOLBAR_INSERT_INTO_PAGE: ChromeWording;
  */
 export declare const FRAME_TOAST_INSERTED_MESSAGE: ChromeWording;
 export declare const FRAME_TOOLBAR_UNGROUP: ChromeWording;
+/**
+ * "Save as template" (the `FrameTemplateProvider` seam): the button, then
+ * the notification that says how the host's save went.
+ */
+export declare const FRAME_TOOLBAR_SAVE_AS_TEMPLATE: ChromeWording;
+export declare const FRAME_TOAST_TEMPLATE_SAVED: ChromeWording;
+export declare const FRAME_TOAST_TEMPLATE_SAVE_FAILED: ChromeWording;
 export declare const FRAME_TOOLBAR_BACKGROUND: ChromeWording;
 export declare const FRAME_PRESENT_TOOL_TOOLTIP: ChromeWording;
 export declare const FRAME_PRESENT_PREVIOUS: ChromeWording;