@formicoidea/labre-core 1.0.0 → 1.1.0

package/dist/_pkgs/affine-database-block/view-deletion.js

@@ -0,0 +1,113 @@
+/**
+ * A host decides what a deleted view takes with it (ADR 0035 amendment of
+ * 2026-10-29). Labre sends a source to its trash with the last view reading
+ * it, and must confirm that BEFORE the view goes, then restore it when the
+ * removal is undone. So the delete gesture of a view of a host database
+ * becomes a request (`DataSourcePickerService.deleteView`) whose `remove()`
+ * is the 1.0 removal, and the undo step it makes is tagged so an undo or a
+ * redo of it reaches `viewHistory`.
+ *
+ * The tag rides in the undo step's `meta`. Yjs builds a NEW step for the
+ * opposite stack while it pops one ('stack-item-added' with the undo manager
+ * as origin, fired inside the pop's transaction, before 'stack-item-popped'),
+ * so the tag is carried over to that step, and an undo, redo, undo… chain
+ * keeps reporting. Remote updates never pop a step: they report nothing.
+ */
+const VIEW_REMOVED = 'labre:database-view-removed';
+// One listener pair per undo manager, whatever the number of blocks: the
+// step outlives the block's data source (a block remounted after a mode
+// switch, or unmounted, still has its removals undone).
+const watches = new WeakMap();
+function isViewRef(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const ref = value;
+    return (typeof ref.databaseId === 'string' &&
+        typeof ref.viewId === 'string' &&
+        typeof ref.docId === 'string' &&
+        typeof ref.blockId === 'string');
+}
+function watchHistory(undoManager, picker) {
+    const known = watches.get(undoManager);
+    if (known) {
+        known.picker = picker;
+        return;
+    }
+    const watch = { picker };
+    watches.set(undoManager, watch);
+    let replay = null;
+    undoManager.on('stack-item-added', event => {
+        if (event.origin === undoManager)
+            replay = event.stackItem;
+    });
+    undoManager.on('stack-item-popped', event => {
+        const opposite = replay;
+        replay = null;
+        const ref = event.stackItem.meta.get(VIEW_REMOVED);
+        if (!isViewRef(ref))
+            return;
+        opposite?.meta.set(VIEW_REMOVED, ref);
+        try {
+            watch.picker.viewHistory?.(ref, event.type);
+        }
+        catch (error) {
+            // A host failure must not break the undo itself.
+            console.error(error);
+        }
+    });
+}
+/**
+ * Deletes view `viewId` of `model`, through the host's `deleteView` when it
+ * has one and the block shows one of its databases; at once otherwise.
+ * `removeNow` is the 1.0 removal (one undo step); `afterRemove` runs after a
+ * removal the host asked for (the view to show next).
+ */
+export function deleteViewThroughHost(options) {
+    const { model, viewId, picker, removeNow, afterRemove } = options;
+    const store = model.store;
+    const databaseId = model.props.externalSourceId;
+    const deleteView = picker?.deleteView;
+    if (!picker || !deleteView || !databaseId || store.readonly) {
+        removeNow();
+        return;
+    }
+    const view = model.props.views.find(v => v.id === viewId);
+    if (!view)
+        return;
+    const ref = {
+        databaseId,
+        viewId,
+        docId: store.id,
+        blockId: model.id,
+        ...(view.sourceId === undefined ? {} : { sourceId: view.sourceId }),
+    };
+    let used = false;
+    const request = {
+        ...ref,
+        viewName: typeof view.name === 'string' ? view.name : '',
+        remove: () => {
+            if (used || store.readonly)
+                return false;
+            if (!model.props.views.some(v => v.id === viewId))
+                return false;
+            used = true;
+            const undoManager = store.history.undoManager;
+            watchHistory(undoManager, picker);
+            let added = null;
+            const grab = (event) => {
+                added = event.stackItem;
+            };
+            undoManager.on('stack-item-added', grab);
+            try {
+                removeNow();
+            }
+            finally {
+                undoManager.off('stack-item-added', grab);
+            }
+            added?.meta.set(VIEW_REMOVED, ref);
+            afterRemove();
+            return true;
+        },
+    };
+    deleteView.call(picker, request);
+}

package/dist/_pkgs/affine-shared/services/data-source-picker-service.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionType } from '../../store/index.js';
+import type { BlockSnapshot, DeltaInsert, ExtensionType } from '../../store/index.js';
 import type { ReadonlySignal } from '@preact/signals-core';
 /** One source of a host database, as the picker lists it. */
 export interface DataSourcePickerSource {
@@ -83,6 +83,62 @@ export interface DataSourcePickerViewTemplate {
     view: Readonly<Record<string, unknown>>;
     properties: readonly DataSourcePickerProperty[];
 }
+/** One row of a table turned into a source (`createDatabaseFrom`). */
+export interface DataSourcePickerRow {
+    /**
+     * The row's title as a rich-text delta: links, mentions (`reference`),
+     * bold… Keep what your title property allows.
+     */
+    title: readonly DeltaInsert[];
+    /**
+     * Property id (of `DataSourcePickerContent.properties`) → the value as the
+     * library stores it: a number, a boolean, a date's epoch milliseconds, a
+     * select's option id (or ids), a rich text as a delta. A property left
+     * out has no value.
+     */
+    values: Readonly<Record<string, unknown>>;
+    /** The row's nested blocks, for its page body; empty when it has none. */
+    body: readonly BlockSnapshot[];
+}
+/** What `createDatabaseFrom` turns into a database. */
+export interface DataSourcePickerContent {
+    /** The database's name: the table's title, or empty for you to name it. */
+    title: string;
+    /**
+     * Its properties in order, the title first (type `title`). Their types are
+     * the library's (`title`, `rich-text`, `number`, `select`,
+     * `multi-select`, `checkbox`, `date`, `link`, `progress`…): map each to
+     * one of yours, or drop it.
+     */
+    properties: readonly DataSourcePickerProperty[];
+    /** The rows, in order. */
+    rows: readonly DataSourcePickerRow[];
+}
+/**
+ * A view of a host database, where it is stored (ADR 0035 amendment of
+ * 2026-10-29, "a host decides what a deleted view takes with it").
+ */
+export interface DataSourcePickerViewRef {
+    /** The block's `externalSourceId`, as `list()` names the database. */
+    databaseId: string;
+    /** The view's stored `sourceId`; absent, the host's implicit source. */
+    sourceId?: string;
+    viewId: string;
+    /** The document (store id) and the `affine:database` block holding it. */
+    docId: string;
+    blockId: string;
+}
+/** What `deleteView` hands the host: the view, and the verb that removes it. */
+export interface DataSourcePickerViewDeletion extends DataSourcePickerViewRef {
+    /** The view's name, as stored ('' when it has none). */
+    viewName: string;
+    /**
+     * Remove the view from its block, as one undo step, and show the next
+     * one. `false` when nothing was removed: the page turned read-only, the
+     * view is already gone, or `remove` was already called.
+     */
+    remove(): boolean;
+}
 /**
  * The data-source picker (ADR 0035 §9c, issue B12): the host lists the
  * databases and sources a view may read, and creates them. The library draws
@@ -107,6 +163,33 @@ export interface DataSourcePickerService {
      * leave the menu.
      */
     createDatabase?(): Promise<DataSourcePickerDatabase | null>;
+    /**
+     * No native table beside your databases (ADR 0035 amendment of
+     * 2026-10-29). The source decides, never the row count: a database block
+     * with no source (`externalSourceId`) and no row, or whose source you no
+     * longer resolve, draws an empty view with "Connect a source" (it
+     * reopens the creation popover); one with no source but native rows shows
+     * them read-only; a connected one with no row is an ordinary table.
+     * Closing the popover writes nothing. Absent or `false`: as in 1.0.
+     */
+    requireSource?: boolean;
+    /**
+     * Create a database holding `content` and resolve to it, with at least one
+     * source, or `null` when nothing was created (ADR 0035 amendment of
+     * 2026-10-29, "turn into a source"). One call, so the rows land together
+     * or not at all. With `requireSource`, "Create Table" on selected
+     * paragraphs and "Move into a database" on a database with native rows
+     * call it, then connect the block to the database's first source in one
+     * undo step; an undo leaves your database in place. Absent, both are
+     * hidden when a source is required.
+     */
+    createDatabaseFrom?(content: DataSourcePickerContent): Promise<DataSourcePickerDatabase | null>;
+    /**
+     * With `createDatabaseFrom`: you keep a row's nested blocks as its page
+     * body (`DataSourcePickerRow.body`). Absent, a conversion whose rows have
+     * nested blocks is refused with a notice and writes nothing.
+     */
+    rowBodies?: boolean;
     /**
      * Create a source in `databaseId`; it resolves to the new source, or
      * `null`. Absent, the picker offers no "New source".
@@ -126,6 +209,21 @@ export interface DataSourcePickerService {
      * offer it. Resolves `true` once saved. Absent, no "Save as template".
      */
     saveViewTemplate?(template: DataSourcePickerViewTemplate): Promise<boolean>;
+    /**
+     * A reader asked to delete a view of one of your databases (a block with
+     * an `externalSourceId`, on a writable document): decide what goes with
+     * it, ask what you must, then call `request.remove()`; not calling it
+     * keeps the view. Called once per gesture ("Delete" in the view's tab
+     * menu or its settings), never for a deleted block, an undo, a redo or a
+     * remote change. Absent, the view is removed at once, as in 1.0.
+     */
+    deleteView?(request: DataSourcePickerViewDeletion): void;
+    /**
+     * An undo (`'undo'`: the view is back) or a redo (`'redo'`: it is gone
+     * again) of a removal made by `request.remove()`, on this client. Never
+     * for a remote change. Nothing to confirm: it already happened.
+     */
+    viewHistory?(view: DataSourcePickerViewRef, step: 'undo' | 'redo'): void;
 }
 export declare const DataSourcePickerProvider: import("../../global/di/types.js").ServiceIdentifier<DataSourcePickerService> & (<U extends DataSourcePickerService = DataSourcePickerService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
 /**

package/dist/_pkgs/affine-widget-keyboard-toolbar/config.js

@@ -1,5 +1,5 @@
 import { pickAndAddSiblingAttachmentBlocks } from '../affine-block-attachment/index.js';
-import { insertDatabaseBlockCommand } from '../affine-database-block/index.js';
+import { canCreateDatabase, createDatabaseByGesture, } from '../affine-database-block/index.js';
 import { insertEmptyEmbedIframeCommand } from '../affine-block-embed/index.js';
 import { insertImagesCommand } from '../affine-block-image/index.js';
 import { insertLatexBlockCommand } from '../affine-block-latex/index.js';
@@ -500,33 +500,22 @@ const databaseToolGroup = {
         {
             name: 'Table view',
             icon: DatabaseTableViewIcon(),
-            showWhen: ({ std }) => std.store.schema.flavourSchemaMap.has('affine:database'),
+            showWhen: ({ std }) => std.store.schema.flavourSchemaMap.has('affine:database') &&
+                canCreateDatabase(std),
+            // The slash entries' gesture (ADR 0035 amendment of 2026-10-29): with
+            // a host picker, the popover over a rowless database, never 3 native
+            // rows the host would not see.
             action: ({ std }) => {
-                std.command
-                    .chain()
-                    .pipe(getSelectedModelsCommand)
-                    .pipe(insertDatabaseBlockCommand, {
-                    viewType: viewPresets.tableViewMeta.type,
-                    place: 'after',
-                    removeEmptyLine: true,
-                })
-                    .run();
+                createDatabaseByGesture(std, viewPresets.tableViewMeta.type);
             },
         },
         {
             name: 'Kanban view',
             icon: DatabaseKanbanViewIcon(),
-            showWhen: ({ std }) => std.store.schema.flavourSchemaMap.has('affine:database'),
+            showWhen: ({ std }) => std.store.schema.flavourSchemaMap.has('affine:database') &&
+                canCreateDatabase(std),
             action: ({ std }) => {
-                std.command
-                    .chain()
-                    .pipe(getSelectedModelsCommand)
-                    .pipe(insertDatabaseBlockCommand, {
-                    viewType: viewPresets.kanbanViewMeta.type,
-                    place: 'after',
-                    removeEmptyLine: true,
-                })
-                    .run();
+                createDatabaseByGesture(std, viewPresets.kanbanViewMeta.type);
             },
         },
     ],

package/package.json

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