@formicoidea/labre-core 0.47.1 → 0.49.0

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

@@ -1,6 +1,7 @@
 import { FeatureFlagService } from '../../affine-shared/services/index.js';
 import { isInsideBlockByFlavour } from '../../affine-shared/utils/index.js';
 import {} from '../../affine-widget-slash-menu/index.js';
+import { viewDefaultName } from '../../data-view/index.js';
 import { DatabaseTableViewIcon } from '@blocksuite/icons/lit';
 import { ToDoListTooltip } from './tooltips.js';
 export const dataViewSlashMenuConfig = {
@@ -28,7 +29,8 @@ export const dataViewSlashMenuConfig = {
                 const id = host.store.addBlock('affine:data-view', {}, host.store.getParent(model), index + 1);
                 const dataViewModel = host.store.getBlock(id);
                 const dataView = std.view.getBlock(dataViewModel.id);
-                dataView?.dataSource.viewManager.viewAdd('table');
+                const dataSource = dataView?.dataSource;
+                dataSource?.viewManager.viewAdd('table', viewDefaultName(dataSource.viewMetaGet('table'), std));
                 if (model.text?.length === 0) {
                     model.store.deleteBlock(model);
                 }

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

@@ -1,6 +1,22 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '../affine-ext-loader/index.js';
-export declare class DataViewViewExtension extends ViewExtensionProvider {
+/**
+ * Data-view block rendering — ALWAYS registered, independent of the
+ * `data-view` flag (ADR 0009, ADR 0035 §5, issue B4): `effects()`, the
+ * flavour and the block view, so a stored `affine:data-view` block draws
+ * whatever the flags say. Until 0.48 all of it sat behind `data-view`.
+ */
+export declare class DataViewRenderViewExtension extends ViewExtensionProvider {
     name: string;
     effect(): void;
     setup(context: ViewExtensionContext): void;
 }
+/**
+ * Data-view creation tooling — flag-gated (`data-view`). It registers nothing
+ * today: the block's only creation path, `dataViewSlashMenuConfig`, was never
+ * registered (it also waits on `enable_block_query`). The class keeps the
+ * render / tooling split of every other block, so a creation entry lands here
+ * the day one ships, and a host that names it keeps compiling.
+ */
+export declare class DataViewViewExtension extends ViewExtensionProvider {
+    name: string;
+}

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

@@ -4,10 +4,16 @@ import { literal } from 'lit/static-html.js';
 import { DataViewBlockSchema } from './data-view-model.js';
 import { effects } from './effects.js';
 const flavour = DataViewBlockSchema.model.flavour;
-export class DataViewViewExtension extends ViewExtensionProvider {
+/**
+ * Data-view block rendering — ALWAYS registered, independent of the
+ * `data-view` flag (ADR 0009, ADR 0035 §5, issue B4): `effects()`, the
+ * flavour and the block view, so a stored `affine:data-view` block draws
+ * whatever the flags say. Until 0.48 all of it sat behind `data-view`.
+ */
+export class DataViewRenderViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
-        this.name = 'affine-data-view-block';
+        this.name = 'affine-data-view-render-block';
     }
     effect() {
         super.effect();
@@ -21,3 +27,16 @@ export class DataViewViewExtension extends ViewExtensionProvider {
         ]);
     }
 }
+/**
+ * Data-view creation tooling — flag-gated (`data-view`). It registers nothing
+ * today: the block's only creation path, `dataViewSlashMenuConfig`, was never
+ * registered (it also waits on `enable_block_query`). The class keeps the
+ * render / tooling split of every other block, so a creation entry lands here
+ * the day one ships, and a host that names it keeps compiling.
+ */
+export class DataViewViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-data-view-block';
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { Command } from '../std/index.js';
+import type { BlockStdScope, Command } from '../std/index.js';
 import type { BlockModel, Store } from '../store/index.js';
 export declare const insertDatabaseBlockCommand: Command<{
     selectedModels?: BlockModel[];
@@ -8,4 +8,4 @@ export declare const insertDatabaseBlockCommand: Command<{
 }, {
     insertedDatabaseBlockId: string;
 }>;
-export declare const initDatabaseBlock: (doc: Store, model: BlockModel, databaseId: string, viewType: string, isAppendNewRow?: boolean) => void;
+export declare const initDatabaseBlock: (doc: Store, model: BlockModel, databaseId: string, viewType: string, isAppendNewRow?: boolean, std?: BlockStdScope) => void;

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

@@ -12,19 +12,19 @@ export const insertDatabaseBlockCommand = (ctx, next) => {
     const string = result[0];
     if (string == null)
         return;
-    initDatabaseBlock(std.store, targetModel, string, viewType, false);
+    initDatabaseBlock(std.store, targetModel, string, viewType, false, std);
     if (removeEmptyLine && targetModel.text?.length === 0) {
         std.store.deleteBlock(targetModel);
     }
     next({ insertedDatabaseBlockId: string });
 };
-export const initDatabaseBlock = (doc, model, databaseId, viewType, isAppendNewRow = true) => {
+export const initDatabaseBlock = (doc, model, databaseId, viewType, isAppendNewRow = true, std) => {
     const blockModel = doc.getBlock(databaseId)?.model;
     if (!blockModel) {
         return;
     }
     const datasource = new DatabaseBlockDataSource(blockModel);
-    databaseViewInitTemplate(datasource, viewType);
+    databaseViewInitTemplate(datasource, viewType, std);
     if (isAppendNewRow) {
         const parent = doc.getParent(model);
         if (!parent)

package/dist/_pkgs/affine-block-database/components/values-banner.d.ts

@@ -0,0 +1,28 @@
+import { type DatabaseAllEvents, type EventTraceFn } from '../../affine-shared/services/index.js';
+import { type DataSourceHydration } from '../../data-view/index.js';
+import { type BlockStdScope, ShadowlessElement } from '../../std/index.js';
+import { nothing } from 'lit';
+declare const DatabaseValuesBanner_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
+export declare class DatabaseValuesBanner extends DatabaseValuesBanner_base {
+    static styles: import("lit").CSSResult;
+    accessor dataSource: DataSourceHydration;
+    accessor std: BlockStdScope;
+    /** Where `DatabaseValuesLoadFailed` goes (the block's tracer); absent, nowhere. */
+    accessor trace: EventTraceFn<DatabaseAllEvents> | undefined;
+    /** Re-evaluated when the 3 s mark passes; never toggled. */
+    private readonly _now$;
+    connectedCallback(): void;
+    /**
+     * Once per failure of a source (its `since`), not per banner: a block
+     * re-rendered, or two views of one source, report it once.
+     */
+    private reportFailure;
+    private readonly _retry;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'affine-database-values-banner': DatabaseValuesBanner;
+    }
+}
+export {};

package/dist/_pkgs/affine-block-database/components/values-banner.js

@@ -0,0 +1,199 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { RESOURCE_STATUS_RETRY } from '../../affine-components/translations.js';
+import { translateKey, } from '../../affine-shared/services/index.js';
+import { valuesBannerOf, valuesStateOf, VALUES_SLOW_AFTER_MS, } from '../../data-view/index.js';
+import { SignalWatcher, WithDisposable } from '../../global/lit/index.js';
+import { ShadowlessElement } from '../../std/index.js';
+import { effect, signal } from '@preact/signals-core';
+import { css, html, nothing } from 'lit';
+import { property } from 'lit/decorators.js';
+import { DATABASE_VALUES_ERROR, DATABASE_VALUES_LOADING, } from '../translations.js';
+/**
+ * The hydration banner of a database (ADR 0035 §9e, issue B2): nothing while
+ * values load for less than 3 s, "still loading" after, "could not be
+ * loaded" with Retry on `error` (Retry only when the source offers
+ * `retryValues`). It reads the source's `valuesState$` and writes nothing; a
+ * source that says nothing about hydration never shows it.
+ */
+const reportedFailures = new WeakMap();
+let DatabaseValuesBanner = (() => {
+    let _classSuper = SignalWatcher(WithDisposable(ShadowlessElement));
+    let _dataSource_decorators;
+    let _dataSource_initializers = [];
+    let _dataSource_extraInitializers = [];
+    let _std_decorators;
+    let _std_initializers = [];
+    let _std_extraInitializers = [];
+    let _trace_decorators;
+    let _trace_initializers = [];
+    let _trace_extraInitializers = [];
+    return class DatabaseValuesBanner extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.#dataSource_accessor_storage = __runInitializers(this, _dataSource_initializers, void 0);
+            this.#std_accessor_storage = (__runInitializers(this, _dataSource_extraInitializers), __runInitializers(this, _std_initializers, void 0));
+            this.#trace_accessor_storage = (__runInitializers(this, _std_extraInitializers), __runInitializers(this, _trace_initializers, undefined));
+            /** Re-evaluated when the 3 s mark passes; never toggled. */
+            this._now$ = (__runInitializers(this, _trace_extraInitializers), signal(Date.now()));
+            this._retry = () => {
+                this.dataSource.retryValues?.();
+            };
+        }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _dataSource_decorators = [property({ attribute: false })];
+            _std_decorators = [property({ attribute: false })];
+            _trace_decorators = [property({ attribute: false })];
+            __esDecorate(this, null, _dataSource_decorators, { kind: "accessor", name: "dataSource", static: false, private: false, access: { has: obj => "dataSource" in obj, get: obj => obj.dataSource, set: (obj, value) => { obj.dataSource = value; } }, metadata: _metadata }, _dataSource_initializers, _dataSource_extraInitializers);
+            __esDecorate(this, null, _std_decorators, { kind: "accessor", name: "std", static: false, private: false, access: { has: obj => "std" in obj, get: obj => obj.std, set: (obj, value) => { obj.std = value; } }, metadata: _metadata }, _std_initializers, _std_extraInitializers);
+            __esDecorate(this, null, _trace_decorators, { kind: "accessor", name: "trace", static: false, private: false, access: { has: obj => "trace" in obj, get: obj => obj.trace, set: (obj, value) => { obj.trace = value; } }, metadata: _metadata }, _trace_initializers, _trace_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static { this.styles = css `
+    affine-database-values-banner {
+      display: block;
+    }
+
+    .affine-database-values-banner {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      margin: 4px 0;
+      padding: 4px 8px;
+      min-height: 32px;
+      border-radius: 8px;
+      font-size: 14px;
+      line-height: 22px;
+      color: var(--affine-text-secondary-color);
+      background-color: var(--affine-hover-color);
+    }
+
+    .affine-database-values-banner[data-kind='error'] {
+      color: var(--affine-error-color);
+    }
+
+    .affine-database-values-banner-text {
+      flex: 1;
+      min-width: 0;
+    }
+  `; }
+        #dataSource_accessor_storage;
+        get dataSource() { return this.#dataSource_accessor_storage; }
+        set dataSource(value) { this.#dataSource_accessor_storage = value; }
+        #std_accessor_storage;
+        get std() { return this.#std_accessor_storage; }
+        set std(value) { this.#std_accessor_storage = value; }
+        #trace_accessor_storage;
+        /** Where `DatabaseValuesLoadFailed` goes (the block's tracer); absent, nowhere. */
+        get trace() { return this.#trace_accessor_storage; }
+        set trace(value) { this.#trace_accessor_storage = value; }
+        connectedCallback() {
+            super.connectedCallback();
+            let timer;
+            const clear = () => {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                timer = undefined;
+            };
+            this.disposables.add(effect(() => {
+                const state = valuesStateOf(this.dataSource);
+                clear();
+                this._now$.value = Date.now();
+                if (state.status === 'error')
+                    this.reportFailure(state.since);
+                if (state.status !== 'loading')
+                    return;
+                const wait = state.since + VALUES_SLOW_AFTER_MS - Date.now();
+                if (wait <= 0)
+                    return;
+                timer = setTimeout(() => {
+                    this._now$.value = Date.now();
+                }, wait);
+            }));
+            this.disposables.add(clear);
+        }
+        /**
+         * Once per failure of a source (its `since`), not per banner: a block
+         * re-rendered, or two views of one source, report it once.
+         */
+        reportFailure(since) {
+            const source = this.dataSource;
+            if (reportedFailures.get(source) === since)
+                return;
+            reportedFailures.set(source, since);
+            this.trace?.('DatabaseValuesLoadFailed', {
+                retryable: !!source.retryValues,
+            });
+        }
+        render() {
+            const kind = valuesBannerOf(valuesStateOf(this.dataSource), this._now$.value);
+            if (kind === 'none')
+                return nothing;
+            if (kind === 'slow') {
+                return html `<div
+        class="affine-database-values-banner"
+        data-kind="slow"
+        data-testid="database-values-loading"
+        role="status"
+      >
+        <span class="affine-database-values-banner-text"
+          >${translateKey(this.std, ...DATABASE_VALUES_LOADING)}</span
+        >
+      </div>`;
+            }
+            const canRetry = !!this.dataSource.retryValues;
+            return html `<div
+      class="affine-database-values-banner"
+      data-kind="error"
+      data-testid="database-values-error"
+      role="alert"
+    >
+      <span class="affine-database-values-banner-text"
+        >${translateKey(this.std, ...DATABASE_VALUES_ERROR)}</span
+      >
+      ${canRetry
+                ? html `<data-view-component-button
+            data-testid="database-values-retry"
+            hoverType="border"
+            .onClick="${this._retry}"
+            .text="${translateKey(this.std, ...RESOURCE_STATUS_RETRY)}"
+          ></data-view-component-button>`
+                : nothing}
+    </div>`;
+        }
+    };
+})();
+export { DatabaseValuesBanner };

package/dist/_pkgs/affine-block-database/configs/slash-menu.d.ts

@@ -1,2 +1,7 @@
-import { type SlashMenuConfig } from '../../affine-widget-slash-menu/index.js';
+import type { SlashMenuConfig } from '../../affine-widget-slash-menu/index.js';
+/**
+ * The slash entries that CREATE a database, registered by the gated
+ * `DatabaseViewExtension` only. No Calendar entry after 0.48 (ADR 0035 §6):
+ * a calendar is no longer created anywhere, a stored one still renders.
+ */
 export declare const databaseSlashMenuConfig: SlashMenuConfig;

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

@@ -1,11 +1,59 @@
 import { getSelectedModelsCommand } from '../../affine-shared/commands/index.js';
-import { TelemetryProvider } from '../../affine-shared/services/index.js';
+import { DataSourcePickerProvider, TelemetryProvider, } from '../../affine-shared/services/index.js';
 import { isInsideBlockByFlavour } from '../../affine-shared/utils/index.js';
-import {} from '../../affine-widget-slash-menu/index.js';
 import { viewPresets } from '../../data-view/view-presets/index.js';
-import { DatabaseKanbanViewIcon, DatabaseTableViewIcon, TodayIcon, } from '@blocksuite/icons/lit';
+import { DatabaseKanbanViewIcon, DatabaseTableViewIcon, } from '@blocksuite/icons/lit';
 import { insertDatabaseBlockCommand } from '../commands.js';
+import { createHostedDatabaseView } from '../linked-view.js';
 import { KanbanViewTooltip, TableViewTooltip } from './tooltips.js';
+/**
+ * With a data-source picker the host owns database creation (ADR 0035 §5):
+ * its `createDatabase` is the only way in, and without it no entry creates
+ * one. Without a picker, a native inline database, as in 0.48.
+ */
+function canCreateDatabase(std) {
+    const picker = std.getOptional(DataSourcePickerProvider);
+    return !picker || !!picker.createDatabase;
+}
+function createDatabaseAction(viewType) {
+    return ({ std }) => {
+        const picker = std.getOptional(DataSourcePickerProvider);
+        if (picker) {
+            const [, { selectedModels }] = std.command.exec(getSelectedModelsCommand);
+            const after = selectedModels?.at(-1);
+            if (!after)
+                return;
+            createHostedDatabaseView(std, picker, {
+                after,
+                viewType,
+                removeEmptyLine: true,
+            }).catch(console.error);
+            return;
+        }
+        std.command
+            .chain()
+            .pipe(getSelectedModelsCommand)
+            .pipe(insertDatabaseBlockCommand, {
+            viewType,
+            place: 'after',
+            removeEmptyLine: true,
+        })
+            .pipe(({ insertedDatabaseBlockId }) => {
+            if (insertedDatabaseBlockId) {
+                const telemetry = std.getOptional(TelemetryProvider);
+                telemetry?.track('BlockCreated', {
+                    blockType: 'affine:database',
+                });
+            }
+        })
+            .run();
+    };
+}
+/**
+ * The slash entries that CREATE a database, registered by the gated
+ * `DatabaseViewExtension` only. No Calendar entry after 0.48 (ADR 0035 §6):
+ * a calendar is no longer created anywhere, a stored one still renders.
+ */
 export const databaseSlashMenuConfig = {
     disableWhen: ({ model }) => model.flavour === 'affine:database',
     items: [
@@ -19,53 +67,9 @@ export const databaseSlashMenuConfig = {
                 caption: 'Table View',
             },
             group: '7_Database@0',
-            when: ({ model }) => !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text'),
-            action: ({ std }) => {
-                std.command
-                    .chain()
-                    .pipe(getSelectedModelsCommand)
-                    .pipe(insertDatabaseBlockCommand, {
-                    viewType: viewPresets.tableViewMeta.type,
-                    place: 'after',
-                    removeEmptyLine: true,
-                })
-                    .pipe(({ insertedDatabaseBlockId }) => {
-                    if (insertedDatabaseBlockId) {
-                        const telemetry = std.getOptional(TelemetryProvider);
-                        telemetry?.track('BlockCreated', {
-                            blockType: 'affine:database',
-                        });
-                    }
-                })
-                    .run();
-            },
-        },
-        {
-            name: 'Calendar View',
-            description: 'Display items by date in a calendar.',
-            searchAlias: ['database', 'calendar'],
-            icon: TodayIcon(),
-            group: '7_Database@1',
-            when: ({ model }) => !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text'),
-            action: ({ std }) => {
-                std.command
-                    .chain()
-                    .pipe(getSelectedModelsCommand)
-                    .pipe(insertDatabaseBlockCommand, {
-                    viewType: viewPresets.calendarViewMeta.type,
-                    place: 'after',
-                    removeEmptyLine: true,
-                })
-                    .pipe(({ insertedDatabaseBlockId }) => {
-                    if (insertedDatabaseBlockId) {
-                        const telemetry = std.getOptional(TelemetryProvider);
-                        telemetry?.track('BlockCreated', {
-                            blockType: 'affine:database',
-                        });
-                    }
-                })
-                    .run();
-            },
+            when: ({ model, std }) => !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text') &&
+                canCreateDatabase(std),
+            action: createDatabaseAction(viewPresets.tableViewMeta.type),
         },
         {
             name: 'Kanban View',
@@ -77,26 +81,9 @@ export const databaseSlashMenuConfig = {
                 caption: 'Kanban View',
             },
             group: '7_Database@2',
-            when: ({ model }) => !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text'),
-            action: ({ std }) => {
-                std.command
-                    .chain()
-                    .pipe(getSelectedModelsCommand)
-                    .pipe(insertDatabaseBlockCommand, {
-                    viewType: viewPresets.kanbanViewMeta.type,
-                    place: 'after',
-                    removeEmptyLine: true,
-                })
-                    .pipe(({ insertedDatabaseBlockId }) => {
-                    if (insertedDatabaseBlockId) {
-                        const telemetry = std.getOptional(TelemetryProvider);
-                        telemetry?.track('BlockCreated', {
-                            blockType: 'affine:database',
-                        });
-                    }
-                })
-                    .run();
-            },
+            when: ({ model, std }) => !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text') &&
+                canCreateDatabase(std),
+            action: createDatabaseAction(viewPresets.kanbanViewMeta.type),
         },
     ],
 };

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

@@ -1,19 +1,19 @@
 import type { ColumnDataType, DatabaseBlockModel } from '../affine-model/index.js';
 import { type InsertToPosition } from '../affine-shared/utils/index.js';
 import { type PropertyMetaConfig, type TypeInstance } from '../data-view/index.js';
-import type { EditorHost } from '../std/index.js';
-import { ExternalDataSourceBase } from './external-data-source.js';
+import type { BlockStdScope, EditorHost } from '../std/index.js';
+import { HostedDataSourceBase } from './external-data-source.js';
 type SpacialProperty = {
     valueSet: (rowId: string, propertyId: string, value: unknown) => void;
     valueGet: (rowId: string, propertyId: string) => unknown;
 };
 /**
  * The inline blob source: rows are the block's children, cells/columns live in
- * the model blob. It implements the {@link ExternalDataSourceBase} data
+ * the model blob. It implements the {@link HostedDataSourceBase} data
  * contract by reading blocksuite signals directly, so it never needs to bump
  * `revision` — reactivity is automatic.
  */
-export declare class DatabaseBlockDataSource extends ExternalDataSourceBase {
+export declare class DatabaseBlockDataSource extends HostedDataSourceBase {
     spacialProperties: Record<string, SpacialProperty>;
     isSpacialProperty(propertyType: string): boolean;
     spacialValueGet(rowId: string, propertyId: string, propertyType: string): unknown;
@@ -79,6 +79,10 @@ export declare class DatabaseBlockDataSource extends ExternalDataSourceBase {
     rowDelete(ids: string[]): void;
     rowMove(rowId: string, position: InsertToPosition): void;
 }
-export declare const databaseViewInitTemplate: (datasource: DatabaseBlockDataSource, viewType: string) => void;
+/**
+ * `std` names the first view in the author's language (`viewDefaultName`),
+ * at the gesture; absent, the preset's English name, as in 0.48.
+ */
+export declare const databaseViewInitTemplate: (datasource: DatabaseBlockDataSource, viewType: string, std?: BlockStdScope) => void;
 export declare const convertToDatabase: (host: EditorHost, viewType: string) => void;
 export {};

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

@@ -1,20 +1,20 @@
 import { getSelectedModelsCommand } from '../affine-shared/commands/index.js';
 import { insertPositionToIndex, } from '../affine-shared/utils/index.js';
-import {} from '../data-view/index.js';
+import { viewDefaultName, } from '../data-view/index.js';
 import { propertyPresets } from '../data-view/property-presets/index.js';
 import {} from '../store/index.js';
 import { computed, signal } from '@preact/signals-core';
 import { getIcon } from './block-icons.js';
-import { ExternalDataSourceBase } from './external-data-source.js';
+import { HostedDataSourceBase } from './external-data-source.js';
 import { databaseBlockProperties, databasePropertyConverts, } from './properties/index.js';
 import { addProperty, copyCellsByProperty, deleteRows, getCell, getProperty, updateCell, updateCells, updateProperty, } from './utils/block-utils.js';
 /**
  * The inline blob source: rows are the block's children, cells/columns live in
- * the model blob. It implements the {@link ExternalDataSourceBase} data
+ * the model blob. It implements the {@link HostedDataSourceBase} data
  * contract by reading blocksuite signals directly, so it never needs to bump
  * `revision` — reactivity is automatic.
  */
-export class DatabaseBlockDataSource extends ExternalDataSourceBase {
+export class DatabaseBlockDataSource extends HostedDataSourceBase {
     isSpacialProperty(propertyType) {
         return this.spacialProperties[propertyType] !== undefined;
     }
@@ -393,11 +393,15 @@ export class DatabaseBlockDataSource extends ExternalDataSourceBase {
         }
     }
 }
-export const databaseViewInitTemplate = (datasource, viewType) => {
+/**
+ * `std` names the first view in the author's language (`viewDefaultName`),
+ * at the gesture; absent, the preset's English name, as in 0.48.
+ */
+export const databaseViewInitTemplate = (datasource, viewType, std) => {
     Array.from({ length: 3 }).forEach(() => {
         datasource.rowAdd('end');
     });
-    datasource.viewManager.viewAdd(viewType);
+    datasource.viewManager.viewAdd(viewType, viewDefaultName(datasource.viewMetaGet(viewType), std));
 };
 export const convertToDatabase = (host, viewType) => {
     const [_, ctx] = host.std.command.exec(getSelectedModelsCommand, {
@@ -418,7 +422,7 @@ export const convertToDatabase = (host, viewType) => {
         return;
     }
     const datasource = new DatabaseBlockDataSource(databaseModel);
-    datasource.viewManager.viewAdd(viewType);
+    datasource.viewManager.viewAdd(viewType, viewDefaultName(datasource.viewMetaGet(viewType), host.std));
     host.store.moveBlocks(selectedModels, databaseModel);
     const selectionManager = host.selection;
     selectionManager.clear();

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

@@ -8,3 +8,5 @@ export declare const databaseTitleRowStyles: string;
 export declare const databaseToolbarRowStyles: string;
 export declare const databaseViewBarContainerStyles: string;
 export declare const databaseContentStyles: string;
+export declare const databaseSourceMissingStyles: string;
+export declare const databaseSourceMissingHintStyles: string;

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

@@ -60,3 +60,18 @@ export const databaseContentStyles = css({
     backgroundColor: 'var(--affine-background-primary-color)',
     borderRadius: '4px',
 });
+export const databaseSourceMissingStyles = css({
+    display: 'flex',
+    flexDirection: 'column',
+    gap: '4px',
+    margin: '8px 0',
+    padding: '12px',
+    borderRadius: '8px',
+    fontSize: '14px',
+    lineHeight: '22px',
+    color: 'var(--affine-text-primary-color)',
+    backgroundColor: 'var(--affine-hover-color)',
+});
+export const databaseSourceMissingHintStyles = css({
+    color: 'var(--affine-text-secondary-color)',
+});