@formicoidea/labre-core 0.47.1 → 0.49.0

package/dist/_pkgs/data-view/core/property/standalone-cell.js

@@ -0,0 +1,324 @@
+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 { createIdentifier, } from '../../../global/di/index.js';
+import { SignalWatcher, WithDisposable } from '../../../global/lit/index.js';
+import { ShadowlessElement } from '../../../std/index.js';
+import { computed, signal } from '@preact/signals-core';
+import { css, html, nothing, unsafeCSS } from 'lit';
+import { property } from 'lit/decorators.js';
+import { dataViewCssVariable } from '../common/css-variable.js';
+import { renderUniLit } from '../utils/uni-component/uni-component.js';
+const NO_FLAGS = signal({
+    enable_number_formatting: false,
+    enable_table_virtual_scroll: false,
+});
+function isEmptyValue(value) {
+    if (value == null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}
+class StandaloneCell {
+    get propertyId() {
+        return this._source.propertyId;
+    }
+    get rowId() {
+        return this._source.propertyId;
+    }
+    get row() {
+        throw new Error('A standalone cell has no row.');
+    }
+    constructor(meta, _source) {
+        this._source = _source;
+        const source = _source;
+        const view = {
+            readonly$: source.readonly$,
+            featureFlags$: source.featureFlags$ ?? NO_FLAGS,
+            serviceGet: (key) => source.serviceGet?.(key) ?? null,
+        };
+        // The whole seam is these three members, held by the spec named above.
+        this.view = view;
+        const type$ = signal(meta.type);
+        const property = {
+            id: source.propertyId,
+            name$: source.name$,
+            data$: source.data$,
+            type$,
+            readonly$: source.readonly$,
+            meta$: signal(meta),
+            renderer$: signal(meta.renderer.cellRenderer),
+            dataCanSet: !!source.dataSet,
+            optionEdits: source.optionEdits,
+            dataUpdate: (updater) => {
+                if (!source.dataSet)
+                    return;
+                const data = source.data$.peek();
+                source.dataSet({ ...data, ...updater(data) });
+            },
+        };
+        this.property = property;
+        this.value$ = source.value$;
+        this.jsonValue$ = source.value$;
+        this.isEmpty$ = computed(() => isEmptyValue(source.value$.value));
+        this.stringValue$ = computed(() => {
+            const value = source.value$.value;
+            if (value === undefined)
+                return undefined;
+            const toString = meta.config.rawValue.toString;
+            return toString({ value, data: source.data$.value });
+        });
+    }
+    valueSet(value) {
+        this._source.valueSet(value);
+    }
+    jsonValueSet(value) {
+        this._source.valueSet(value);
+    }
+}
+/** A `Cell` for one value outside any view, drawn with `meta`'s renderer. */
+export function createStandaloneCell(meta, source) {
+    return new StandaloneCell(meta, source);
+}
+/**
+ * A property type a standalone cell can be drawn with, registered by the
+ * package that owns its renderer when that package sits above the host: the
+ * database block registers its `link` cell, which the title band (a fragment
+ * the database block depends on) cannot import. The presets of this package
+ * need no registration; a host imports them.
+ */
+export const StandaloneCellMetaProvider = createIdentifier('DataViewStandaloneCellMeta');
+export function StandaloneCellMetaExtension(meta) {
+    // Erased the way a data source's property list erases its metas.
+    const erased = meta;
+    return {
+        setup: di => {
+            di.override(StandaloneCellMetaProvider(meta.type), () => erased);
+        },
+    };
+}
+/**
+ * The element that hosts a standalone cell: it mounts the cell renderer the
+ * way a table cell container does and owns the same edit lifecycle
+ * (`beforeEnterEditMode`, `afterEnterEditingMode`, `beforeExitEditingMode`),
+ * so a click, Enter or Space starts the renderer's own editor: the checkbox
+ * toggles, a select pops its tag menu, the date its picker, a text its input.
+ *
+ * Leaving: a popup editor (select, date) closes itself on a click away and
+ * calls `selectCurrentCell(false)`, as in the table; an editor drawn in place
+ * (an input inside this element) leaves when the focus does, Escape included.
+ * Either way the renderer's exit hook commits, exactly once.
+ */
+let StandaloneCellHost = (() => {
+    let _classSuper = SignalWatcher(WithDisposable(ShadowlessElement));
+    let _cell_decorators;
+    let _cell_initializers = [];
+    let _cell_extraInitializers = [];
+    let _placeholder_decorators;
+    let _placeholder_initializers = [];
+    let _placeholder_extraInitializers = [];
+    let _readonly_decorators;
+    let _readonly_initializers = [];
+    let _readonly_extraInitializers = [];
+    let _onEditingChange_decorators;
+    let _onEditingChange_initializers = [];
+    let _onEditingChange_extraInitializers = [];
+    return class StandaloneCellHost extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _cell_decorators = [property({ attribute: false })];
+            _placeholder_decorators = [property({ attribute: false })];
+            _readonly_decorators = [property({ attribute: false })];
+            _onEditingChange_decorators = [property({ attribute: false })];
+            __esDecorate(this, null, _cell_decorators, { kind: "accessor", name: "cell", static: false, private: false, access: { has: obj => "cell" in obj, get: obj => obj.cell, set: (obj, value) => { obj.cell = value; } }, metadata: _metadata }, _cell_initializers, _cell_extraInitializers);
+            __esDecorate(this, null, _placeholder_decorators, { kind: "accessor", name: "placeholder", static: false, private: false, access: { has: obj => "placeholder" in obj, get: obj => obj.placeholder, set: (obj, value) => { obj.placeholder = value; } }, metadata: _metadata }, _placeholder_initializers, _placeholder_extraInitializers);
+            __esDecorate(this, null, _readonly_decorators, { kind: "accessor", name: "readonly", static: false, private: false, access: { has: obj => "readonly" in obj, get: obj => obj.readonly, set: (obj, value) => { obj.readonly = value; } }, metadata: _metadata }, _readonly_initializers, _readonly_extraInitializers);
+            __esDecorate(this, null, _onEditingChange_decorators, { kind: "accessor", name: "onEditingChange", static: false, private: false, access: { has: obj => "onEditingChange" in obj, get: obj => obj.onEditingChange, set: (obj, value) => { obj.onEditingChange = value; } }, metadata: _metadata }, _onEditingChange_initializers, _onEditingChange_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static { this.styles = css `
+    dv-standalone-cell {
+      ${unsafeCSS(dataViewCssVariable())}
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
+      min-width: 0;
+      max-width: 100%;
+      outline: none;
+    }
+
+    dv-standalone-cell[data-editable='true'] {
+      cursor: pointer;
+    }
+
+    /* The record detail's editing ring (detail/field.ts). */
+    dv-standalone-cell[data-editing='true'] {
+      border-radius: 4px;
+      box-shadow: 0px 0px 0px 2px
+        color-mix(in srgb, var(--affine-primary-color) 30%, transparent);
+    }
+
+    .dv-standalone-cell-placeholder {
+      color: var(--affine-placeholder-color);
+      white-space: nowrap;
+    }
+  `; }
+        /** Opens the renderer's editor; a checkbox toggles instead. */
+        edit() {
+            if (this.readonly || this.isEditing$.peek())
+                return;
+            const cell = this._cell$.peek();
+            if (!cell?.beforeEnterEditMode())
+                return;
+            this.isEditing$.value = true;
+            this.onEditingChange?.(true);
+            requestAnimationFrame(() => {
+                if (this.isEditing$.peek())
+                    cell.afterEnterEditingMode();
+            });
+        }
+        /** Closes the editor; the renderer's exit hook commits its value. */
+        exit() {
+            // An exit hook may close a popup whose own close asks to exit again.
+            if (!this.isEditing$.peek() || this._exiting)
+                return;
+            this._exiting = true;
+            try {
+                this._cell$.peek()?.beforeExitEditingMode();
+            }
+            finally {
+                this._exiting = false;
+            }
+            this.isEditing$.value = false;
+            this.onEditingChange?.(false);
+        }
+        connectedCallback() {
+            super.connectedCallback();
+            this._disposables.addFromEvent(this, 'click', event => {
+                if (this.readonly)
+                    return;
+                event.stopPropagation();
+                this.edit();
+            });
+            this._disposables.addFromEvent(this, 'keydown', event => {
+                if (this.isEditing$.peek()) {
+                    if (event.key === 'Escape')
+                        this.exit();
+                    return;
+                }
+                if (event.target !== this)
+                    return;
+                if (event.key === 'Enter' || event.key === ' ') {
+                    event.preventDefault();
+                    this.edit();
+                }
+            });
+            this._disposables.addFromEvent(this, 'focusout', event => {
+                if (!this.isEditing$.peek())
+                    return;
+                const { target, relatedTarget } = event;
+                if (!(target instanceof HTMLInputElement) &&
+                    !(target instanceof HTMLTextAreaElement))
+                    return;
+                if (relatedTarget instanceof Node && this.contains(relatedTarget))
+                    return;
+                this.exit();
+            });
+            this._disposables.add(() => this.exit());
+        }
+        render() {
+            const view = this.cell.property.renderer$.value?.view;
+            if (!view)
+                return nothing;
+            this.dataset.editable = this.readonly ? 'false' : 'true';
+            this.dataset.editing = this.isEditing$.value ? 'true' : 'false';
+            if (this.readonly)
+                this.removeAttribute('tabindex');
+            else
+                this.tabIndex = 0;
+            const props = {
+                cell: this.cell,
+                isEditing$: this.isEditing$,
+                selectCurrentCell: this._selectCurrentCell,
+            };
+            const placeholder = this.placeholder && !this.isEditing$.value && this.cell.isEmpty$.value
+                ? html `<span class="dv-standalone-cell-placeholder"
+            >${this.placeholder}</span
+          >`
+                : nothing;
+            return html `${renderUniLit(view, props, { ref: this._cell$, style: { display: 'contents' } })}${placeholder}`;
+        }
+        #cell_accessor_storage;
+        get cell() { return this.#cell_accessor_storage; }
+        set cell(value) { this.#cell_accessor_storage = value; }
+        #placeholder_accessor_storage;
+        /** Drawn while the value is empty and no editor is open. */
+        get placeholder() { return this.#placeholder_accessor_storage; }
+        set placeholder(value) { this.#placeholder_accessor_storage = value; }
+        #readonly_accessor_storage;
+        /** Draws the value and opens no editor. */
+        get readonly() { return this.#readonly_accessor_storage; }
+        set readonly(value) { this.#readonly_accessor_storage = value; }
+        #onEditingChange_accessor_storage;
+        /**
+         * Told when the editor opens and closes. The gallery and list presets host
+         * a view's own cells here and lock the view's rows while one edits, as a
+         * table or kanban cell does (`view.lockRows`), so a value that changes the
+         * sort or the filter does not move or drop the row under the editor.
+         */
+        get onEditingChange() { return this.#onEditingChange_accessor_storage; }
+        set onEditingChange(value) { this.#onEditingChange_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            this._cell$ = signal();
+            this._exiting = false;
+            this.isEditing$ = signal(false);
+            this._selectCurrentCell = (editing) => {
+                if (editing)
+                    this.edit();
+                else
+                    this.exit();
+            };
+            this.#cell_accessor_storage = __runInitializers(this, _cell_initializers, void 0);
+            this.#placeholder_accessor_storage = (__runInitializers(this, _cell_extraInitializers), __runInitializers(this, _placeholder_initializers, ''));
+            this.#readonly_accessor_storage = (__runInitializers(this, _placeholder_extraInitializers), __runInitializers(this, _readonly_initializers, false));
+            this.#onEditingChange_accessor_storage = (__runInitializers(this, _readonly_extraInitializers), __runInitializers(this, _onEditingChange_initializers, undefined));
+            __runInitializers(this, _onEditingChange_extraInitializers);
+        }
+    };
+})();
+export { StandaloneCellHost };

package/dist/_pkgs/data-view/core/telemetry.d.ts

@@ -0,0 +1,16 @@
+import type { DatabaseAllEvents, DatabaseAllViewEvents, EventTraceFn } from '../../affine-shared/services/index.js';
+import type { SingleView } from './view-manager/single-view.js';
+/**
+ * The tracer a database host gives its data source (`serviceSet`), the same
+ * function it passes the root as `config.eventTrace`. It exists for the
+ * gestures whose code holds a view or a trait but no UI logic (the group-by
+ * menus build from a `GroupTrait`): they report through the view's source.
+ * Absent, nothing is reported (a standalone data view, a test).
+ */
+export declare const DataViewEventTraceKey: import("../../global/di/types.js").ServiceIdentifier<EventTraceFn<DatabaseAllEvents>> & (<U extends EventTraceFn<DatabaseAllEvents> = EventTraceFn<DatabaseAllEvents>>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Report a view-level event from code that only holds the view, with the
+ * same `viewId` / `viewType` params `DataViewUILogicBase.eventTrace` adds.
+ * Ids only (telemetry README, "Databases").
+ */
+export declare function traceViewEvent<K extends keyof DatabaseAllViewEvents>(view: SingleView, key: K, params: DatabaseAllViewEvents[K]): void;

package/dist/_pkgs/data-view/core/telemetry.js

@@ -0,0 +1,22 @@
+import { createIdentifier } from '../../global/di/index.js';
+/**
+ * The tracer a database host gives its data source (`serviceSet`), the same
+ * function it passes the root as `config.eventTrace`. It exists for the
+ * gestures whose code holds a view or a trait but no UI logic (the group-by
+ * menus build from a `GroupTrait`): they report through the view's source.
+ * Absent, nothing is reported (a standalone data view, a test).
+ */
+export const DataViewEventTraceKey = createIdentifier('data-view-event-trace');
+/**
+ * Report a view-level event from code that only holds the view, with the
+ * same `viewId` / `viewType` params `DataViewUILogicBase.eventTrace` adds.
+ * Ids only (telemetry README, "Databases").
+ */
+export function traceViewEvent(view, key, params) {
+    const trace = view.manager.dataSource.serviceGet(DataViewEventTraceKey);
+    trace?.(key, {
+        ...params,
+        viewId: view.id,
+        viewType: view.type,
+    });
+}

package/dist/_pkgs/data-view/core/utils/new-tab-click.d.ts

@@ -0,0 +1,2 @@
+/** A click that asks for a new tab: Ctrl on Windows and Linux, Cmd on macOS. */
+export declare function isNewTabClick(event: Pick<MouseEvent, 'ctrlKey' | 'metaKey'>): boolean;

package/dist/_pkgs/data-view/core/utils/new-tab-click.js

@@ -0,0 +1,4 @@
+/** A click that asks for a new tab: Ctrl on Windows and Linux, Cmd on macOS. */
+export function isNewTabClick(event) {
+    return event.ctrlKey || event.metaKey;
+}

package/dist/_pkgs/data-view/core/utils/wording.d.ts

@@ -0,0 +1,11 @@
+import { type ChromeWording } from '../../../affine-shared/services/index.js';
+import type { BlockStdScope } from '../../../std/index.js';
+export type Wording = (wording: ChromeWording) => string;
+/**
+ * Resolve the data-view's wordings through the translation seam when an
+ * editor is there (`stdContext`), in English otherwise (a unit test, a
+ * standalone mount). A popup renders outside the host, so its opener
+ * resolves the words and hands this function down.
+ */
+export declare const wordingOf: (std: BlockStdScope | undefined) => Wording;
+export declare const englishWording: Wording;

package/dist/_pkgs/data-view/core/utils/wording.js

@@ -0,0 +1,9 @@
+import { translateKey, } from '../../../affine-shared/services/index.js';
+/**
+ * Resolve the data-view's wordings through the translation seam when an
+ * editor is there (`stdContext`), in English otherwise (a unit test, a
+ * standalone mount). A popup renders outside the host, so its opener
+ * resolves the words and hands this function down.
+ */
+export const wordingOf = (std) => ([key, fallback]) => std ? translateKey(std, key, fallback) : fallback;
+export const englishWording = ([, fallback]) => fallback;

package/dist/_pkgs/data-view/core/view/data-view.d.ts

@@ -14,7 +14,14 @@ export type DefaultViewDataType = BasicViewDataType & {
 export type DataViewDataType = DefaultViewDataType;
 export type DataViewMode = string;
 export interface DataViewModelConfig<Data extends DataViewDataType = DataViewDataType> {
+    /**
+     * The English name a new view of this preset is given, and the fallback of
+     * {@link defaultNameKey}. A seed: never translated in place, the creation
+     * site writes the resolved name (`viewDefaultName`).
+     */
     defaultName: string;
+    /** The `com.labre.*` key of {@link defaultName}; absent, it is shown as is. */
+    defaultNameKey?: string;
     dataViewManager: new (viewManager: ViewManager, viewId: string) => SingleView;
     defaultData: (viewManager: ViewManager) => Omit<Data, 'id' | 'name' | 'mode'>;
 }

package/dist/_pkgs/data-view/core/view/default-name.d.ts

@@ -0,0 +1,10 @@
+import type { BlockStdScope } from '../../../std/index.js';
+import type { DataViewModel } from './data-view.js';
+/**
+ * The name a view created now is given: the preset's `defaultNameKey`
+ * resolved through the host's catalogue, its English `defaultName` without
+ * an editor (`std` absent) or without a key. A creation site writes what
+ * this returns, at the gesture, so the stored name is the one the author saw
+ * and the preset's seed never changes (ADR 0023). Never call it on load.
+ */
+export declare function viewDefaultName(meta: Pick<DataViewModel, 'model'>, std: BlockStdScope | undefined): string;

package/dist/_pkgs/data-view/core/view/default-name.js

@@ -0,0 +1,14 @@
+import { translateKey } from '../../../affine-shared/services/index.js';
+/**
+ * The name a view created now is given: the preset's `defaultNameKey`
+ * resolved through the host's catalogue, its English `defaultName` without
+ * an editor (`std` absent) or without a key. A creation site writes what
+ * this returns, at the gesture, so the stored name is the one the author saw
+ * and the preset's seed never changes (ADR 0023). Never call it on load.
+ */
+export function viewDefaultName(meta, std) {
+    const { defaultName, defaultNameKey } = meta.model;
+    if (!std || !defaultNameKey)
+        return defaultName;
+    return translateKey(std, defaultNameKey, defaultName);
+}

package/dist/_pkgs/data-view/core/view/index.d.ts

@@ -1,4 +1,6 @@
 export * from './convert.js';
 export * from './data-view.js';
 export * from './data-view-base.js';
+export * from './default-name.js';
 export * from './types.js';
+export * from './open-in.js';

package/dist/_pkgs/data-view/core/view/index.js

@@ -1,4 +1,6 @@
 export * from './convert.js';
 export * from './data-view.js';
 export * from './data-view-base.js';
+export * from './default-name.js';
 export * from './types.js';
+export * from './open-in.js';

package/dist/_pkgs/data-view/core/view/open-in.d.ts

@@ -0,0 +1,27 @@
+import { type DatabaseViewOpenIn } from '../../../affine-model/index.js';
+import type { DataSource } from '../data-source/base.js';
+import type { SingleView } from '../view-manager/single-view.js';
+/**
+ * Where a view opens its rows' pages (ADR 0035 §8, B8; PRD REQ-DB-11): the
+ * stored `openIn` of the view, a setting every reader of the view shares.
+ * Absent, or a value this build does not know (the list is append-only),
+ * reads `side`. The row-open seam (§9a, B9) reads it; this file only reads
+ * and writes the setting.
+ */
+export declare const DEFAULT_OPEN_IN: DatabaseViewOpenIn;
+export declare function viewOpenIn(data: object | undefined): DatabaseViewOpenIn;
+/**
+ * Record a choice of the view settings. Written on that gesture only, and not
+ * when it changes nothing: picking "Side peek" on a view that stores no
+ * `openIn` leaves the field absent. A read-only view and a fallback view
+ * (ADR 0035 §6) are never written. Returns whether it wrote.
+ */
+export declare function viewOpenInSet(view: SingleView, openIn: DatabaseViewOpenIn): boolean;
+/**
+ * Whether the source says its rows are pages (`rowsAreDocuments`, on the
+ * hosted source of `blocks/database`, ADR 0035 §9a). Only then does a row
+ * open where `openIn` says, so only then is the setting offered: a
+ * block-backed row keeps the detail panel whatever the view stores. Read
+ * structurally because the flag is declared above this package.
+ */
+export declare function rowsArePages(dataSource: DataSource): boolean;

package/dist/_pkgs/data-view/core/view/open-in.js

@@ -0,0 +1,39 @@
+import { DATABASE_VIEW_OPEN_IN, } from '../../../affine-model/index.js';
+/**
+ * Where a view opens its rows' pages (ADR 0035 §8, B8; PRD REQ-DB-11): the
+ * stored `openIn` of the view, a setting every reader of the view shares.
+ * Absent, or a value this build does not know (the list is append-only),
+ * reads `side`. The row-open seam (§9a, B9) reads it; this file only reads
+ * and writes the setting.
+ */
+export const DEFAULT_OPEN_IN = 'side';
+export function viewOpenIn(data) {
+    const stored = data?.openIn;
+    return DATABASE_VIEW_OPEN_IN.find(mode => mode === stored) ?? DEFAULT_OPEN_IN;
+}
+/**
+ * Record a choice of the view settings. Written on that gesture only, and not
+ * when it changes nothing: picking "Side peek" on a view that stores no
+ * `openIn` leaves the field absent. A read-only view and a fallback view
+ * (ADR 0035 §6) are never written. Returns whether it wrote.
+ */
+export function viewOpenInSet(view, openIn) {
+    if (view.readonly$.peek() || view.shownAsFallback$.peek())
+        return false;
+    const dataSource = view.manager.dataSource;
+    if (viewOpenIn(dataSource.viewDataGet(view.id)) === openIn)
+        return false;
+    dataSource.viewDataUpdate(view.id, () => ({ openIn }));
+    return true;
+}
+/**
+ * Whether the source says its rows are pages (`rowsAreDocuments`, on the
+ * hosted source of `blocks/database`, ADR 0035 §9a). Only then does a row
+ * open where `openIn` says, so only then is the setting offered: a
+ * block-backed row keeps the detail panel whatever the view stores. Read
+ * structurally because the flag is declared above this package.
+ */
+export function rowsArePages(dataSource) {
+    return (dataSource.rowsAreDocuments ===
+        true);
+}

package/dist/_pkgs/data-view/core/view-manager/cell.d.ts

@@ -1,4 +1,5 @@
 import { type ReadonlySignal } from '@preact/signals-core';
+import { type CellStatus } from '../data-source/hydration.js';
 import type { Property } from './property.js';
 import type { Row } from './row.js';
 import type { SingleView } from './single-view.js';
@@ -12,6 +13,8 @@ export interface Cell<RawValue = unknown, JsonValue = unknown, Data extends Reco
     readonly value$: ReadonlySignal<RawValue | undefined>;
     readonly jsonValue$: ReadonlySignal<JsonValue | undefined>;
     readonly stringValue$: ReadonlySignal<string | undefined>;
+    /** Whether the value is the source's real one yet (ADR 0035 §9e). */
+    readonly status$?: ReadonlySignal<CellStatus>;
     valueSet(value: RawValue | undefined): void;
     jsonValueSet(value: JsonValue | undefined): void;
 }
@@ -21,6 +24,7 @@ export declare class CellBase<RawValue = unknown, JsonValue = unknown, Data exte
     rowId: string;
     get dataSource(): import("../index.js").DataSource;
     meta$: ReadonlySignal<import("../index.js").PropertyMetaConfig | undefined>;
+    status$: ReadonlySignal<CellStatus>;
     value$: ReadonlySignal<RawValue>;
     isEmpty$: ReadonlySignal<boolean>;
     jsonValue$: ReadonlySignal<JsonValue | undefined>;
@@ -29,6 +33,7 @@ export declare class CellBase<RawValue = unknown, JsonValue = unknown, Data exte
     get property(): Property<RawValue, JsonValue, Data>;
     get row(): Row;
     constructor(view: SingleView, propertyId: string, rowId: string);
+    private get _writable();
     valueSet(value: RawValue | undefined): void;
     jsonValueSet(value: JsonValue | undefined): void;
 }

package/dist/_pkgs/data-view/core/view-manager/cell.js

@@ -1,4 +1,5 @@
 import { computed } from '@preact/signals-core';
+import { cellStatusOf } from '../data-source/hydration.js';
 import { fromJson } from '../property/utils.js';
 export class CellBase {
     get dataSource() {
@@ -17,6 +18,7 @@ export class CellBase {
         this.meta$ = computed(() => {
             return this.dataSource.propertyMetaGet(this.property.type$.value);
         });
+        this.status$ = computed(() => cellStatusOf(this.dataSource, this.rowId, this.propertyId));
         this.value$ = computed(() => {
             return this.view.manager.dataSource.cellValueGet(this.rowId, this.propertyId);
         });
@@ -51,10 +53,19 @@ export class CellBase {
             });
         });
     }
+    // A value the source has not delivered (or failed to) is never written
+    // over: a paste, a fill or a kanban drop on such a cell does nothing.
+    get _writable() {
+        return this.status$.peek() === 'ready';
+    }
     valueSet(value) {
+        if (!this._writable)
+            return;
         this.view.manager.dataSource.cellValueChange(this.rowId, this.propertyId, value);
     }
     jsonValueSet(value) {
+        if (!this._writable)
+            return;
         const meta = this.property.meta$.value;
         if (!meta) {
             return;

package/dist/_pkgs/data-view/core/view-manager/index.d.ts

@@ -3,3 +3,6 @@ export * from './property.js';
 export * from './row.js';
 export * from './single-view.js';
 export * from './view-manager.js';
+export * from './properties-panel-opener.js';
+export * from './view-creation.js';
+export * from './new-row-menu-opener.js';

package/dist/_pkgs/data-view/core/view-manager/index.js

@@ -3,3 +3,6 @@ export * from './property.js';
 export * from './row.js';
 export * from './single-view.js';
 export * from './view-manager.js';
+export * from './properties-panel-opener.js';
+export * from './view-creation.js';
+export * from './new-row-menu-opener.js';

package/dist/_pkgs/data-view/core/view-manager/new-row-menu-opener.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Set on a data source (`serviceSet`) by the block that hosts its views when
+ * the host offers a menu beside "New" (templates and options, ADR 0035
+ * amendment of 2026-10-14). The header's "New" then draws a chevron that
+ * calls `open`; the main part still adds a row through `addRow`, as without
+ * it. Absent, "New" is the single button of 0.48, nothing else drawn.
+ *
+ * `label` is resolved by the block, which owns the wording and the
+ * translation seam, so data-view declares no key for a host's menu.
+ */
+export interface NewRowMenuOpener {
+    label(): string;
+    /** Asked at every render of "New"; `false` draws no chevron for this
+     *  view. Absent, the chevron is drawn. */
+    canOpen?(viewId: string): boolean;
+    open(anchor: HTMLElement, viewId: string): void;
+}
+export declare const NewRowMenuOpenerKey: import("../../../global/di/types.js").ServiceIdentifier<NewRowMenuOpener> & (<U extends NewRowMenuOpener = NewRowMenuOpener>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);

package/dist/_pkgs/data-view/core/view-manager/new-row-menu-opener.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from '../../../global/di/index.js';
+export const NewRowMenuOpenerKey = createIdentifier('data-view-new-row-menu-opener');

package/dist/_pkgs/data-view/core/view-manager/properties-panel-opener.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Set on a data source (`serviceSet`) by the block that hosts its views when
+ * the editor has a properties panel (ADR 0035 §9b, issue B10): the view
+ * options' "Properties" then opens that panel on the view instead of the
+ * popover. Absent, the popover, as in 0.48: the only way back to a hidden
+ * property must always exist, and here it is the panel or the popover.
+ */
+export declare const PropertiesPanelOpenerKey: import("../../../global/di/types.js").ServiceIdentifier<(viewId: string) => void> & (<U extends (viewId: string) => void = (viewId: string) => void>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);

package/dist/_pkgs/data-view/core/view-manager/properties-panel-opener.js

@@ -0,0 +1,9 @@
+import { createIdentifier } from '../../../global/di/index.js';
+/**
+ * Set on a data source (`serviceSet`) by the block that hosts its views when
+ * the editor has a properties panel (ADR 0035 §9b, issue B10): the view
+ * options' "Properties" then opens that panel on the view instead of the
+ * popover. Absent, the popover, as in 0.48: the only way back to a hidden
+ * property must always exist, and here it is the panel or the popover.
+ */
+export const PropertiesPanelOpenerKey = createIdentifier('data-view-properties-panel-opener');