@formicoidea/labre-core 0.48.0 → 0.49.0

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');

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

@@ -1,6 +1,7 @@
 import type { UniComponent } from '../../../affine-shared/types/index.js';
 import type { InsertToPosition } from '../../../affine-shared/utils/index.js';
 import { type ReadonlySignal } from '@preact/signals-core';
+import type { TagOptionEdits } from '../component/tags/multi-tag-select.js';
 import type { TypeInstance } from '../logical/type.js';
 import type { CellRenderer, PropertyMetaConfig } from '../property/index.js';
 import type { PropertyDataUpdater } from '../types.js';
@@ -33,6 +34,13 @@ export interface Property<RawValue = unknown, JsonValue = unknown, Data extends
      * creates, edits and reorders no option (`standalone-cell.ts`).
      */
     readonly dataCanSet?: boolean;
+    /**
+     * Which option edits a select's `dataUpdate` stands for when it writes
+     * (`TagOptionEdits`); absent means all of them. A standalone cell whose
+     * host writes options one create or rename at a time says
+     * `'create-rename'`, and the tag menu offers no delete, colour or reorder.
+     */
+    readonly optionEdits?: TagOptionEdits;
     readonly type$: ReadonlySignal<string>;
     readonly typeSet?: (type: string) => void;
     get typeCanSet(): boolean;

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

@@ -1,6 +1,7 @@
 import type { InsertToPosition } from '../../../affine-shared/utils/index.js';
 import type { GeneralServiceIdentifier } from '../../../global/di/index.js';
 import { type ReadonlySignal } from '@preact/signals-core';
+import type { DataSource } from '../data-source/base.js';
 import type { Variable } from '../expression/types.js';
 import type { PropertyMetaConfig } from '../property/property-config.js';
 import type { TraitKey } from '../traits/key.js';
@@ -10,6 +11,14 @@ import { type Cell } from './cell.js';
 import type { Property } from './property.js';
 import { type Row } from './row.js';
 import type { ViewManager } from './view-manager.js';
+/**
+ * True when a stored `mode` has no preset of its own and the source draws it
+ * through another one (ADR 0035 §6: a `timeline`, a mode from a newer
+ * client, an import). The one spelling of the rule, read by
+ * `SingleView.shownAsFallback$` and by the views bar's tabs, which must not
+ * build a view per tab to ask.
+ */
+export declare function modeShownAsFallback(dataSource: Pick<DataSource, 'viewMetaGet'>, mode: string): boolean;
 export type MainProperties = {
     titleColumn?: string;
     iconColumn?: string;
@@ -21,6 +30,11 @@ export interface SingleView {
     readonly manager: ViewManager;
     readonly meta: ViewMeta;
     readonly readonly$: ReadonlySignal<boolean>;
+    /**
+     * The stored mode has no preset here and `meta` is the source's fallback:
+     * the view is drawn, its settings are read-only, its data is never written.
+     */
+    readonly shownAsFallback$: ReadonlySignal<boolean>;
     delete(): void;
     duplicate(): void;
     readonly name$: ReadonlySignal<string>;
@@ -57,6 +71,19 @@ export declare abstract class SingleViewBase<ViewData extends DataViewDataType =
     id: string;
     private readonly searchString;
     private readonly traitMap;
+    /** The view data exactly as stored, whatever its mode. */
+    private readonly storedData$;
+    /**
+     * {@link modeShownAsFallback} for this view. Read from the stored mode,
+     * never from `type`, which a preset may derive from {@link data$}.
+     */
+    readonly shownAsFallback$: ReadonlySignal<boolean>;
+    /**
+     * A fallback view reads the preset's DEFAULT data, keeping only its id,
+     * name and stored mode: the stored keys belong to a preset this client does
+     * not have, so neither a filter nor a column list is trusted from them, and
+     * the preset draws the source's properties as a fresh view would.
+     */
     data$: ReadonlySignal<ViewData | undefined>;
     abstract detailProperties$: ReadonlySignal<Property[]>;
     protected lockRows$: import("@preact/signals-core").Signal<boolean>;
@@ -79,7 +106,7 @@ export declare abstract class SingleViewBase<ViewData extends DataViewDataType =
         icon: import("../../../affine-shared/types/uni-component.js").UniComponent | undefined;
         propertyType: string;
     }[]>;
-    protected get dataSource(): import("../index.js").DataSource;
+    protected get dataSource(): DataSource;
     get featureFlags$(): ReadonlySignal<DatabaseFlags>;
     get isLocked(): boolean;
     get meta(): ViewMeta;

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

@@ -2,6 +2,16 @@ import { computed, signal } from '@preact/signals-core';
 import { computedLock } from '../utils/lock.js';
 import { CellBase } from './cell.js';
 import { RowBase } from './row.js';
+/**
+ * True when a stored `mode` has no preset of its own and the source draws it
+ * through another one (ADR 0035 §6: a `timeline`, a mode from a newer
+ * client, an import). The one spelling of the rule, read by
+ * `SingleView.shownAsFallback$` and by the views bar's tabs, which must not
+ * build a view per tab to ask.
+ */
+export function modeShownAsFallback(dataSource, mode) {
+    return dataSource.viewMetaGet(mode).type !== mode;
+}
 export class SingleViewBase {
     rowsDelete(rows) {
         this.lockRows(false);
@@ -27,9 +37,37 @@ export class SingleViewBase {
         this.id = id;
         this.searchString = signal('');
         this.traitMap = new Map();
-        this.data$ = computed(() => {
+        /** The view data exactly as stored, whatever its mode. */
+        this.storedData$ = computed(() => {
             return this.dataSource.viewDataGet(this.id);
         });
+        /**
+         * {@link modeShownAsFallback} for this view. Read from the stored mode,
+         * never from `type`, which a preset may derive from {@link data$}.
+         */
+        this.shownAsFallback$ = computed(() => {
+            const mode = this.storedData$.value?.mode;
+            return mode != null && modeShownAsFallback(this.dataSource, mode);
+        });
+        /**
+         * A fallback view reads the preset's DEFAULT data, keeping only its id,
+         * name and stored mode: the stored keys belong to a preset this client does
+         * not have, so neither a filter nor a column list is trusted from them, and
+         * the preset draws the source's properties as a fresh view would.
+         */
+        this.data$ = computed(() => {
+            const stored = this.storedData$.value;
+            if (!stored || !this.shownAsFallback$.value) {
+                return stored;
+            }
+            const meta = this.dataSource.viewMetaGet(stored.mode);
+            return {
+                ...meta.model.defaultData(this.manager),
+                id: stored.id,
+                name: stored.name,
+                mode: stored.mode,
+            };
+        });
         this.lockRows$ = signal(false);
         this.isLocked$ = computed(() => {
             return this.lockRows$.value;
@@ -96,6 +134,12 @@ export class SingleViewBase {
         return this.dataSource.serviceGetOrCreate(key, create);
     }
     dataUpdate(updater) {
+        // A fallback view's stored data is never rewritten (ADR 0035 §6): every
+        // setting it shows is the fallback preset's default, and writing one back
+        // would mix that preset's keys into another mode's data. Cells are the
+        // source's, not the view's, and stay writable.
+        if (this.shownAsFallback$.peek())
+            return;
         this.dataSource.viewDataUpdate(this.id, updater);
     }
     delete() {

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

@@ -0,0 +1,49 @@
+import type { MenuConfig } from '../../../affine-components/context-menu/index.js';
+import type { BlockStdScope } from '../../../std/index.js';
+import { type ExtensionType } from '../../../store/index.js';
+import type { DataSource } from '../data-source/base.js';
+import type { ViewManager } from './view-manager.js';
+/**
+ * Set to `true` on a data source (`serviceSet`) whose host switched off the
+ * tooling that CREATES views: the views bar then offers no "+" and no
+ * "Create …" (ADR 0035 §5, ADR 0009). Absent means offered, so every source
+ * that never sets it keeps its 0.48 views bar. The stored views keep
+ * rendering, switching layout and being deleted: only creation is tooling.
+ */
+export declare const ViewCreationOffKey: import("../../../global/di/types.js").ServiceIdentifier<true> & (<U extends true = true>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * "Duplicate as table": the way out of a view shown through a fallback
+ * preset (`SingleView.shownAsFallback$`). Adds a view of the preset that drew
+ * it, under the same name, with that preset's default data, and selects it;
+ * the stored view is left exactly as it was, so a client that knows its mode
+ * still reads it. Returns the new view's id, or `undefined` when there is no
+ * such view or it is not a fallback.
+ */
+export declare function duplicateAsShownPreset(manager: ViewManager, viewId: string): string | undefined;
+/** What the views bar hands an {@link AddViewMenu} when "+" is clicked. */
+export interface AddViewMenuContext {
+    /** The editor the bar is mounted in; absent outside one. */
+    std: BlockStdScope | undefined;
+    dataSource: DataSource;
+    viewManager: ViewManager;
+    /**
+     * The bar's own "add a view of this preset": adds it with the preset's
+     * default data and its name resolved at the gesture, selects it and traces
+     * `DatabaseViewAdded` once, `source` (default `existing`) saying whether the
+     * gesture created the source the view reads. Returns its id.
+     */
+    addView: (type: string, source?: 'existing' | 'new') => string;
+}
+/**
+ * The "+" menu of the views bar, when something above data-view knows more
+ * than the presets (ADR 0035 §1, B11): the `core-database` bundle registers
+ * one from its tooling extension to offer "on an existing source" and "with
+ * a new source". It is a registry between library packages, never filled by
+ * a host. Absent, or answering `undefined` for a data source it does not
+ * handle, the bar offers the creatable presets, as in 0.48.
+ */
+export interface AddViewMenu {
+    items(context: AddViewMenuContext): MenuConfig[] | undefined;
+}
+export declare const AddViewMenuIdentifier: import("../../../global/di/types.js").ServiceIdentifier<AddViewMenu> & (<U extends AddViewMenu = AddViewMenu>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+export declare function AddViewMenuExtension(menu: AddViewMenu): ExtensionType;

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

@@ -0,0 +1,40 @@
+import { createIdentifier } from '../../../global/di/index.js';
+import { nanoid } from '../../../store/index.js';
+/**
+ * Set to `true` on a data source (`serviceSet`) whose host switched off the
+ * tooling that CREATES views: the views bar then offers no "+" and no
+ * "Create …" (ADR 0035 §5, ADR 0009). Absent means offered, so every source
+ * that never sets it keeps its 0.48 views bar. The stored views keep
+ * rendering, switching layout and being deleted: only creation is tooling.
+ */
+export const ViewCreationOffKey = createIdentifier('data-view-view-creation-off');
+/**
+ * "Duplicate as table": the way out of a view shown through a fallback
+ * preset (`SingleView.shownAsFallback$`). Adds a view of the preset that drew
+ * it, under the same name, with that preset's default data, and selects it;
+ * the stored view is left exactly as it was, so a client that knows its mode
+ * still reads it. Returns the new view's id, or `undefined` when there is no
+ * such view or it is not a fallback.
+ */
+export function duplicateAsShownPreset(manager, viewId) {
+    const view = manager.viewGet(viewId);
+    if (!view || !view.shownAsFallback$.peek())
+        return;
+    const meta = view.meta;
+    const id = manager.dataSource.viewDataAdd({
+        ...meta.model.defaultData(manager),
+        id: nanoid(),
+        name: view.name$.peek(),
+        mode: meta.type,
+    });
+    manager.setCurrentView(id);
+    return id;
+}
+export const AddViewMenuIdentifier = createIdentifier('DataViewAddViewMenu');
+export function AddViewMenuExtension(menu) {
+    return {
+        setup: di => {
+            di.override(AddViewMenuIdentifier, () => menu);
+        },
+    };
+}

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

@@ -12,7 +12,11 @@ export interface ViewManager {
     setCurrentView(id: string): void;
     views$: ReadonlySignal<string[]>;
     viewGet(id: string): SingleView | undefined;
-    viewAdd(type: DataViewMode): string;
+    /**
+     * `name` is what the creation site resolved (`viewDefaultName`); absent,
+     * the preset's English `defaultName` is written, as in 0.48.
+     */
+    viewAdd(type: DataViewMode, name?: string): string;
     viewDelete(id: string): void;
     viewDuplicate(id: string): void;
     viewDataGet(id: string): DataViewDataType | undefined;
@@ -30,7 +34,7 @@ export declare class ViewManagerBase implements ViewManager {
     constructor(dataSource: DataSource);
     moveTo(id: string, position: InsertToPosition): void;
     setCurrentView(id: string | undefined): void;
-    viewAdd(type: DataViewMode): string;
+    viewAdd(type: DataViewMode, name?: string): string;
     viewChangeType(id: string, type: string): void;
     viewDataGet(id: string): DataViewDataType | undefined;
     viewDelete(id: string): void;

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

@@ -29,13 +29,13 @@ export class ViewManagerBase {
     setCurrentView(id) {
         this._currentViewId$.value = id;
     }
-    viewAdd(type) {
+    viewAdd(type, name) {
         const meta = this.dataSource.viewMetaGet(type);
         const data = meta.model.defaultData(this);
         const id = this.dataSource.viewDataAdd({
             ...data,
             id: nanoid(),
-            name: meta.model.defaultName,
+            name: name ?? meta.model.defaultName,
             mode: type,
         });
         this.setCurrentView(id);

package/dist/_pkgs/data-view/property-presets/date/cell-renderer.d.ts

@@ -1,6 +1,8 @@
 import { BaseCellRenderer } from '../../core/property/index.js';
 export declare class DateCell extends BaseCellRenderer<number, number> {
     private _prevPortalAbortController;
+    /** The picker opens in a popup: its words and locale are resolved here. */
+    private createDatePicker;
     private readonly openDatePicker;
     private readonly updateValue;
     tempValue$: import("@preact/signals-core").Signal<Date | undefined>;

package/dist/_pkgs/data-view/property-presets/date/cell-renderer.js

@@ -1,5 +1,6 @@
 import { popMenu, popupTargetFromElement, } from '../../../affine-components/context-menu/index.js';
 import { DatePicker } from '../../../affine-components/date-picker/index.js';
+import { formatLocale } from '../../../affine-shared/services/index.js';
 import { createLitPortal } from '../../../affine-components/portal/index.js';
 import { IS_MOBILE } from '../../../global/env/index.js';
 import { flip, offset } from '@floating-ui/dom';
@@ -40,7 +41,7 @@ export class DateCell extends BaseCellRenderer {
                 ${this.formattedTempValue$.value}
               </div>`,
                             () => {
-                                const datePicker = new DatePicker();
+                                const datePicker = this.createDatePicker();
                                 datePicker.padding = 0;
                                 datePicker.value = this.tempValue$.value?.getTime() ?? Date.now();
                                 datePicker.onChange = (date) => {
@@ -71,7 +72,7 @@ export class DateCell extends BaseCellRenderer {
                         middleware: [offset(10), flip()],
                     },
                     template: () => {
-                        const datePicker = new DatePicker();
+                        const datePicker = this.createDatePicker();
                         datePicker.value = this.tempValue$.value?.getTime() ?? Date.now();
                         datePicker.popup = true;
                         datePicker.onClear = () => {
@@ -114,6 +115,14 @@ export class DateCell extends BaseCellRenderer {
                 this.format(this.value ? new Date(this.value) : undefined));
         });
     }
+    /** The picker opens in a popup: its words and locale are resolved here. */
+    createDatePicker() {
+        const datePicker = new DatePicker();
+        datePicker.wording = this.wording;
+        if (this.chromeStd)
+            datePicker.locale = formatLocale(this.chromeStd);
+        return datePicker;
+    }
     format(value) {
         return value ? format(value, 'yyyy/MM/dd') : '';
     }

package/dist/_pkgs/data-view/property-presets/multi-select/cell-renderer.js

@@ -17,6 +17,7 @@ export class MultiSelectCell extends BaseCellRenderer {
                 name: this.cell.property.name$.value,
                 options: this.options$,
                 onOptionsChange: this.property.dataCanSet === false ? undefined : this._onOptionsChange,
+                optionEdits: this.property.optionEdits,
                 value: this._value$,
                 onChange: v => {
                     this.valueSetImmediate(v);
@@ -24,6 +25,7 @@ export class MultiSelectCell extends BaseCellRenderer {
                 onComplete: this._editComplete,
                 minWidth: 400,
                 initialDraftText,
+                wording: this.wording,
             });
         };
         this._editComplete = () => {

package/dist/_pkgs/data-view/property-presets/select/cell-renderer.js

@@ -17,6 +17,7 @@ export class SelectCell extends BaseCellRenderer {
                 mode: 'single',
                 options: this.options$,
                 onOptionsChange: this.property.dataCanSet === false ? undefined : this._onOptionsChange,
+                optionEdits: this.property.optionEdits,
                 value: this._value$,
                 onChange: v => {
                     this.valueSetImmediate(v[0]);
@@ -24,6 +25,7 @@ export class SelectCell extends BaseCellRenderer {
                 onComplete: this._editComplete,
                 minWidth: 400,
                 initialDraftText,
+                wording: this.wording,
             });
         };
         this._editComplete = () => {