@formicoidea/labre-core 0.26.1 → 0.28.0

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

@@ -1,19 +1,24 @@
 import type { ColumnDataType, DatabaseBlockModel } from '../affine-model/index.js';
 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 { type PropertyMetaConfig, type TypeInstance } from '../data-view/index.js';
 import type { EditorHost } from '../std/index.js';
-import { type ReadonlySignal } from '@preact/signals-core';
+import { ExternalDataSourceBase } from './external-data-source.js';
 type SpacialProperty = {
     valueSet: (rowId: string, propertyId: string, value: unknown) => void;
     valueGet: (rowId: string, propertyId: string) => unknown;
 };
-export declare class DatabaseBlockDataSource extends DataSourceBase {
-    get parentProvider(): import("../global/di/provider.js").ServiceProvider;
+/**
+ * The inline blob source: rows are the block's children, cells/columns live in
+ * the model blob. It implements the {@link ExternalDataSourceBase} data
+ * contract by reading blocksuite signals directly, so it never needs to bump
+ * `revision` — reactivity is automatic.
+ */
+export declare class DatabaseBlockDataSource extends ExternalDataSourceBase {
     spacialProperties: Record<string, SpacialProperty>;
     isSpacialProperty(propertyType: string): boolean;
     spacialValueGet(rowId: string, propertyId: string, propertyType: string): unknown;
     static externalProperties: import("@preact/signals-core").Signal<PropertyMetaConfig[]>;
-    static propertiesList: ReadonlySignal<(PropertyMetaConfig | PropertyMetaConfig<"checkbox", {}, boolean, boolean> | PropertyMetaConfig<"date", {}, number | null, number | null> | PropertyMetaConfig<"image", {}, string | null, string | null> | PropertyMetaConfig<"multi-select", {
+    static propertiesList: import("@preact/signals-core").ReadonlySignal<(PropertyMetaConfig | PropertyMetaConfig<"checkbox", {}, boolean, boolean> | PropertyMetaConfig<"date", {}, number | null, number | null> | PropertyMetaConfig<"image", {}, string | null, string | null> | PropertyMetaConfig<"multi-select", {
         options: {
             id: string;
             value: string;
@@ -28,68 +33,51 @@ export declare class DatabaseBlockDataSource extends DataSourceBase {
             value: string;
             color: string;
         }[];
-    }, string | null, string | null> | PropertyMetaConfig<"link", {}, string, string> | PropertyMetaConfig<"rich-text", {}, import("./properties/rich-text/define.js").RichTextCellType | undefined, string> | PropertyMetaConfig<"title", {}, import("../store/index.js").Text<{
+    }, string | null, string | null> | PropertyMetaConfig<"created-time", {}, number | null, number | null> | PropertyMetaConfig<"link", {}, string, string> | PropertyMetaConfig<"rich-text", {}, import("./properties/rich-text/define.js").RichTextCellType | undefined, string> | PropertyMetaConfig<"title", {}, import("../store/index.js").Text<{
         bold?: true | null | undefined;
         link?: string | null | undefined;
         strike?: true | null | undefined;
         code?: true | null | undefined;
         italic?: true | null | undefined;
         underline?: true | null | undefined;
-    }> | undefined, string> | PropertyMetaConfig<"created-time", {}, number | null, number | null>)[]>;
-    static propertiesMap: ReadonlySignal<{
+    }> | undefined, string>)[]>;
+    static propertiesMap: import("@preact/signals-core").ReadonlySignal<{
         [k: string]: PropertyMetaConfig;
     }>;
     private _batch;
-    private readonly _model;
-    featureFlags$: ReadonlySignal<DatabaseFlags>;
-    properties$: ReadonlySignal<string[]>;
-    readonly$: ReadonlySignal<boolean>;
-    rows$: ReadonlySignal<string[]>;
-    viewConverts: import("./index.js").ViewConvertConfig[];
-    viewDataList$: ReadonlySignal<DataViewDataType[]>;
-    viewManager: ViewManager;
-    viewMetas: ViewMeta[];
-    get doc(): import("../store/index.js").Store;
-    allPropertyMetas$: ReadonlySignal<PropertyMetaConfig<any, any, any, any>[]>;
-    propertyMetas$: ReadonlySignal<PropertyMetaConfig[]>;
     constructor(model: DatabaseBlockModel, init?: (dataSource: DatabaseBlockDataSource) => void);
     private _runCapture;
     private getModelById;
     private newPropertyName;
-    cellValueChange(rowId: string, propertyId: string, value: unknown): void;
-    cellValueGet(rowId: string, propertyId: string): unknown;
-    propertyAdd(insertToPosition: InsertToPosition, ops?: {
-        type?: string;
-        name?: string;
-    }): string | undefined;
+    protected getRows(): string[];
+    protected getProperties(): string[];
+    protected getPropertyMetas(): PropertyMetaConfig[];
+    protected getCellValue(rowId: string, propertyId: string): unknown;
     protected getNormalPropertyAndIndex(propertyId: string): {
         column: ColumnDataType<Record<string, unknown>>;
         index: number;
     } | undefined;
     private getPropertyAndIndex;
+    protected getPropertyData(propertyId: string): Record<string, unknown>;
+    protected getPropertyDataType(propertyId: string): TypeInstance | undefined;
+    protected getPropertyName(propertyId: string): string;
+    protected getPropertyType(propertyId: string): string | undefined;
+    propertyReadonlyGet(propertyId: string): boolean;
+    propertyMetaGet(type: string): PropertyMetaConfig | undefined;
     private updateProperty;
-    propertyDataGet(propertyId: string): Record<string, unknown>;
+    cellValueChange(rowId: string, propertyId: string, value: unknown): void;
+    propertyAdd(insertToPosition: InsertToPosition, ops?: {
+        type?: string;
+        name?: string;
+    }): string | undefined;
     propertyDataSet(propertyId: string, data: Record<string, unknown>): void;
-    propertyDataTypeGet(propertyId: string): TypeInstance | undefined;
     propertyDelete(id: string): void;
     propertyDuplicate(propertyId: string): string | undefined;
-    propertyMetaGet(type: string): PropertyMetaConfig | undefined;
-    propertyNameGet(propertyId: string): string;
     propertyNameSet(propertyId: string, name: string): void;
-    propertyReadonlyGet(propertyId: string): boolean;
-    propertyTypeGet(propertyId: string): string | undefined;
     propertyTypeSet(propertyId: string, toType: string): void;
     rowAdd(insertPosition: InsertToPosition | number): string;
     rowDelete(ids: string[]): void;
     rowMove(rowId: string, position: InsertToPosition): void;
-    viewDataAdd(viewData: DataViewDataType): string;
-    viewDataDelete(viewId: string): void;
-    viewDataDuplicate(id: string): string;
-    viewDataGet(viewId: string): DataViewDataType | undefined;
-    viewDataMoveTo(id: string, position: InsertToPosition): void;
-    viewDataUpdate<ViewData extends DataViewDataType>(id: string, updater: (data: ViewData) => Partial<ViewData>): void;
-    viewMetaGet(type: string): ViewMeta;
-    viewMetaGetById(viewId: string): ViewMeta | undefined;
 }
 export declare const databaseViewInitTemplate: (datasource: DatabaseBlockDataSource, viewType: string) => void;
 export declare const convertToDatabase: (host: EditorHost, viewType: string) => void;

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

@@ -1,20 +1,20 @@
 import { getSelectedModelsCommand } from '../affine-shared/commands/index.js';
-import { FeatureFlagService } from '../affine-shared/services/index.js';
 import { insertPositionToIndex, } from '../affine-shared/utils/index.js';
-import { DataSourceBase, ViewManagerBase, } from '../data-view/index.js';
+import {} from '../data-view/index.js';
 import { propertyPresets } from '../data-view/property-presets/index.js';
-import { IS_MOBILE } from '../global/env/index.js';
-import { BlockSuiteError, ErrorCode } from '../global/exceptions/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 { databaseBlockProperties, databasePropertyConverts, } from './properties/index.js';
-import { addProperty, copyCellsByProperty, deleteRows, deleteView, duplicateView, getCell, getProperty, moveViewTo, updateCell, updateCells, updateProperty, updateView, } from './utils/block-utils.js';
-import { databaseBlockViewConverts, databaseBlockViewMap, databaseBlockViews, } from './views/index.js';
-export class DatabaseBlockDataSource extends DataSourceBase {
-    get parentProvider() {
-        return this._model.store.provider;
-    }
+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
+ * contract by reading blocksuite signals directly, so it never needs to bump
+ * `revision` — reactivity is automatic.
+ */
+export class DatabaseBlockDataSource extends ExternalDataSourceBase {
     isSpacialProperty(propertyType) {
         return this.spacialProperties[propertyType] !== undefined;
     }
@@ -31,11 +31,8 @@ export class DatabaseBlockDataSource extends DataSourceBase {
     static { this.propertiesMap = computed(() => {
         return Object.fromEntries(this.propertiesList.value.map(v => [v.type, v]));
     }); }
-    get doc() {
-        return this._model.store;
-    }
     constructor(model, init) {
-        super();
+        super(model);
         this.spacialProperties = {
             'created-time': {
                 valueSet: () => { },
@@ -76,49 +73,7 @@ export class DatabaseBlockDataSource extends DataSourceBase {
             },
         };
         this._batch = 0;
-        this.featureFlags$ = computed(() => {
-            const featureFlagService = this.doc.get(FeatureFlagService);
-            const enableNumberFormat = featureFlagService.getFlag('enable_database_number_formatting');
-            const enableTableVirtualScroll = featureFlagService.getFlag('enable_table_virtual_scroll');
-            return {
-                enable_number_formatting: enableNumberFormat ?? false,
-                enable_table_virtual_scroll: enableTableVirtualScroll ?? false,
-            };
-        });
-        this.properties$ = computed(() => {
-            const fixedPropertiesSet = new Set(this.fixedProperties$.value);
-            const properties = [];
-            this._model.props.columns$.value.forEach(column => {
-                if (fixedPropertiesSet.has(column.type)) {
-                    fixedPropertiesSet.delete(column.type);
-                }
-                properties.push(column.id);
-            });
-            const result = [...fixedPropertiesSet, ...properties];
-            return result;
-        });
-        this.readonly$ = computed(() => {
-            return (this._model.store.readonly ||
-                // TODO(@L-Sun): use block level readonly
-                IS_MOBILE);
-        });
-        this.rows$ = computed(() => {
-            return this._model.children.map(v => v.id);
-        });
-        this.viewConverts = databaseBlockViewConverts;
-        this.viewDataList$ = computed(() => {
-            return this._model.props.views$.value;
-        });
-        this.viewManager = new ViewManagerBase(this);
-        this.viewMetas = databaseBlockViews;
-        this.allPropertyMetas$ = computed(() => {
-            return DatabaseBlockDataSource.propertiesList.value;
-        });
-        this.propertyMetas$ = computed(() => {
-            return this.allPropertyMetas$.value.filter(v => !v.config.fixed && !v.config.hide);
-        });
-        this._model = model; // ensure invariants first
-        init?.(this); // then allow external initialisation
+        init?.(this); // allow external initialisation
     }
     _runCapture() {
         if (this._batch) {
@@ -145,34 +100,26 @@ export class DatabaseBlockDataSource extends DataSourceBase {
             i++;
         }
     }
-    cellValueChange(rowId, propertyId, value) {
-        this._runCapture();
-        const type = this.propertyTypeGet(propertyId);
-        if (type == null) {
-            return;
-        }
-        const update = this.propertyMetaGet(type)?.config.rawValue.setValue;
-        const old = this.cellValueGet(rowId, propertyId);
-        const updateFn = update ??
-            (({ setValue, newValue }) => {
-                setValue(newValue);
-            });
-        updateFn({
-            value: old,
-            data: this.propertyDataGet(propertyId),
-            dataSource: this,
-            newValue: value,
-            setValue: newValue => {
-                if (this._model.props.columns$.value.some(v => v.id === propertyId)) {
-                    updateCell(this._model, rowId, {
-                        columnId: propertyId,
-                        value: newValue,
-                    });
-                }
-            },
+    // --- data contract (read) ------------------------------------------------
+    getRows() {
+        return this._model.children.map(v => v.id);
+    }
+    getProperties() {
+        const fixedPropertiesSet = new Set(this.fixedProperties$.value);
+        const properties = [];
+        this._model.props.columns$.value.forEach(column => {
+            if (fixedPropertiesSet.has(column.type)) {
+                fixedPropertiesSet.delete(column.type);
+            }
+            properties.push(column.id);
         });
+        return [...fixedPropertiesSet, ...properties];
+    }
+    getPropertyMetas() {
+        return DatabaseBlockDataSource.propertiesList
+            .value;
     }
-    cellValueGet(rowId, propertyId) {
+    getCellValue(rowId, propertyId) {
         if (this.isSpacialProperty(propertyId)) {
             return this.spacialValueGet(rowId, propertyId, propertyId);
         }
@@ -196,16 +143,6 @@ export class DatabaseBlockDataSource extends DataSourceBase {
         }
         return;
     }
-    propertyAdd(insertToPosition, ops) {
-        this.doc.captureSync();
-        const { type, name } = ops ?? {};
-        const property = this.propertyMetaGet(type ?? propertyPresets.multiSelectPropertyConfig.type);
-        if (!property) {
-            return;
-        }
-        const result = addProperty(this._model, insertToPosition, property.create(this.newPropertyName(name)));
-        return result;
-    }
     getNormalPropertyAndIndex(propertyId) {
         const index = this._model.props.columns$.value.findIndex(v => v.id === propertyId);
         if (index >= 0) {
@@ -243,6 +180,57 @@ export class DatabaseBlockDataSource extends DataSourceBase {
         }
         return undefined;
     }
+    getPropertyData(propertyId) {
+        const result = this.getPropertyAndIndex(propertyId);
+        if (!result) {
+            return {};
+        }
+        return result.column.data;
+    }
+    getPropertyDataType(propertyId) {
+        const result = this.getPropertyAndIndex(propertyId);
+        if (!result) {
+            return;
+        }
+        const { column } = result;
+        const meta = this.propertyMetaGet(column.type);
+        if (!meta) {
+            return;
+        }
+        return meta.config?.jsonValue.type({
+            data: column.data,
+            dataSource: this,
+        });
+    }
+    getPropertyName(propertyId) {
+        if (propertyId === 'type') {
+            return 'Block Type';
+        }
+        const result = this.getPropertyAndIndex(propertyId);
+        if (!result) {
+            return '';
+        }
+        return result.column.name;
+    }
+    getPropertyType(propertyId) {
+        if (propertyId === 'type') {
+            return 'image';
+        }
+        const result = this.getPropertyAndIndex(propertyId);
+        if (!result) {
+            return;
+        }
+        return result.column.type;
+    }
+    propertyReadonlyGet(propertyId) {
+        if (propertyId === 'type')
+            return true;
+        return false;
+    }
+    propertyMetaGet(type) {
+        return DatabaseBlockDataSource.propertiesMap.value[type];
+    }
+    // --- data contract (mutations) ------------------------------------------
     updateProperty(id, updater) {
         const result = this.getPropertyAndIndex(id);
         if (!result) {
@@ -264,32 +252,47 @@ export class DatabaseBlockDataSource extends DataSourceBase {
         });
         return id;
     }
-    propertyDataGet(propertyId) {
-        const result = this.getPropertyAndIndex(propertyId);
-        if (!result) {
-            return {};
-        }
-        return result.column.data;
-    }
-    propertyDataSet(propertyId, data) {
+    cellValueChange(rowId, propertyId, value) {
         this._runCapture();
-        this.updateProperty(propertyId, () => ({ data }));
-    }
-    propertyDataTypeGet(propertyId) {
-        const result = this.getPropertyAndIndex(propertyId);
-        if (!result) {
-            return;
-        }
-        const { column } = result;
-        const meta = this.propertyMetaGet(column.type);
-        if (!meta) {
+        const type = this.propertyTypeGet(propertyId);
+        if (type == null) {
             return;
         }
-        return meta.config?.jsonValue.type({
-            data: column.data,
+        const update = this.propertyMetaGet(type)?.config.rawValue.setValue;
+        const old = this.cellValueGet(rowId, propertyId);
+        const updateFn = update ??
+            (({ setValue, newValue }) => {
+                setValue(newValue);
+            });
+        updateFn({
+            value: old,
+            data: this.propertyDataGet(propertyId),
             dataSource: this,
+            newValue: value,
+            setValue: newValue => {
+                if (this._model.props.columns$.value.some(v => v.id === propertyId)) {
+                    updateCell(this._model, rowId, {
+                        columnId: propertyId,
+                        value: newValue,
+                    });
+                }
+            },
         });
     }
+    propertyAdd(insertToPosition, ops) {
+        this.doc.captureSync();
+        const { type, name } = ops ?? {};
+        const property = this.propertyMetaGet(type ?? propertyPresets.multiSelectPropertyConfig.type);
+        if (!property) {
+            return;
+        }
+        const result = addProperty(this._model, insertToPosition, property.create(this.newPropertyName(name)));
+        return result;
+    }
+    propertyDataSet(propertyId, data) {
+        this._runCapture();
+        this.updateProperty(propertyId, () => ({ data }));
+    }
     propertyDelete(id) {
         if (this.isFixedProperty(id)) {
             return;
@@ -325,38 +328,10 @@ export class DatabaseBlockDataSource extends DataSourceBase {
         copyCellsByProperty(this._model, copyId, id);
         return id;
     }
-    propertyMetaGet(type) {
-        return DatabaseBlockDataSource.propertiesMap.value[type];
-    }
-    propertyNameGet(propertyId) {
-        if (propertyId === 'type') {
-            return 'Block Type';
-        }
-        const result = this.getPropertyAndIndex(propertyId);
-        if (!result) {
-            return '';
-        }
-        return result.column.name;
-    }
     propertyNameSet(propertyId, name) {
         this.doc.captureSync();
         this.updateProperty(propertyId, () => ({ name }));
     }
-    propertyReadonlyGet(propertyId) {
-        if (propertyId === 'type')
-            return true;
-        return false;
-    }
-    propertyTypeGet(propertyId) {
-        if (propertyId === 'type') {
-            return 'image';
-        }
-        const result = this.getPropertyAndIndex(propertyId);
-        if (!result) {
-            return;
-        }
-        return result.column.type;
-    }
     propertyTypeSet(propertyId, toType) {
         if (this.isFixedProperty(propertyId)) {
             return;
@@ -418,43 +393,6 @@ export class DatabaseBlockDataSource extends DataSourceBase {
             this.doc.moveBlocks([model], this._model, target);
         }
     }
-    viewDataAdd(viewData) {
-        this._model.store.captureSync();
-        this._model.store.transact(() => {
-            this._model.props.views = [...this._model.props.views, viewData];
-        });
-        return viewData.id;
-    }
-    viewDataDelete(viewId) {
-        this._model.store.captureSync();
-        deleteView(this._model, viewId);
-    }
-    viewDataDuplicate(id) {
-        return duplicateView(this._model, id);
-    }
-    viewDataGet(viewId) {
-        return this.viewDataList$.value.find(data => data.id === viewId);
-    }
-    viewDataMoveTo(id, position) {
-        moveViewTo(this._model, id, position);
-    }
-    viewDataUpdate(id, updater) {
-        updateView(this._model, id, updater);
-    }
-    viewMetaGet(type) {
-        const view = databaseBlockViewMap[type];
-        if (!view) {
-            throw new BlockSuiteError(ErrorCode.DatabaseBlockError, `Unknown view type: ${type}`);
-        }
-        return view;
-    }
-    viewMetaGetById(viewId) {
-        const view = this.viewDataGet(viewId);
-        if (!view) {
-            return;
-        }
-        return this.viewMetaGet(view.mode);
-    }
 }
 export const databaseViewInitTemplate = (datasource, viewType) => {
     Array.from({ length: 3 }).forEach(() => {

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

@@ -1,12 +1,17 @@
 import { CaptionedBlockComponent } from '../affine-components/caption/index.js';
 import { DropIndicator } from '../affine-components/drop-indicator/index.js';
 import type { DatabaseBlockModel } from '../affine-model/index.js';
-import { type DataViewWidget, type SingleView } from '../data-view/index.js';
+import { type DataSourceBase, type DataViewWidget, type SingleView } from '../data-view/index.js';
 import { type BlockComponent } from '../std/index.js';
 import type { DatabaseViewExtensionOptions } from './view';
 export declare class DatabaseBlockComponent extends CaptionedBlockComponent<DatabaseBlockModel> {
     private readonly clickDatabaseOps;
-    private readonly dataSource;
+    private _dataSource?;
+    private _dataViewRootLogic?;
+    private _sourceVersion;
+    private _buildDataSource;
+    get dataSource(): DataSourceBase;
+    private rebuildDataSource;
     private readonly renderTitle;
     createTemplate: (data: {
         view: SingleView;
@@ -24,8 +29,10 @@ export declare class DatabaseBlockComponent extends CaptionedBlockComponent<Data
     get topContenteditableElement(): BlockComponent<import("../store/index.js").BlockModel<object>, import("../std/index.js").BlockService, string> | null;
     private renderDatabaseOps;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     listenFullWidthChange(): void;
-    private readonly dataViewRootLogic;
+    private get dataViewRootLogic();
+    private _buildDataViewRootLogic;
     renderBlock(): import("lit-html").TemplateResult<1>;
     accessor useZeroWidth: boolean;
 }