@formicoidea/labre-core 0.47.1 → 0.49.0

package/dist/_pkgs/data-view/core/group-by/trait.js

@@ -1,7 +1,9 @@
 import { insertPositionToIndex, } from '../../../affine-shared/utils/index.js';
 import { computed, effect, signal, } from '@preact/signals-core';
+import { traceViewEvent } from '../telemetry.js';
 import { createTraitKey } from '../traits/key.js';
 import { computedLock } from '../utils/lock.js';
+import { groupCollapsed$, groupCollapsedSet } from './collapsed-state.js';
 import { compareDateKeys } from './compare-date-keys.js';
 import { defaultGroupBy } from './default.js';
 import { findGroupByConfigByName, getGroupByService } from './matcher.js';
@@ -74,6 +76,28 @@ export const reorderGroupKeys = (keys, groupKey, position) => {
     return reordered;
 };
 export class GroupTrait {
+    /** Whether the view stores hidden groups (every preset of 0.49 does). */
+    get groupsCanHide() {
+        return this.ops.groupHideSet != null;
+    }
+    /**
+     * Hide or show a group for everyone: a view setting, written to the view's
+     * `groupProperties` on the gesture, never when nothing changes.
+     */
+    groupHideSet(groupKey, hide) {
+        const set = this.ops.groupHideSet;
+        const groups = this.groupsDataList$.value;
+        if (!set || !groups || this.view.readonly$.value)
+            return;
+        set(groups.map(group => group.key), groupKey, hide);
+    }
+    /** Whether a group is folded: personal, on this device, never stored. */
+    collapsed$(groupKey) {
+        return groupCollapsed$(this.view.id, groupKey);
+    }
+    collapsedSet(groupKey, collapsed) {
+        groupCollapsedSet(this.view.id, groupKey, collapsed);
+    }
     get addGroup() {
         return this.property$.value?.meta$.value?.config.addGroup;
     }
@@ -167,6 +191,27 @@ export class GroupTrait {
                 .map(key => groupMap[key])
                 .filter((v) => v != null);
         }), this.view.isLocked$);
+        /**
+         * The groups a view draws: every group but the ones its stored
+         * `groupProperties` hide (ADR 0035 §8, B8). `groupsDataList$` keeps them
+         * all, because a reorder or a card move writes an entry for every key and
+         * must not drop a hidden group's.
+         */
+        this.visibleGroups$ = computed(() => {
+            const groups = this.groupsDataList$.value;
+            const hidden = this.ops.groupHidden;
+            if (!groups || !hidden)
+                return groups;
+            return groups.filter(group => !hidden(group.key));
+        });
+        /** The hidden groups, listed at the end of the view to be shown again. */
+        this.hiddenGroups$ = computed(() => {
+            const groups = this.groupsDataList$.value;
+            const hidden = this.ops.groupHidden;
+            if (!groups || !hidden)
+                return [];
+            return groups.filter(group => hidden(group.key));
+        });
         this.updateData = (data) => {
             const property = this.property$.value;
             if (!property) {
@@ -199,10 +244,17 @@ export class GroupTrait {
      * year — keeping the reading direction.
      */
     changeGroupMode(modeName) {
-        const propertyId = this.property$.value?.id;
+        const property = this.property$.value;
+        const propertyId = property?.id;
         if (!propertyId) {
             return;
         }
+        if (this.groupBy$.value?.name !== modeName) {
+            traceViewEvent(this.view, 'DatabaseGroupChanged', {
+                groupBy: modeName,
+                propertyType: property.type$.value,
+            });
+        }
         this.ops.groupBySet({
             type: 'groupBy',
             columnId: propertyId,
@@ -248,6 +300,9 @@ export class GroupTrait {
     }
     changeGroup(columnId) {
         if (columnId == null) {
+            if (this.groupBy$.value) {
+                traceViewEvent(this.view, 'DatabaseGroupChanged', { groupBy: 'none' });
+            }
             this.ops.groupBySet(undefined);
             return;
         }
@@ -258,6 +313,12 @@ export class GroupTrait {
             if (groupBy) {
                 groupBy.sort = { desc: !this.sortAsc$.value };
             }
+            if (groupBy && columnId !== this.groupBy$.value?.columnId) {
+                traceViewEvent(this.view, 'DatabaseGroupChanged', {
+                    groupBy: groupBy.name,
+                    propertyType: column.type$.value,
+                });
+            }
             this.ops.groupBySet(groupBy);
         }
     }

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

@@ -1,11 +1,14 @@
 export * from './common/index.js';
 export * from './component/index.js';
 export { DataSourceBase } from './data-source/base.js';
+export * from './data-source/hydration.js';
 export { DataViewRootUILogic } from './data-view.js';
+export { isNewTabClick } from './utils/new-tab-click.js';
 export * from './filter/index.js';
 export * from './group-by/index.js';
 export * from './logical/index.js';
 export * from './property/index.js';
+export * from './telemetry.js';
 export type { DataViewSelection } from './types.js';
 export * from './types.js';
 export * from './utils/index.js';

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

@@ -1,11 +1,14 @@
 export * from './common/index.js';
 export * from './component/index.js';
 export { DataSourceBase } from './data-source/base.js';
+export * from './data-source/hydration.js';
 export { DataViewRootUILogic } from './data-view.js';
+export { isNewTabClick } from './utils/new-tab-click.js';
 export * from './filter/index.js';
 export * from './group-by/index.js';
 export * from './logical/index.js';
 export * from './property/index.js';
+export * from './telemetry.js';
 export * from './types.js';
 export * from './utils/index.js';
 export * from './view/index.js';

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

@@ -1,4 +1,5 @@
-import { ShadowlessElement } from '../../../std/index.js';
+import { type ChromeWording, type TranslationParams } from '../../../affine-shared/services/index.js';
+import { type BlockStdScope, ShadowlessElement } from '../../../std/index.js';
 import { type ReadonlySignal } from '@preact/signals-core';
 import type { PropertyValues } from 'lit';
 import type { Cell } from '../view-manager/cell.js';
@@ -7,6 +8,19 @@ declare const BaseCellRenderer_base: typeof ShadowlessElement & import("../../..
 export declare abstract class BaseCellRenderer<RawValue = unknown, JsonValue = unknown, Data extends Record<string, unknown> = Record<string, unknown>> extends BaseCellRenderer_base implements DataViewCellLifeCycle, CellRenderProps<Data, RawValue, JsonValue> {
     get expose(): this;
     accessor cell: Cell<RawValue, JsonValue, Data>;
+    /**
+     * The editor the cell renders in, for its chrome wordings only; absent
+     * outside one (a test, a detached mount), and then every wording is its
+     * English fallback. Not `std`: database cells already read theirs from
+     * the data source's host.
+     */
+    accessor chromeStd: BlockStdScope;
+    /**
+     * A wording resolved here, while the cell is in the editor's DOM: the
+     * popups a cell opens (the tag menu, the date picker) render outside it
+     * and receive the resolved text.
+     */
+    readonly wording: (wording: ChromeWording, params?: TranslationParams) => string;
     readonly$: ReadonlySignal<boolean>;
     value$: ReadonlySignal<RawValue | undefined>;
     get property(): import("../index.js").Property<RawValue, JsonValue, Data>;

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

@@ -32,8 +32,10 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
+import { fillPlaceholders, translateKey, } from '../../../affine-shared/services/index.js';
 import { SignalWatcher, WithDisposable } from '../../../global/lit/index.js';
-import { ShadowlessElement } from '../../../std/index.js';
+import { ShadowlessElement, stdContext } from '../../../std/index.js';
+import { consume } from '@lit/context';
 import { computed } from '@preact/signals-core';
 import { property } from 'lit/decorators.js';
 let BaseCellRenderer = (() => {
@@ -41,6 +43,9 @@ let BaseCellRenderer = (() => {
     let _cell_decorators;
     let _cell_initializers = [];
     let _cell_extraInitializers = [];
+    let _chromeStd_decorators;
+    let _chromeStd_initializers = [];
+    let _chromeStd_extraInitializers = [];
     let _isEditing$_decorators;
     let _isEditing$_initializers = [];
     let _isEditing$_extraInitializers = [];
@@ -51,9 +56,11 @@ let BaseCellRenderer = (() => {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _cell_decorators = [property({ attribute: false })];
+            _chromeStd_decorators = [consume({ context: stdContext })];
             _isEditing$_decorators = [property({ attribute: false })];
             _selectCurrentCell_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, _chromeStd_decorators, { kind: "accessor", name: "chromeStd", static: false, private: false, access: { has: obj => "chromeStd" in obj, get: obj => obj.chromeStd, set: (obj, value) => { obj.chromeStd = value; } }, metadata: _metadata }, _chromeStd_initializers, _chromeStd_extraInitializers);
             __esDecorate(this, null, _isEditing$_decorators, { kind: "accessor", name: "isEditing$", static: false, private: false, access: { has: obj => "isEditing$" in obj, get: obj => obj.isEditing$, set: (obj, value) => { obj.isEditing$ = value; } }, metadata: _metadata }, _isEditing$_initializers, _isEditing$_extraInitializers);
             __esDecorate(this, null, _selectCurrentCell_decorators, { kind: "accessor", name: "selectCurrentCell", static: false, private: false, access: { has: obj => "selectCurrentCell" in obj, get: obj => obj.selectCurrentCell, set: (obj, value) => { obj.selectCurrentCell = value; } }, metadata: _metadata }, _selectCurrentCell_initializers, _selectCurrentCell_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -64,6 +71,15 @@ let BaseCellRenderer = (() => {
         #cell_accessor_storage;
         get cell() { return this.#cell_accessor_storage; }
         set cell(value) { this.#cell_accessor_storage = value; }
+        #chromeStd_accessor_storage;
+        /**
+         * The editor the cell renders in, for its chrome wordings only; absent
+         * outside one (a test, a detached mount), and then every wording is its
+         * English fallback. Not `std`: database cells already read theirs from
+         * the data source's host.
+         */
+        get chromeStd() { return this.#chromeStd_accessor_storage; }
+        set chromeStd(value) { this.#chromeStd_accessor_storage = value; }
         get property() {
             return this.cell.property;
         }
@@ -149,9 +165,18 @@ let BaseCellRenderer = (() => {
         constructor() {
             super(...arguments);
             this.#cell_accessor_storage = __runInitializers(this, _cell_initializers, void 0);
-            this.readonly$ = (__runInitializers(this, _cell_extraInitializers), computed(() => {
+            this.#chromeStd_accessor_storage = (__runInitializers(this, _cell_extraInitializers), __runInitializers(this, _chromeStd_initializers, void 0));
+            /**
+             * A wording resolved here, while the cell is in the editor's DOM: the
+             * popups a cell opens (the tag menu, the date picker) render outside it
+             * and receive the resolved text.
+             */
+            this.wording = (__runInitializers(this, _chromeStd_extraInitializers), (wording, params) => this.chromeStd
+                ? translateKey(this.chromeStd, ...wording, params)
+                : fillPlaceholders(wording[1], params));
+            this.readonly$ = computed(() => {
                 return this.cell.property.readonly$.value;
-            }));
+            });
             this.value$ = computed(() => {
                 return this.cell.value$.value;
             });

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

@@ -3,4 +3,5 @@ export * from './convert.js';
 export * from './manager.js';
 export * from './property-config.js';
 export * from './renderer.js';
+export * from './standalone-cell.js';
 export * from './types.js';

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

@@ -3,4 +3,5 @@ export * from './convert.js';
 export * from './manager.js';
 export * from './property-config.js';
 export * from './renderer.js';
+export * from './standalone-cell.js';
 export * from './types.js';

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

@@ -0,0 +1,109 @@
+import { type GeneralServiceIdentifier } from '../../../global/di/index.js';
+import { ShadowlessElement } from '../../../std/index.js';
+import type { ExtensionType } from '../../../store/index.js';
+import { type ReadonlySignal } from '@preact/signals-core';
+import { nothing } from 'lit';
+import type { TagOptionEdits } from '../component/tags/multi-tag-select.js';
+import type { DatabaseFlags } from '../types.js';
+import type { Cell } from '../view-manager/cell.js';
+import type { PropertyMetaConfig } from './property-config.js';
+/**
+ * A cell outside any view: one property's value drawn and edited by the very
+ * cell renderer a table cell mounts (checkbox, select, multi-select, date,
+ * number, text, a link…), for a host that has a value and no table, such as
+ * the title band under a page title (ADR 0035 §11).
+ *
+ * A cell renderer is written against a `Cell` bound to a `SingleView` and a
+ * data source. Outside a view there are neither, and building a data source
+ * for one value would be a second store. What the presets actually read is
+ * small, and this seam provides exactly that and nothing more:
+ * - of the property: `name$`, `data$`, `type$`, `readonly$`, `dataUpdate`,
+ *   `renderer$`, `meta$`, `dataCanSet` and `optionEdits`;
+ * - of the view: `featureFlags$` (the number format), `serviceGet` (the link
+ *   cell's editor host) and `readonly$`;
+ * - of the cell: `value$` and `valueSet`, with the JSON value the raw one,
+ *   which holds for every preset a standalone cell is drawn for.
+ * The rest of `SingleView` and `Row` is absent: a renderer that starts
+ * reading it fails `standalone-cell.unit.spec.ts`, which mounts every preset
+ * through this seam, rather than a host at run time.
+ */
+export interface StandaloneCellSource<RawValue = unknown, Data extends Record<string, unknown> = Record<string, unknown>> {
+    readonly propertyId: string;
+    readonly name$: ReadonlySignal<string>;
+    readonly data$: ReadonlySignal<Data>;
+    readonly value$: ReadonlySignal<RawValue | undefined>;
+    readonly readonly$: ReadonlySignal<boolean>;
+    /** A value the cell's editor commits; the host decides when it shows. */
+    valueSet(value: RawValue | undefined): void;
+    /**
+     * Writes the property's config (a select's options). Absent, the config is
+     * not the host's to write here: a select offers its options and creates,
+     * renames, recolours, reorders or deletes none.
+     */
+    dataSet?(data: Data): void;
+    /**
+     * Which option edits `dataSet` stands for; absent, all. `'create-rename'`:
+     * a select creates and renames options and deletes, recolours and
+     * reorders none (`TagOptionEdits`).
+     */
+    readonly optionEdits?: TagOptionEdits;
+    /** The view's flags (`enable_number_formatting`); absent, all off. */
+    readonly featureFlags$?: ReadonlySignal<DatabaseFlags>;
+    /** What `view.serviceGet` answers; absent, nothing. */
+    serviceGet?<T>(key: GeneralServiceIdentifier<T>): T | null;
+}
+/** A `Cell` for one value outside any view, drawn with `meta`'s renderer. */
+export declare function createStandaloneCell<RawValue = unknown, Data extends Record<string, unknown> = Record<string, unknown>>(meta: PropertyMetaConfig, source: StandaloneCellSource<RawValue, Data>): Cell<RawValue, RawValue, Data>;
+/**
+ * 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 declare const StandaloneCellMetaProvider: import("../../../global/di/types.js").ServiceIdentifier<PropertyMetaConfig> & (<U extends PropertyMetaConfig = PropertyMetaConfig>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+export declare function StandaloneCellMetaExtension<Type extends string, Data extends NonNullable<unknown>, RawValue, JsonValue>(meta: PropertyMetaConfig<Type, Data, RawValue, JsonValue>): ExtensionType;
+declare const StandaloneCellHost_base: typeof ShadowlessElement & import("../../../global/utils/types.js").Constructor<import("../../../global/lit/with-disposable.js").DisposableClass>;
+/**
+ * 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.
+ */
+export declare class StandaloneCellHost extends StandaloneCellHost_base {
+    static styles: import("lit").CSSResult;
+    private readonly _cell$;
+    private _exiting;
+    readonly isEditing$: import("@preact/signals-core").Signal<boolean>;
+    /** Opens the renderer's editor; a checkbox toggles instead. */
+    edit(): void;
+    /** Closes the editor; the renderer's exit hook commits its value. */
+    exit(): void;
+    private readonly _selectCurrentCell;
+    connectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    accessor cell: Cell;
+    /** Drawn while the value is empty and no editor is open. */
+    accessor placeholder: string;
+    /** Draws the value and opens no editor. */
+    accessor readonly: boolean;
+    /**
+     * 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.
+     */
+    accessor onEditingChange: ((editing: boolean) => void) | undefined;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'dv-standalone-cell': StandaloneCellHost;
+    }
+}
+export {};