@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/_pkgs/data-view/view-presets/calendar/renderer.d.ts

@@ -0,0 +1,2 @@
+import './pc/effect.js';
+export declare const calendarViewMeta: import("../../index.js").ViewMeta<"calendar", import("./types.js").CalendarViewData>;

package/dist/_pkgs/data-view/view-presets/calendar/renderer.js

@@ -0,0 +1,8 @@
+import './pc/effect.js';
+import { createIcon } from '../../core/utils/uni-icon.js';
+import { calendarViewModel } from './define.js';
+import { CalendarViewUILogic } from './pc/view.js';
+export const calendarViewMeta = calendarViewModel.createMeta({
+    icon: createIcon('TodayIcon'),
+    pcLogic: () => CalendarViewUILogic,
+});

package/dist/_pkgs/data-view/view-presets/calendar/source.d.ts

@@ -0,0 +1,8 @@
+import type { DataSource } from '../../core/data-source/base.js';
+import type { CalendarExternalSource, CalendarStoredViewData } from './types.js';
+export type CalendarExternalSourceFactory = {
+    id: string;
+    create(viewData: CalendarStoredViewData): CalendarExternalSource;
+};
+export declare const CalendarExternalSourceProvider: import("../../../global/di/types.js").ServiceIdentifier<CalendarExternalSourceFactory> & (<U extends CalendarExternalSourceFactory = CalendarExternalSourceFactory>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+export declare const getCalendarExternalSources: (dataSource: DataSource, viewData: CalendarStoredViewData) => CalendarExternalSource[];

package/dist/_pkgs/data-view/view-presets/calendar/source.js

@@ -0,0 +1,3 @@
+import { createIdentifier } from '../../../global/di/index.js';
+export const CalendarExternalSourceProvider = createIdentifier('calendar-external-source');
+export const getCalendarExternalSources = (dataSource, viewData) => Array.from(dataSource.provider.getAll(CalendarExternalSourceProvider).values()).map(source => source.create(viewData));

package/dist/_pkgs/data-view/view-presets/calendar/types.d.ts

@@ -0,0 +1,79 @@
+import type { FilterGroup } from '../../core/filter/types.js';
+import type { Sort } from '../../core/sort/types.js';
+import type { BasicViewDataType } from '../../core/view/data-view.js';
+export type CalendarWorkspaceSourceConfig = {
+    enabled: boolean;
+    subscriptionIds?: string[];
+};
+export type CalendarUiData = {
+    emptyMonthHintDismissed?: boolean;
+};
+export type CalendarCardProperty = {
+    propertyId: string;
+    value: string;
+};
+export type CalendarTitleSegment = {
+    text: string;
+    linkedDoc?: boolean;
+};
+type CalendarViewDataShape = {
+    filter: FilterGroup;
+    sort?: Sort;
+    date: {
+        startColumnId?: string;
+        endColumnId?: string;
+    };
+    card: {
+        titleColumnId?: string;
+        visiblePropertyIds: string[];
+    };
+    sources: {
+        workspaceCalendar?: CalendarWorkspaceSourceConfig;
+    };
+    ui?: CalendarUiData;
+};
+export type CalendarViewData = BasicViewDataType<'calendar', CalendarViewDataShape>;
+export type CalendarStoredViewData = CalendarViewData;
+export type CalendarEntryBase = {
+    id: string;
+    sourceId: string;
+    title: string;
+    color?: string;
+    startAt: number;
+    endAt?: number;
+    allDay?: boolean;
+};
+export type CalendarRowEntry = CalendarEntryBase & {
+    kind: 'row';
+    sourceId: 'database';
+    rowId: string;
+    titleSegments?: CalendarTitleSegment[];
+    cardProperties: CalendarCardProperty[];
+    canResizeRange: boolean;
+};
+export type CalendarExternalEntry = CalendarEntryBase & {
+    kind: 'external';
+    sourceId: string;
+    externalId: string;
+    calendarName?: string;
+    location?: string;
+    description?: string;
+    canResizeRange: false;
+};
+export type CalendarEntry = CalendarRowEntry | CalendarExternalEntry;
+export type CalendarEntryRange = {
+    from: number;
+    to: number;
+};
+export type CalendarExternalSource = {
+    id: string;
+    getSubscriptionOptions?(): CalendarExternalSourceSubscription[];
+    openConnectSettings?(): void;
+    getEntries(range: CalendarEntryRange): CalendarExternalEntry[] | Promise<CalendarExternalEntry[]>;
+};
+export type CalendarExternalSourceSubscription = {
+    id: string;
+    name: string;
+    color?: string;
+};
+export {};

package/dist/_pkgs/data-view/view-presets/calendar/types.js

@@ -0,0 +1 @@
+export {};

package/dist/_pkgs/data-view/view-presets/convert.js

@@ -1,6 +1,14 @@
 import { createViewConvert } from '../core/view/convert.js';
+import { calendarViewModel } from './calendar/index.js';
 import { kanbanViewModel } from './kanban/index.js';
 import { tableViewModel } from './table/index.js';
+const headerToCalendarCard = (header) => ({
+    titleColumnId: header?.titleColumn,
+    visiblePropertyIds: [],
+});
+const calendarCardToHeader = (card) => ({
+    titleColumn: card?.titleColumnId,
+});
 export const viewConverts = [
     createViewConvert(tableViewModel, kanbanViewModel, data => {
         if (data.groupBy) {
@@ -17,4 +25,24 @@ export const viewConverts = [
         filter: data.filter,
         groupBy: data.groupBy,
     })),
+    createViewConvert(tableViewModel, calendarViewModel, data => ({
+        filter: data.filter,
+        sort: data.sort,
+        card: headerToCalendarCard(data.header),
+    })),
+    createViewConvert(kanbanViewModel, calendarViewModel, data => ({
+        filter: data.filter,
+        sort: data.sort,
+        card: headerToCalendarCard(data.header),
+    })),
+    createViewConvert(calendarViewModel, tableViewModel, data => ({
+        filter: data.filter,
+        sort: data.sort,
+        header: calendarCardToHeader(data.card),
+    })),
+    createViewConvert(calendarViewModel, kanbanViewModel, data => ({
+        filter: data.filter,
+        sort: data.sort,
+        header: calendarCardToHeader(data.card),
+    })),
 ];

package/dist/_pkgs/data-view/view-presets/effect.js

@@ -1,6 +1,8 @@
+import { calendarEffects } from './calendar/effect.js';
 import { kanbanEffects } from './kanban/effect.js';
 import { tableEffects } from './table/effect.js';
 export function viewPresetsEffects() {
+    calendarEffects();
     kanbanEffects();
     tableEffects();
 }

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

@@ -1,7 +1,9 @@
+export * from './calendar/index.js';
 export * from './convert.js';
 export * from './kanban/index.js';
 export * from './table/index.js';
 export declare const viewPresets: {
     tableViewMeta: import("../index.js").ViewMeta<"table", import("./index.js").TableViewData>;
     kanbanViewMeta: import("../index.js").ViewMeta<"kanban", import("./index.js").KanbanViewData>;
+    calendarViewMeta: import("../index.js").ViewMeta<"calendar", import("./index.js").CalendarViewData>;
 };

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

@@ -1,9 +1,12 @@
+import { calendarViewMeta } from './calendar/index.js';
 import { kanbanViewMeta } from './kanban/index.js';
 import { tableViewMeta } from './table/index.js';
+export * from './calendar/index.js';
 export * from './convert.js';
 export * from './kanban/index.js';
 export * from './table/index.js';
 export const viewPresets = {
     tableViewMeta: tableViewMeta,
     kanbanViewMeta: kanbanViewMeta,
+    calendarViewMeta: calendarViewMeta,
 };

package/dist/_pkgs/data-view/view-presets/kanban/kanban-view-manager.js

@@ -191,7 +191,9 @@ export class KanbanSingleView extends SingleViewBase {
     }
     isShow(rowId) {
         if (this.filter$.value?.conditions.length) {
-            const rowMap = Object.fromEntries(this.properties$.value.map(column => [
+            // Filters are evaluated against every property of the view, hidden ones
+            // included: hiding a column must not silently drop the condition on it.
+            const rowMap = Object.fromEntries(this.propertiesRaw$.value.map(column => [
                 column.id,
                 column.cellGetOrCreate(rowId).jsonValue$.value,
             ]));

package/dist/_pkgs/data-view/view-presets/kanban/mobile/cell.js

@@ -111,13 +111,13 @@ let MobileKanbanCell = (() => {
                 return;
             this.disposables.add(effect(() => {
                 const isEditing = this.isSelectionEditing$.value;
-                if (isEditing) {
+                if (isEditing && !this.isEditing$.peek()) {
                     this.isEditing$.value = true;
                     requestAnimationFrame(() => {
                         this._cell.value?.afterEnterEditingMode();
                     });
                 }
-                else {
+                else if (!isEditing && this.isEditing$.peek()) {
                     this._cell.value?.beforeExitEditingMode();
                     this.isEditing$.value = false;
                 }

package/dist/_pkgs/data-view/view-presets/table/collapsed-state.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared utility for managing table group collapsed state in sessionStorage.
+ * Used by both PC and mobile table group implementations.
+ */
+/**
+ * Gets the collapsed state for a specific table group from sessionStorage.
+ * @param viewId - The ID of the table view
+ * @param groupKey - The key of the group
+ * @returns The collapsed state as a boolean, or false if not found or invalid
+ */
+export declare function getCollapsedState(viewId: string, groupKey: string): boolean;
+/**
+ * Sets the collapsed state for a specific table group in sessionStorage.
+ * @param viewId - The ID of the table view
+ * @param groupKey - The key of the group
+ * @param collapsed - The collapsed state to store
+ */
+export declare function setCollapsedState(viewId: string, groupKey: string, collapsed: boolean): void;

package/dist/_pkgs/data-view/view-presets/table/collapsed-state.js

@@ -0,0 +1,36 @@
+/**
+ * Shared utility for managing table group collapsed state in sessionStorage.
+ * Used by both PC and mobile table group implementations.
+ */
+/**
+ * Gets the collapsed state for a specific table group from sessionStorage.
+ * @param viewId - The ID of the table view
+ * @param groupKey - The key of the group
+ * @returns The collapsed state as a boolean, or false if not found or invalid
+ */
+export function getCollapsedState(viewId, groupKey) {
+    try {
+        const value = sessionStorage.getItem(`affine:table-group:${viewId}:${groupKey}:collapsed`);
+        if (!value)
+            return false;
+        const parsed = JSON.parse(value);
+        return typeof parsed === 'boolean' ? parsed : false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sets the collapsed state for a specific table group in sessionStorage.
+ * @param viewId - The ID of the table view
+ * @param groupKey - The key of the group
+ * @param collapsed - The collapsed state to store
+ */
+export function setCollapsedState(viewId, groupKey, collapsed) {
+    try {
+        sessionStorage.setItem(`affine:table-group:${viewId}:${groupKey}:collapsed`, JSON.stringify(collapsed));
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/_pkgs/data-view/view-presets/table/mobile/cell.js

@@ -112,14 +112,14 @@ let MobileTableCell = (() => {
                 return;
             this.disposables.add(effect(() => {
                 const isEditing = this.isSelectionEditing$.value;
-                if (isEditing) {
+                if (isEditing && !this.isEditing$.peek()) {
                     this.isEditing$.value = true;
                     const cell = this._cell.value;
                     requestAnimationFrame(() => {
                         cell?.afterEnterEditingMode();
                     });
                 }
-                else {
+                else if (!isEditing && this.isEditing$.peek()) {
                     this._cell.value?.beforeExitEditingMode();
                     this.isEditing$.value = false;
                 }

package/dist/_pkgs/data-view/view-presets/table/mobile/group.d.ts

@@ -5,12 +5,23 @@ import type { MobileTableViewUILogic } from './table-view-ui-logic.js';
 declare const MobileTableGroup_base: typeof ShadowlessElement & import("../../../../global/utils/types.js").Constructor<import("../../../../global/lit/with-disposable.js").DisposableClass>;
 export declare class MobileTableGroup extends MobileTableGroup_base {
     static styles: import("lit").CSSResult;
+    collapsed$: import("@preact/signals-core").Signal<boolean>;
+    private storageLoaded;
+    /**
+     * Read the stored collapsed state once, as soon as the group and its view
+     * are both known. Reading it earlier would key the lookup on a missing view
+     * id and pin the group open.
+     */
+    private _loadCollapsedState;
+    private readonly _toggleCollapse;
     private readonly clickAddRow;
     private readonly clickAddRowInStart;
     private readonly clickGroupOptions;
     private readonly renderGroupHeader;
     get rows(): Row[];
     private renderRows;
+    willUpdate(changed: Map<PropertyKey, unknown>): void;
+    connectedCallback(): void;
     render(): import("lit-html").TemplateResult<1>;
     accessor group: Group | undefined;
     accessor tableViewLogic: MobileTableViewUILogic;

package/dist/_pkgs/data-view/view-presets/table/mobile/group.js

@@ -34,13 +34,15 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { menu, popFilterableSimpleMenu, popupTargetFromElement, } from '../../../../affine-components/context-menu/index.js';
 import { SignalWatcher, WithDisposable } from '../../../../global/lit/index.js';
-import { PlusIcon } from '@blocksuite/icons/lit';
+import { PlusIcon, ToggleDownIcon, ToggleRightIcon, } from '@blocksuite/icons/lit';
 import { ShadowlessElement } from '../../../../std/index.js';
+import { signal } from '@preact/signals-core';
 import { cssVarV2 } from '@toeverything/theme/v2';
-import { css, html, unsafeCSS } from 'lit';
+import { css, html, nothing, unsafeCSS } from 'lit';
 import { property } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { GroupTitle } from '../../../core/group-by/group-title.js';
+import { getCollapsedState, setCollapsedState } from '../collapsed-state.js';
 import { LEFT_TOOL_BAR_WIDTH } from '../consts.js';
 const styles = css `
   .data-view-table-group-add-row {
@@ -67,6 +69,28 @@ const styles = css `
     line-height: 20px;
     color: var(--affine-text-secondary-color);
   }
+
+  .group-toggle-btn {
+    width: 20px;
+    height: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background-color 150ms cubic-bezier(0.42, 0, 1, 1);
+  }
+
+  .group-toggle-btn:hover {
+    background: var(--affine-hover-color);
+  }
+
+  .group-toggle-btn svg {
+    width: 16px;
+    height: 16px;
+    flex-shrink: 0;
+    user-select: none;
+  }
 `;
 let MobileTableGroup = (() => {
     let _classSuper = SignalWatcher(WithDisposable(ShadowlessElement));
@@ -86,6 +110,20 @@ let MobileTableGroup = (() => {
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static { this.styles = styles; }
+        /**
+         * Read the stored collapsed state once, as soon as the group and its view
+         * are both known. Reading it earlier would key the lookup on a missing view
+         * id and pin the group open.
+         */
+        _loadCollapsedState() {
+            if (this.storageLoaded)
+                return;
+            this.storageLoaded = true;
+            const view = this.tableViewLogic?.view;
+            if (!view)
+                return;
+            this.collapsed$.value = getCollapsedState(view.id, this.group?.key ?? 'all');
+        }
         get rows() {
             return this.group?.rows ?? this.view.rows$.value;
         }
@@ -122,8 +160,24 @@ let MobileTableGroup = (() => {
           </div>`}
     `;
         }
+        willUpdate(changed) {
+            super.willUpdate(changed);
+            if (!this.storageLoaded &&
+                (changed.has('group') || changed.has('tableViewLogic'))) {
+                this._loadCollapsedState();
+            }
+        }
+        connectedCallback() {
+            super.connectedCallback();
+            this._loadCollapsedState();
+        }
         render() {
-            return this.renderRows(this.rows);
+            // Collapsed, only the header survives — the column header, the rows and
+            // the add-row affordance all fold away with them.
+            return html `
+      ${this.collapsed$.value ? this.renderGroupHeader() : nothing}
+      ${this.collapsed$.value ? nothing : this.renderRows(this.rows)}
+    `;
         }
         #group_accessor_storage;
         get group() { return this.#group_accessor_storage; }
@@ -136,6 +190,17 @@ let MobileTableGroup = (() => {
         }
         constructor() {
             super(...arguments);
+            this.collapsed$ = signal(false);
+            this.storageLoaded = false;
+            this._toggleCollapse = (e) => {
+                e?.stopPropagation();
+                const next = !this.collapsed$.value;
+                this.collapsed$.value = next;
+                const view = this.tableViewLogic?.view;
+                if (view) {
+                    setCollapsedState(view.id, this.group?.key ?? 'all', next);
+                }
+            };
             this.clickAddRow = () => {
                 this.view.rowAdd('end', this.group?.key);
                 this.requestUpdate();
@@ -175,8 +240,28 @@ let MobileTableGroup = (() => {
                 }
                 return html `
       <div
-        style="position: sticky;left: 0;width: max-content;padding: 6px 0;margin-bottom: 4px;display:flex;align-items:center;gap: 12px;max-width: 400px"
+        style="position: sticky;left: 0;width: max-content;padding: 6px 0;margin-bottom: 4px;display:flex;align-items:center;gap: 8px;max-width: 400px"
       >
+        <div
+          class="group-toggle-btn"
+          role="button"
+          aria-expanded=${this.collapsed$.value ? 'false' : 'true'}
+          aria-label=${this.collapsed$.value
+                    ? 'Expand group'
+                    : 'Collapse group'}
+          tabindex="0"
+          @click=${this._toggleCollapse}
+          @keydown=${(e) => {
+                    if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        this._toggleCollapse();
+                    }
+                }}
+        >
+          ${this.collapsed$.value
+                    ? ToggleRightIcon({ width: '16px', height: '16px' })
+                    : ToggleDownIcon({ width: '16px', height: '16px' })}
+        </div>
         ${GroupTitle(this.group, {
                     readonly: this.view.readonly$.value,
                     clickAdd: this.clickAddRowInStart,

package/dist/_pkgs/data-view/view-presets/table/pc/cell.d.ts

@@ -9,6 +9,9 @@ export declare class TableViewCellContainer extends TableViewCellContainer_base
     private readonly _cell$;
     accessor column: TableProperty;
     accessor rowId: string;
+    private _tagDraft;
+    setTagDraft(value: string): void;
+    consumeTagDraft(): string | undefined;
     cell$: import("@preact/signals-core").ReadonlySignal<import("../../../index.js").Cell<unknown, unknown, Record<string, unknown>>>;
     selectCurrentCell: (editing: boolean) => void;
     get cell(): DataViewCellLifeCycle | undefined;

package/dist/_pkgs/data-view/view-presets/table/pc/cell.js

@@ -100,6 +100,14 @@ let TableViewCellContainer = (() => {
         #rowId_accessor_storage;
         get rowId() { return this.#rowId_accessor_storage; }
         set rowId(value) { this.#rowId_accessor_storage = value; }
+        setTagDraft(value) {
+            this._tagDraft = value;
+        }
+        consumeTagDraft() {
+            const value = this._tagDraft;
+            this._tagDraft = undefined;
+            return value;
+        }
         get cell() {
             return this._cell$.value;
         }
@@ -169,9 +177,10 @@ let TableViewCellContainer = (() => {
             this._cell$ = signal();
             this.#column_accessor_storage = __runInitializers(this, _column_initializers, void 0);
             this.#rowId_accessor_storage = (__runInitializers(this, _column_extraInitializers), __runInitializers(this, _rowId_initializers, void 0));
-            this.cell$ = (__runInitializers(this, _rowId_extraInitializers), computed(() => {
+            this._tagDraft = __runInitializers(this, _rowId_extraInitializers);
+            this.cell$ = computed(() => {
                 return this.column.cellGetOrCreate(this.rowId);
-            }));
+            });
             this.selectCurrentCell = (editing) => {
                 if (this.view.readonly$.value) {
                     return;

package/dist/_pkgs/data-view/view-presets/table/pc/controller/hotkeys.d.ts

@@ -5,5 +5,6 @@ export declare class TableHotkeysController implements ReactiveController {
     get selectionController(): import("./selection.js").TableSelectionController;
     constructor(logic: TableViewUILogic);
     get host(): import("../table-view-ui-logic.js").TableViewUI | undefined;
+    private _handleDeleteOrBackspace;
     hostConnected(): void;
 }

package/dist/_pkgs/data-view/view-presets/table/pc/controller/hotkeys.js

@@ -12,39 +12,26 @@ export class TableHotkeysController {
     get host() {
         return this.logic.ui$.value;
     }
-    hostConnected() {
-        this.host?.disposables.add(this.logic.bindHotkey({
-            Backspace: () => {
-                const selection = this.selectionController.selection;
-                if (!selection) {
-                    return;
-                }
-                if (TableViewRowSelection.is(selection)) {
-                    const rows = TableViewRowSelection.rowsIds(selection);
-                    this.selectionController.selection = undefined;
-                    this.logic.view.rowsDelete(rows);
-                    this.logic.ui$.value?.requestUpdate();
-                    return;
-                }
-                const { focus, rowsSelection, columnsSelection, isEditing, groupKey, } = selection;
-                if (focus && !isEditing) {
-                    if (rowsSelection && columnsSelection) {
-                        // multi cell
-                        for (let i = rowsSelection.start; i <= rowsSelection.end; i++) {
-                            const { start, end } = columnsSelection;
-                            for (let j = start; j <= end; j++) {
-                                const container = this.selectionController.getCellContainer(groupKey, i, j);
-                                const rowId = container?.dataset.rowId;
-                                const columnId = container?.dataset.columnId;
-                                if (rowId && columnId) {
-                                    container?.column.valueSetFromString(rowId, '');
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        // single cell
-                        const container = this.selectionController.getCellContainer(groupKey, focus.rowIndex, focus.columnIndex);
+    _handleDeleteOrBackspace() {
+        const selection = this.selectionController.selection;
+        if (!selection) {
+            return;
+        }
+        if (TableViewRowSelection.is(selection)) {
+            const rows = TableViewRowSelection.rowsIds(selection);
+            this.selectionController.selection = undefined;
+            this.logic.view.rowsDelete(rows);
+            this.logic.ui$.value?.requestUpdate();
+            return;
+        }
+        const { focus, rowsSelection, columnsSelection, isEditing, groupKey } = selection;
+        if (focus && !isEditing) {
+            if (rowsSelection && columnsSelection) {
+                // multi cell
+                for (let i = rowsSelection.start; i <= rowsSelection.end; i++) {
+                    const { start, end } = columnsSelection;
+                    for (let j = start; j <= end; j++) {
+                        const container = this.selectionController.getCellContainer(groupKey, i, j);
                         const rowId = container?.dataset.rowId;
                         const columnId = container?.dataset.columnId;
                         if (rowId && columnId) {
@@ -52,6 +39,25 @@ export class TableHotkeysController {
                         }
                     }
                 }
+            }
+            else {
+                // single cell
+                const container = this.selectionController.getCellContainer(groupKey, focus.rowIndex, focus.columnIndex);
+                const rowId = container?.dataset.rowId;
+                const columnId = container?.dataset.columnId;
+                if (rowId && columnId) {
+                    container?.column.valueSetFromString(rowId, '');
+                }
+            }
+        }
+    }
+    hostConnected() {
+        this.host?.disposables.add(this.logic.bindHotkey({
+            Backspace: () => {
+                this._handleDeleteOrBackspace();
+            },
+            Delete: () => {
+                this._handleDeleteOrBackspace();
             },
             Escape: () => {
                 const selection = this.selectionController.selection;

package/dist/_pkgs/data-view/view-presets/table/pc/group.d.ts

@@ -5,6 +5,15 @@ import type { TableViewUILogic } from './table-view-ui-logic.js';
 declare const TableGroup_base: typeof ShadowlessElement & import("../../../../global/utils/types.js").Constructor<import("../../../../global/lit/with-disposable.js").DisposableClass>;
 export declare class TableGroup extends TableGroup_base {
     static styles: import("lit").CSSResult;
+    collapsed$: import("@preact/signals-core").Signal<boolean>;
+    private storageLoaded;
+    /**
+     * Read the stored collapsed state once, as soon as the group and its view
+     * are both known. Reading it earlier would key the lookup on a missing view
+     * id and pin the group open.
+     */
+    private _loadCollapsedState;
+    private readonly _toggleCollapse;
     private readonly clickAddRow;
     private readonly clickAddRowInStart;
     private readonly clickGroupOptions;
@@ -14,6 +23,7 @@ export declare class TableGroup extends TableGroup_base {
     showIndicator: () => void;
     get rows(): Row[];
     private renderRows;
+    willUpdate(changed: Map<PropertyKey, unknown>): void;
     connectedCallback(): void;
     render(): import("lit-html").TemplateResult<1>;
     accessor rowsContainer: HTMLElement | null;