@formicoidea/labre-core 0.48.0 → 0.49.0

package/dist/_pkgs/affine-block-database/database-block.d.ts

@@ -9,14 +9,29 @@ export declare class DatabaseBlockComponent extends CaptionedBlockComponent<Data
     private _dataSource?;
     private _dataViewRootLogic?;
     private _sourceVersion;
+    /**
+     * Every database event leaves here, with the block's id and nothing about
+     * its rows (telemetry README, "Databases"): the root's `eventTrace`, and
+     * the source's `DataViewEventTraceKey` for code that holds only a view.
+     */
+    private readonly traceDatabaseEvent;
     private _buildDataSource;
     get dataSource(): DataSourceBase;
     private rebuildDataSource;
+    /**
+     * A row that is a document opens where the host says, in the view's
+     * `openIn` mode (ADR 0035 §9a, B9); without an opener, or for a row that is
+     * a block, the caller keeps the peek view and the side detail of 0.48.
+     * Every row open passes here once, so `DatabaseRowOpened` leaves from here
+     * (B17), whichever path then opens the row.
+     */
+    private openRowThroughHost;
     private readonly renderTitle;
     createTemplate: (data: {
         view: SingleView;
         rowId: string;
     }, openDoc: (docId: string) => void) => import("lit-html").TemplateResult;
+    private renderViewBar;
     headerWidget: DataViewWidget;
     indicator: DropIndicator;
     onDrag: (evt: MouseEvent, id: string) => (() => void);
@@ -27,10 +42,18 @@ export declare class DatabaseBlockComponent extends CaptionedBlockComponent<Data
     get optionsConfig(): DatabaseViewExtensionOptions;
     get isCommentHighlighted(): boolean;
     get topContenteditableElement(): BlockComponent<import("../store/index.js").BlockModel<object>, import("../std/index.js").BlockService, string> | null;
+    private readonly renderSourceMissing;
     private renderDatabaseOps;
     connectedCallback(): void;
     disconnectedCallback(): void;
     listenFullWidthChange(): void;
+    /**
+     * Puts the caret on the current view's first cell, where the view has one
+     * (table, kanban; the other presets ignore it): what the page title's
+     * Enter and ArrowDown reach when this block is the page's body
+     * (`<doc-title .bodyBlockId>`, a database's full page, ADR 0035 B13).
+     */
+    focusFirstCell(): void;
     private get dataViewRootLogic();
     private _buildDataViewRootLogic;
     renderBlock(): import("lit-html").TemplateResult<1>;

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

@@ -4,9 +4,9 @@ import { DropIndicator } from '../affine-components/drop-indicator/index.js';
 import { PeekViewProvider } from '../affine-components/peek/index.js';
 import { toast } from '../affine-components/toast/index.js';
 import { EDGELESS_TOP_CONTENTEDITABLE_SELECTOR } from '../affine-shared/consts/index.js';
-import { BlockCommentManager, CommentProviderIdentifier, DocModeProvider, NotificationProvider, TelemetryProvider, TOAST_COPIED_TO_CLIPBOARD, translateKey, } from '../affine-shared/services/index.js';
+import { BlockCommentManager, CommentProviderIdentifier, DocModeProvider, NotificationProvider, PropertiesPanelProvider, TelemetryProvider, TOAST_COPIED_TO_CLIPBOARD, translateKey, } from '../affine-shared/services/index.js';
 import { getDropResult } from '../affine-widget-drag-handle/index.js';
-import { createRecordDetail, createUniComponentFromWebComponent, DataViewRootUILogic, defineUniComponent, ExternalGroupByConfigProvider, renderUniLit, uniMap, } from '../data-view/index.js';
+import { createRecordDetail, createUniComponentFromWebComponent, DataViewRootUILogic, DataViewEventTraceKey, defineUniComponent, ExternalGroupByConfigProvider, NewRowMenuOpenerKey, PropertiesPanelOpenerKey, renderUniLit, traceViewEvent, uniMap, ViewCreationOffKey, } from '../data-view/index.js';
 import { CalendarExternalSourceProvider } from '../data-view/view-presets/index.js';
 import { widgetPresets } from '../data-view/widget-presets/index.js';
 import { Rect } from '../global/gfx/index.js';
@@ -22,13 +22,16 @@ import { popSideDetail } from './components/layout.js';
 import { DatabaseConfigExtension } from './config.js';
 import { EditorHostKey } from './context/host-context.js';
 import { DatabaseBlockDataSource } from './data-source.js';
-import { databaseBlockStyles, databaseContentStyles, databaseHeaderBarStyles, databaseHeaderContainerStyles, databaseOpsStyles, databaseTitleRowStyles, databaseTitleStyles, databaseToolbarRowStyles, databaseViewBarContainerStyles, } from './database-block-styles.js';
+import { HostedDataSourceBase } from './external-data-source.js';
+import { databaseBlockStyles, databaseContentStyles, databaseHeaderBarStyles, databaseHeaderContainerStyles, databaseOpsStyles, databaseSourceMissingHintStyles, databaseSourceMissingStyles, databaseTitleRowStyles, databaseTitleStyles, databaseToolbarRowStyles, databaseViewBarContainerStyles, } from './database-block-styles.js';
 import { BlockRenderer } from './detail-panel/block-renderer.js';
 import { NoteRenderer } from './detail-panel/note-renderer.js';
 import { DatabaseSelection } from './selection.js';
-import { DatabaseDataSourceProvider } from './service/index.js';
+import { databaseOpenRowRequest, DatabaseDataSourceProvider, DatabaseNewRowMenuProvider, DatabaseOpenRowProvider, openDatabasePropertiesPanel, rowOpenedParams, } from './service/index.js';
+import { DATABASE_NEW_RECORD_MORE, DATABASE_SOURCE_MISSING, DATABASE_SOURCE_MISSING_HINT, } from './translations.js';
 import { currentViewStorage } from './utils/current-view.js';
 import { getSingleDocIdFromText } from './utils/title-doc.js';
+import { DatabaseViewCreationIdentifier } from './view-creation.js';
 export class DatabaseBlockComponent extends CaptionedBlockComponent {
     constructor() {
         super(...arguments);
@@ -94,6 +97,18 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
         // forcing Lit to tear the old one down (disposing its listeners) and mount a
         // fresh one bound to the new source.
         this._sourceVersion = 0;
+        /**
+         * Every database event leaves here, with the block's id and nothing about
+         * its rows (telemetry README, "Databases"): the root's `eventTrace`, and
+         * the source's `DataViewEventTraceKey` for code that holds only a view.
+         */
+        this.traceDatabaseEvent = (key, params) => {
+            const telemetryService = this.std.getOptional(TelemetryProvider);
+            telemetryService?.track(key, {
+                ...params,
+                blockId: this.blockId,
+            });
+        };
         this.renderTitle = (dataViewLogic) => {
             return html ` <affine-database-title
       class="${databaseTitleStyles}"
@@ -125,17 +140,15 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
             ${this.renderTitle(props.dataViewLogic)} ${this.renderDatabaseOps()}
           </div>
           <div class="${databaseToolbarRowStyles} ${databaseHeaderBarStyles}">
-            <div class="${databaseViewBarContainerStyles}">
-              ${renderUniLit(widgetPresets.viewBar, {
-                ...props,
-                onChangeView: id => {
-                    currentViewStorage.setCurrentView(this.blockId, id);
-                },
-            })}
-            </div>
+            ${this.renderViewBar(props)}
             ${renderUniLit(this.toolsWidget, props)}
           </div>
           ${renderUniLit(widgetPresets.quickSettingBar, props)}
+          <affine-database-values-banner
+            .dataSource="${this.dataSource}"
+            .std="${this.std}"
+            .trace="${this.traceDatabaseEvent}"
+          ></affine-database-values-banner>
         </div>
       `;
         });
@@ -201,6 +214,20 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
                 widgetPresets.tools.viewOptions,
                 widgetPresets.tools.tableAddRow,
             ],
+            gallery: [
+                widgetPresets.tools.filter,
+                widgetPresets.tools.sort,
+                widgetPresets.tools.search,
+                widgetPresets.tools.viewOptions,
+                widgetPresets.tools.tableAddRow,
+            ],
+            list: [
+                widgetPresets.tools.filter,
+                widgetPresets.tools.sort,
+                widgetPresets.tools.search,
+                widgetPresets.tools.viewOptions,
+                widgetPresets.tools.tableAddRow,
+            ],
         });
         this.viewSelection$ = computed(() => {
             const databaseSelection = this.selection.value.find((selection) => {
@@ -212,11 +239,63 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
             return databaseSelection?.viewSelection;
         });
         this.virtualPadding$ = signal(0);
+        // ADR 0035 §7: a view whose source the host cannot resolve keeps the title
+        // and the view bar, so another view can be picked, and draws this instead of
+        // its tools and body: nothing to filter, add or edit, and nothing rewritten.
+        this.renderSourceMissing = (dataViewLogic) => {
+            const dataSource = this.dataSource;
+            if (!(dataSource instanceof HostedDataSourceBase))
+                return undefined;
+            if (!dataSource.sourceMissing$.value)
+                return undefined;
+            return html `<div class="${databaseHeaderContainerStyles}">
+        <div class="${databaseTitleRowStyles}">
+          ${this.renderTitle(dataViewLogic)}
+        </div>
+        <div class="${databaseToolbarRowStyles} ${databaseHeaderBarStyles}">
+          ${this.renderViewBar({ dataViewLogic })}
+        </div>
+      </div>
+      <div
+        class="${databaseSourceMissingStyles}"
+        data-testid="database-source-missing"
+        role="status"
+      >
+        <div>${translateKey(this.std, ...DATABASE_SOURCE_MISSING)}</div>
+        <div class="${databaseSourceMissingHintStyles}">
+          ${translateKey(this.std, ...DATABASE_SOURCE_MISSING_HINT)}
+        </div>
+      </div>`;
+        };
         this.#useZeroWidth_accessor_storage = true;
     }
     _buildDataSource() {
         const initFn = (dataSource) => {
             dataSource.serviceSet(EditorHostKey, this.host);
+            dataSource.serviceSet(DataViewEventTraceKey, this.traceDatabaseEvent);
+            // With a host properties panel, the view options' "Properties" opens
+            // it (ADR 0035 §9b); without, the data-view's popover stays.
+            if (this.std.getOptional(PropertiesPanelProvider)) {
+                dataSource.serviceSet(PropertiesPanelOpenerKey, viewId => {
+                    openDatabasePropertiesPanel(this.std, this.model, viewId);
+                });
+            }
+            // With a host menu beside "New" (its templates), the header draws a
+            // chevron that opens it; the main part still adds a row (`rowAdd`).
+            const newRowMenu = this.std.getOptional(DatabaseNewRowMenuProvider);
+            if (newRowMenu) {
+                dataSource.serviceSet(NewRowMenuOpenerKey, {
+                    label: () => translateKey(this.std, ...DATABASE_NEW_RECORD_MORE),
+                    canOpen: viewId => newRowMenu.canOpen?.({ blockId: this.model.id, viewId }) ?? true,
+                    open: (anchor, viewId) => {
+                        newRowMenu.open({ anchor, blockId: this.model.id, viewId });
+                    },
+                });
+            }
+            // `{ database: false }` takes view creation away, never the views.
+            if (!this.std.getOptional(DatabaseViewCreationIdentifier)) {
+                dataSource.serviceSet(ViewCreationOffKey, true);
+            }
             this.std.provider
                 .getAll(ExternalGroupByConfigProvider)
                 .forEach(config => {
@@ -251,6 +330,43 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
         this._sourceVersion++;
         this.requestUpdate();
     }
+    /**
+     * A row that is a document opens where the host says, in the view's
+     * `openIn` mode (ADR 0035 §9a, B9); without an opener, or for a row that is
+     * a block, the caller keeps the peek view and the side detail of 0.48.
+     * Every row open passes here once, so `DatabaseRowOpened` leaves from here
+     * (B17), whichever path then opens the row.
+     */
+    openRowThroughHost(data) {
+        const opener = this.std.getOptional(DatabaseOpenRowProvider);
+        const source = this.dataSource;
+        const viewData = source.viewDataGet(data.view.id);
+        const rowsAreDocuments = source instanceof HostedDataSourceBase && source.rowsAreDocuments;
+        const request = databaseOpenRowRequest({
+            hasOpener: !!opener,
+            rowsAreDocuments,
+            rowId: data.rowId,
+            viewId: data.view.id,
+            blockId: this.blockId,
+            openIn: viewData?.openIn,
+            newTab: data.newTab,
+        });
+        traceViewEvent(data.view, 'DatabaseRowOpened', rowOpenedParams(request, rowsAreDocuments, data.newTab));
+        if (!opener || !request)
+            return false;
+        opener.open(request);
+        return true;
+    }
+    renderViewBar(props) {
+        return html `<div class="${databaseViewBarContainerStyles}">
+      ${renderUniLit(widgetPresets.viewBar, {
+            ...props,
+            onChangeView: id => {
+                currentViewStorage.setCurrentView(this.blockId, id);
+            },
+        })}
+    </div>`;
+    }
     get optionsConfig() {
         return {
             configure: (_model, options) => options,
@@ -310,6 +426,15 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
             this.virtualPadding$.value = Math.max(0, padding - 72);
         }));
     }
+    /**
+     * Puts the caret on the current view's first cell, where the view has one
+     * (table, kanban; the other presets ignore it): what the page title's
+     * Enter and ArrowDown reach when this block is the page's body
+     * (`<doc-title .bodyBlockId>`, a database's full page, ADR 0035 B13).
+     */
+    focusFirstCell() {
+        this._dataViewRootLogic?.focusFirstCell();
+    }
     get dataViewRootLogic() {
         if (!this._dataViewRootLogic) {
             this._dataViewRootLogic = this._buildDataViewRootLogic();
@@ -337,6 +462,7 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
             setSelection: this.setSelection,
             dataSource: this.dataSource,
             headerWidget: this.headerWidget,
+            viewPlaceholder: this.renderSourceMissing,
             onDrag: this.onDrag,
             clipboard: this.std.clipboard,
             dnd: this.std.dnd,
@@ -351,15 +477,11 @@ export class DatabaseBlockComponent extends CaptionedBlockComponent {
                     }
                 },
             },
-            eventTrace: (key, params) => {
-                const telemetryService = this.std.getOptional(TelemetryProvider);
-                telemetryService?.track(key, {
-                    ...params,
-                    blockId: this.blockId,
-                });
-            },
+            eventTrace: this.traceDatabaseEvent,
             detailPanelConfig: {
                 openDetailPanel: (target, data) => {
+                    if (this.openRowThroughHost(data))
+                        return Promise.resolve();
                     const peekViewService = this.std.getOptional(PeekViewProvider);
                     if (peekViewService) {
                         const openDoc = (docId) => {

package/dist/_pkgs/affine-block-database/effects.js

@@ -1,5 +1,6 @@
 import { CenterPeek } from './components/layout.js';
 import { DatabaseTitle } from './components/title/index.js';
+import { DatabaseValuesBanner } from './components/values-banner.js';
 import { DatabaseBlockComponent } from './database-block.js';
 import { DatabaseDndPreviewBlockComponent } from './database-dnd-preview-block.js';
 import { BlockRenderer } from './detail-panel/block-renderer.js';
@@ -11,6 +12,7 @@ import { IconCell } from './properties/title/icon.js';
 import { HeaderAreaTextCell } from './properties/title/text.js';
 export function effects() {
     customElements.define('affine-database-title', DatabaseTitle);
+    customElements.define('affine-database-values-banner', DatabaseValuesBanner);
     customElements.define('data-view-header-area-icon', IconCell);
     customElements.define('affine-database-link-cell', LinkCell);
     customElements.define('data-view-header-area-text', HeaderAreaTextCell);

package/dist/_pkgs/affine-block-database/external-data-source.d.ts

@@ -3,6 +3,22 @@ import type { InsertToPosition } from '../affine-shared/utils/index.js';
 import { type DatabaseFlags, DataSourceBase, type DataViewDataType, type PropertyMetaConfig, type TypeInstance, type ViewManager, type ViewMeta } from '../data-view/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
 import { type ReadonlySignal } from '@preact/signals-core';
+/**
+ * One source of a hosted database, as `resolveSource` answers it (ADR 0035
+ * §7, issue B1): the `affine:database` block that owns its schema
+ * (`props.columns`) and its ordered row ids. Where the host keeps its sources
+ * is the host's format; the library never reads it.
+ */
+export interface HostedSource {
+    schema: DatabaseBlockModel;
+    rows: ReadonlySignal<string[]>;
+}
+/**
+ * `sourceId` is the current view's stored `sourceId` (ADR 0035 §8), absent
+ * for every view stored before 0.49. `null`: no such source, and the view
+ * draws "Source not found" instead of its body (never an error).
+ */
+export type ResolveHostedSource = (sourceId: string | undefined) => HostedSource | null;
 /**
  * Intermediate base for `affine:database` data sources whose **view config**
  * keeps living in the block model blob (`model.props.views`) while the **data
@@ -23,13 +39,58 @@ import { type ReadonlySignal } from '@preact/signals-core';
  * computeds re-run. Defining `rows$`/`properties$` here (not as instance fields
  * reassigned in a subclass constructor) also avoids the "reassign after super"
  * dance.
+ *
+ * Sources (ADR 0035 §7, B1): the views live in `hostModel.props.views`; each
+ * view reads the source its `sourceId` names, through `resolveSource`. The
+ * data layer answers for the CURRENT view's source ({@link source$},
+ * {@link schema$}, {@link rows$}): one view is drawn at a time, and property
+ * ids never collide across sources (host-generated uuids). Without
+ * `resolveSource` the block has one implicit source, itself, whatever a view
+ * says: the 0.48 behaviour, which `ExternalDataSourceBase(model)` keeps.
+ *
+ * Rows that are documents (B15): a source whose rows are documents says so
+ * with {@link rowsAreDocuments}, answers each title from its own store with
+ * {@link titleOf}, and returns `hostedTitleColumnConfig` from
+ * `propertyMetaGet('title')`, so a title is a plain string and no row's
+ * document is loaded to draw it.
  */
-export declare abstract class ExternalDataSourceBase extends DataSourceBase {
+export declare abstract class HostedDataSourceBase extends DataSourceBase {
+    /** The block that hosts the views (and, without `resolveSource`, the data). */
     protected readonly _model: DatabaseBlockModel;
+    private readonly _resolveSource;
     /** Bumped by {@link invalidate} to re-run the data-layer computeds. */
     protected readonly revision: import("@preact/signals-core").Signal<number>;
     protected readonly disposables: DisposableGroup;
-    constructor(model: DatabaseBlockModel);
+    constructor(hostModel: DatabaseBlockModel, resolveSource?: ResolveHostedSource);
+    get hostModel(): DatabaseBlockModel;
+    /** The current view's stored `sourceId`; `undefined` reads the implicit source. */
+    readonly currentSourceId$: ReadonlySignal<string | undefined>;
+    private readonly _implicitRows$;
+    /**
+     * Whether views name the source they read: a `resolveSource` was given.
+     * Without it there is one implicit source, the block, whatever `sourceId`
+     * a view stores, so chrome that lists sources has nothing to list.
+     */
+    get resolvesSources(): boolean;
+    /**
+     * Any source, by the `sourceId` a view would store, resolved the way the
+     * current view's is ({@link source$}); `null` when there is no such source.
+     * Read by chrome that lists the sources of the views (the "+ view" menu of
+     * `@labre/affine-database-editor`, ADR 0035 B11). Writes nothing.
+     */
+    sourceOf(sourceId: string | undefined): HostedSource | null;
+    /** The current view's source; `null` when `resolveSource` knows none. */
+    readonly source$: ReadonlySignal<HostedSource | null>;
+    readonly schema$: ReadonlySignal<DatabaseBlockModel | null>;
+    readonly sourceMissing$: ReadonlySignal<boolean>;
+    /** Each row is a document (ADR 0035 §9a, §9f). Read-only. */
+    get rowsAreDocuments(): boolean;
+    /**
+     * A document row's title from the source's own store, read for the `title`
+     * property when {@link rowsAreDocuments}; `undefined` falls back to
+     * `getCellValue`.
+     */
+    protected titleOf(_rowId: string): string | undefined;
     /** Notify the view layer that the underlying data changed. */
     protected invalidate(): void;
     dispose(): void;
@@ -67,3 +128,9 @@ export declare abstract class ExternalDataSourceBase extends DataSourceBase {
     viewMetaGet(type: string): ViewMeta;
     viewMetaGetById(viewId: string): ViewMeta | undefined;
 }
+/**
+ * The 0.48 name, kept so a host source written against it compiles unchanged:
+ * `new ExternalDataSourceBase(model)` is a hosted source with one implicit
+ * source, the block itself.
+ */
+export { HostedDataSourceBase as ExternalDataSourceBase };

package/dist/_pkgs/affine-block-database/external-data-source.js

@@ -1,11 +1,9 @@
 import { FeatureFlagService } from '../affine-shared/services/index.js';
 import { DataSourceBase, ViewManagerBase, } from '../data-view/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
-import { IS_MOBILE } from '../global/env/index.js';
-import { BlockSuiteError, ErrorCode } from '../global/exceptions/index.js';
 import { computed, signal } from '@preact/signals-core';
 import { deleteView, duplicateView, moveViewTo, updateView, } from './utils/block-utils.js';
-import { databaseBlockViewConverts, databaseBlockViewMap, databaseBlockViews, } from './views/index.js';
+import { databaseBlockViewConverts, databaseBlockViewMetaGet, databaseBlockViews, } from './views/index.js';
 /**
  * Intermediate base for `affine:database` data sources whose **view config**
  * keeps living in the block model blob (`model.props.views`) while the **data
@@ -26,18 +24,49 @@ import { databaseBlockViewConverts, databaseBlockViewMap, databaseBlockViews, }
  * computeds re-run. Defining `rows$`/`properties$` here (not as instance fields
  * reassigned in a subclass constructor) also avoids the "reassign after super"
  * dance.
+ *
+ * Sources (ADR 0035 §7, B1): the views live in `hostModel.props.views`; each
+ * view reads the source its `sourceId` names, through `resolveSource`. The
+ * data layer answers for the CURRENT view's source ({@link source$},
+ * {@link schema$}, {@link rows$}): one view is drawn at a time, and property
+ * ids never collide across sources (host-generated uuids). Without
+ * `resolveSource` the block has one implicit source, itself, whatever a view
+ * says: the 0.48 behaviour, which `ExternalDataSourceBase(model)` keeps.
+ *
+ * Rows that are documents (B15): a source whose rows are documents says so
+ * with {@link rowsAreDocuments}, answers each title from its own store with
+ * {@link titleOf}, and returns `hostedTitleColumnConfig` from
+ * `propertyMetaGet('title')`, so a title is a plain string and no row's
+ * document is loaded to draw it.
  */
-export class ExternalDataSourceBase extends DataSourceBase {
-    constructor(model) {
+export class HostedDataSourceBase extends DataSourceBase {
+    constructor(hostModel, resolveSource) {
         super();
         /** Bumped by {@link invalidate} to re-run the data-layer computeds. */
         this.revision = signal(0);
         this.disposables = new DisposableGroup();
-        // --- reactive bridge over the data contract -----------------------------
-        this.rows$ = computed(() => {
+        /** The current view's stored `sourceId`; `undefined` reads the implicit source. */
+        this.currentSourceId$ = computed(() => {
+            const viewId = this.viewManager.currentViewId$.value;
+            if (!viewId)
+                return undefined;
+            const view = this.viewDataGet(viewId);
+            return view?.sourceId;
+        });
+        this._implicitRows$ = computed(() => {
             void this.revision.value;
             return this.getRows();
         });
+        /** The current view's source; `null` when `resolveSource` knows none. */
+        // Without `resolveSource` the current view is not read at all: the
+        // implicit source does not depend on it.
+        this.source$ = computed(() => this._resolveSource
+            ? this.sourceOf(this.currentSourceId$.value)
+            : this.sourceOf(undefined));
+        this.schema$ = computed(() => this.source$.value?.schema ?? null);
+        this.sourceMissing$ = computed(() => this.source$.value === null);
+        // --- reactive bridge over the data contract -----------------------------
+        this.rows$ = computed(() => this.source$.value?.rows.value ?? []);
         this.properties$ = computed(() => {
             void this.revision.value;
             return this.getProperties();
@@ -58,10 +87,10 @@ export class ExternalDataSourceBase extends DataSourceBase {
                 enable_table_virtual_scroll: featureFlagService.getFlag('enable_table_virtual_scroll') ?? false,
             };
         });
+        // Mobile edits too (ADR 0035 §1, B5): the table and kanban presets ship
+        // their own touch renderers, chosen by `DataViewRootUILogic`.
         this.readonly$ = computed(() => {
-            return (this._model.store.readonly ||
-                // TODO(@L-Sun): use block level readonly
-                IS_MOBILE);
+            return this._model.store.readonly;
         });
         this.viewConverts = databaseBlockViewConverts;
         this.viewMetas = databaseBlockViews;
@@ -69,7 +98,43 @@ export class ExternalDataSourceBase extends DataSourceBase {
         this.viewDataList$ = computed(() => {
             return this._model.props.views$.value;
         });
-        this._model = model;
+        this._model = hostModel;
+        this._resolveSource = resolveSource;
+    }
+    get hostModel() {
+        return this._model;
+    }
+    /**
+     * Whether views name the source they read: a `resolveSource` was given.
+     * Without it there is one implicit source, the block, whatever `sourceId`
+     * a view stores, so chrome that lists sources has nothing to list.
+     */
+    get resolvesSources() {
+        return this._resolveSource !== undefined;
+    }
+    /**
+     * Any source, by the `sourceId` a view would store, resolved the way the
+     * current view's is ({@link source$}); `null` when there is no such source.
+     * Read by chrome that lists the sources of the views (the "+ view" menu of
+     * `@labre/affine-database-editor`, ADR 0035 B11). Writes nothing.
+     */
+    sourceOf(sourceId) {
+        if (!this._resolveSource) {
+            return { schema: this._model, rows: this._implicitRows$ };
+        }
+        return this._resolveSource(sourceId);
+    }
+    /** Each row is a document (ADR 0035 §9a, §9f). Read-only. */
+    get rowsAreDocuments() {
+        return false;
+    }
+    /**
+     * A document row's title from the source's own store, read for the `title`
+     * property when {@link rowsAreDocuments}; `undefined` falls back to
+     * `getCellValue`.
+     */
+    titleOf(_rowId) {
+        return undefined;
     }
     /** Notify the view layer that the underlying data changed. */
     invalidate() {
@@ -86,6 +151,11 @@ export class ExternalDataSourceBase extends DataSourceBase {
     }
     cellValueGet(rowId, propertyId) {
         void this.revision.value;
+        if (this.rowsAreDocuments && this.getPropertyType(propertyId) === 'title') {
+            const title = this.titleOf(rowId);
+            if (title !== undefined)
+                return title;
+        }
         return this.getCellValue(rowId, propertyId);
     }
     propertyTypeGet(propertyId) {
@@ -128,11 +198,7 @@ export class ExternalDataSourceBase extends DataSourceBase {
         updateView(this._model, id, updater);
     }
     viewMetaGet(type) {
-        const view = databaseBlockViewMap[type];
-        if (!view) {
-            throw new BlockSuiteError(ErrorCode.DatabaseBlockError, `Unknown view type: ${type}`);
-        }
-        return view;
+        return databaseBlockViewMetaGet(type);
     }
     viewMetaGetById(viewId) {
         const view = this.viewDataGet(viewId);
@@ -142,3 +208,9 @@ export class ExternalDataSourceBase extends DataSourceBase {
         return this.viewMetaGet(view.mode);
     }
 }
+/**
+ * The 0.48 name, kept so a host source written against it compiles unchanged:
+ * `new ExternalDataSourceBase(model)` is a hosted source with one implicit
+ * source, the block itself.
+ */
+export { HostedDataSourceBase as ExternalDataSourceBase };

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

@@ -12,5 +12,7 @@ export * from './properties/rich-text/cell-renderer.js';
 export * from './selection.js';
 export * from './service/index.js';
 export * from './utils/block-utils.js';
+export * from './view-creation.js';
 export * from './views/index.js';
 export * from '../data-view/index.js';
+export * from './linked-view.js';

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

@@ -12,5 +12,7 @@ export * from './properties/rich-text/cell-renderer.js';
 export * from './selection.js';
 export * from './service/index.js';
 export * from './utils/block-utils.js';
+export * from './view-creation.js';
 export * from './views/index.js';
 export * from '../data-view/index.js';
+export * from './linked-view.js';

package/dist/_pkgs/affine-block-database/linked-view.d.ts

@@ -0,0 +1,38 @@
+import { type DataSourcePickerDatabase, type DataSourcePickerService } from '../affine-shared/services/index.js';
+import type { BlockStdScope } from '../std/index.js';
+import { type BlockModel } from '../store/index.js';
+/**
+ * A view of a host database inserted into a document (ADR 0035 §5, §9c,
+ * issue B12): an `affine:database` block whose `externalSourceId` is the
+ * database the host listed and whose one view reads the chosen source
+ * (`sourceId`). No new prop, no new flavour: the shape every hosted database
+ * already has (labre ADR-0046 §3).
+ *
+ * The view's preset data comes from the preset's own `defaultData`, computed
+ * over the host's data source with the new view current, so a board groups by
+ * a property of the source it reads. One gesture, one undo step: the block
+ * and its view are written without a `captureSync` between them.
+ *
+ * Returns the new block's id, or `null` when nothing was written (read-only
+ * document, the anchor gone, no host data source).
+ */
+export declare function insertLinkedDatabaseView(std: BlockStdScope, options: {
+    /** The block the view goes after. */
+    after: BlockModel;
+    database: Pick<DataSourcePickerDatabase, 'id' | 'title'>;
+    sourceId: string;
+    viewType: string;
+    /** Drop `after` when it is an empty paragraph (a slash entry's line). */
+    removeEmptyLine?: boolean;
+}): string | null;
+/**
+ * The creating slash entries once the host fills the picker (ADR 0035 §5):
+ * ask the host for a new database, then insert a view of its first source
+ * after `after`. Nothing is written until the host answers; `null`, or a
+ * database with no source, writes nothing.
+ */
+export declare function createHostedDatabaseView(std: BlockStdScope, picker: DataSourcePickerService, options: {
+    after: BlockModel;
+    viewType: string;
+    removeEmptyLine?: boolean;
+}): Promise<string | null>;