@formicoidea/labre-core 0.30.1 → 0.32.0

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

@@ -1,4 +1,4 @@
-import type { KanbanViewSelectionWithType, TableViewSelectionWithType } from '../view-presets';
+import type { KanbanViewSelectionWithType, TableViewSelectionWithType } from '../view-presets/index.js';
 export type DataViewSelection = TableViewSelectionWithType | KanbanViewSelectionWithType;
 export type DataViewSelectionState = DataViewSelection | undefined;
 export type PropertyDataUpdater<Data extends Record<string, unknown> = Record<string, unknown>> = (data: Data) => Partial<Data>;

package/dist/_pkgs/data-view/core/utils/menu-title.js

@@ -1,22 +1,22 @@
 import { ArrowLeftBigIcon } from '@blocksuite/icons/lit';
 import { html } from 'lit';
 export const menuTitle = (name, onBack) => {
-    return html `
-    <div
-      style="display:flex;align-items:center;gap: 4px;padding: 3px 3px 3px 2px"
-    >
-      <div
-        @click=${onBack}
-        class="dv-icon-20 dv-hover dv-pd-2 dv-round-4"
-        style="display:flex;"
-      >
-        ${ArrowLeftBigIcon()}
-      </div>
-      <div
-        style="font-weight:500;font-size: 14px;line-height: 22px;color: var(--affine-text-primary-color)"
-      >
-        ${name}
-      </div>
-    </div>
+    return html `
+    <div
+      style="display:flex;align-items:center;gap: 4px;padding: 3px 3px 3px 2px"
+    >
+      <div
+        @click=${onBack}
+        class="dv-icon-20 dv-hover dv-pd-2 dv-round-4"
+        style="display:flex;"
+      >
+        ${ArrowLeftBigIcon()}
+      </div>
+      <div
+        style="font-weight:500;font-size: 14px;line-height: 22px;color: var(--affine-text-primary-color)"
+      >
+        ${name}
+      </div>
+    </div>
   `;
 };

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

@@ -1,5 +1,5 @@
-export * from './cell';
-export * from './property';
-export * from './row';
+export * from './cell.js';
+export * from './property.js';
+export * from './row.js';
 export * from './single-view.js';
 export * from './view-manager.js';

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

@@ -1,5 +1,5 @@
-export * from './cell';
-export * from './property';
-export * from './row';
+export * from './cell.js';
+export * from './property.js';
+export * from './row.js';
 export * from './single-view.js';
 export * from './view-manager.js';

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

@@ -1,7 +1,7 @@
 import { popupTargetFromElement } from '../../../affine-components/context-menu/index.js';
 import { computed } from '@preact/signals-core';
 import { html } from 'lit/static-html.js';
-import { popTagSelect } from '../../core/component/tags/multi-tag-select.js';
+import { consumeTagDraftFromTableCellHost, popTagSelect, } from '../../core/component/tags/multi-tag-select.js';
 import { BaseCellRenderer } from '../../core/property/index.js';
 import { createFromBaseCellRenderer } from '../../core/property/renderer.js';
 import { stopPropagation } from '../../core/utils/event.js';
@@ -12,6 +12,7 @@ export class MultiSelectCell extends BaseCellRenderer {
     constructor() {
         super(...arguments);
         this.popTagSelect = () => {
+            const initialDraftText = consumeTagDraftFromTableCellHost(this);
             this.closePopup = popTagSelect(popupTargetFromElement(this), {
                 name: this.cell.property.name$.value,
                 options: this.options$,
@@ -22,6 +23,7 @@ export class MultiSelectCell extends BaseCellRenderer {
                 },
                 onComplete: this._editComplete,
                 minWidth: 400,
+                initialDraftText,
             });
         };
         this._editComplete = () => {

package/dist/_pkgs/data-view/property-presets/number/define.js

@@ -2,6 +2,7 @@ import zod from 'zod';
 import { t } from '../../core/logical/type-presets.js';
 import { propertyType } from '../../core/property/property-config.js';
 import { NumberPropertySchema } from './types.js';
+import { parseNumber } from './utils/formatter.js';
 export const numberPropertyType = propertyType('number');
 export const numberPropertyModelConfig = numberPropertyType.modelConfig({
     name: 'Number',
@@ -19,7 +20,7 @@ export const numberPropertyModelConfig = numberPropertyType.modelConfig({
         default: () => null,
         toString: ({ value }) => value?.toString() ?? '',
         fromString: ({ value }) => {
-            const num = value ? Number(value) : NaN;
+            const num = value ? parseNumber(value) : NaN;
             return { value: isNaN(num) ? null : num };
         },
         toJson: ({ value }) => value ?? null,

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

@@ -1,7 +1,7 @@
 import { popupTargetFromElement } from '../../../affine-components/context-menu/index.js';
 import { computed } from '@preact/signals-core';
 import { html } from 'lit/static-html.js';
-import { popTagSelect } from '../../core/component/tags/multi-tag-select.js';
+import { consumeTagDraftFromTableCellHost, popTagSelect, } from '../../core/component/tags/multi-tag-select.js';
 import { BaseCellRenderer } from '../../core/property/index.js';
 import { createFromBaseCellRenderer } from '../../core/property/renderer.js';
 import { createIcon } from '../../core/utils/uni-icon.js';
@@ -11,6 +11,7 @@ export class SelectCell extends BaseCellRenderer {
     constructor() {
         super(...arguments);
         this.popTagSelect = () => {
+            const initialDraftText = consumeTagDraftFromTableCellHost(this);
             this.closePopup = popTagSelect(popupTargetFromElement(this), {
                 name: this.cell.property.name$.value,
                 mode: 'single',
@@ -22,6 +23,7 @@ export class SelectCell extends BaseCellRenderer {
                 },
                 onComplete: this._editComplete,
                 minWidth: 400,
+                initialDraftText,
             });
         };
         this._editComplete = () => {

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

@@ -0,0 +1,70 @@
+import type { InsertToPosition } from '../../../affine-shared/utils/index.js';
+import { type ReadonlySignal } from '@preact/signals-core';
+import { FilterTrait } from '../../core/filter/trait.js';
+import { PropertyBase } from '../../core/view-manager/property.js';
+import { type Row, RowBase } from '../../core/view-manager/row.js';
+import { SingleViewBase } from '../../core/view-manager/single-view.js';
+import type { ViewManager } from '../../core/view-manager/view-manager.js';
+import type { CalendarEntry, CalendarEntryRange, CalendarExternalEntry, CalendarExternalSource, CalendarRowEntry, CalendarStoredViewData } from './types.js';
+export type CalendarDateMapping = {
+    status: 'ready';
+    propertyId: string;
+} | {
+    status: 'setup';
+    propertyId?: string;
+};
+export declare class CalendarSingleView extends SingleViewBase<CalendarStoredViewData> {
+    private readonly externalEntries$;
+    private externalEntriesRequestId;
+    propertiesRaw$: ReadonlySignal<CalendarProperty[]>;
+    properties$: ReadonlySignal<CalendarProperty[]>;
+    detailProperties$: ReadonlySignal<CalendarProperty[]>;
+    private readonly filter$;
+    private readonly sortList$;
+    emptyMonthHintDismissed$: ReadonlySignal<boolean>;
+    private readonly sortManager;
+    filterTrait: FilterTrait;
+    mainProperties$: ReadonlySignal<{
+        titleColumn: string | undefined;
+    }>;
+    readonly$: ReadonlySignal<boolean>;
+    dateProperties$: ReadonlySignal<CalendarProperty[]>;
+    dateMapping$: ReadonlySignal<CalendarDateMapping>;
+    startDateMapping$: ReadonlySignal<CalendarDateMapping>;
+    endDateMapping$: ReadonlySignal<CalendarDateMapping>;
+    private readonly visibleCardProperties$;
+    rowEntries$: ReadonlySignal<CalendarRowEntry[]>;
+    entries$: ReadonlySignal<CalendarEntry[]>;
+    externalSources$: ReadonlySignal<CalendarExternalSource[]>;
+    get type(): string;
+    constructor(viewManager: ViewManager, viewId: string);
+    isShow(rowId: string): boolean;
+    rowsMapping(rows: Row[]): Row[];
+    propertyGetOrCreate(propertyId: string): CalendarProperty;
+    rowGetOrCreate(rowId: string): CalendarRow;
+    setStartDateColumn(propertyId: string): void;
+    setDateColumn(propertyId: string): void;
+    setEndDateColumn(propertyId: string | undefined): void;
+    setWorkspaceCalendarEnabled(enabled: boolean): void;
+    setWorkspaceCalendarSubscriptionIds(subscriptionIds?: string[]): void;
+    dismissEmptyMonthHint(): void;
+    getDocDisplayTitle(docId: string): string;
+    createStartDateColumn(): string | undefined;
+    createDateColumn(): string | undefined;
+    createEndDateColumn(): string | undefined;
+    createRowOnDate(date: number | Date): string | undefined;
+    createLinkedDocRowOnDate(date: number | Date, docId: string): string | undefined;
+    moveRowToDate(rowId: string, date: number | Date): void;
+    resizeRowRange(rowId: string, edge: 'start' | 'end', date: number | Date): void;
+    loadExternalEntries(range: CalendarEntryRange): Promise<CalendarExternalEntry[]>;
+}
+export declare class CalendarProperty extends PropertyBase {
+    hide$: ReadonlySignal<boolean>;
+    constructor(view: CalendarSingleView, propertyId: string);
+    hideSet(_hide: boolean): void;
+    move(_position: InsertToPosition): void;
+}
+export declare class CalendarRow extends RowBase {
+    readonly calendarView: CalendarSingleView;
+    constructor(calendarView: CalendarSingleView, rowId: string);
+}

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

@@ -0,0 +1,449 @@
+import { DocDisplayMetaProvider } from '../../../affine-shared/services/index.js';
+import { Text } from '../../../store/index.js';
+import { computed, signal } from '@preact/signals-core';
+import { Doc } from 'yjs';
+import { evalFilter } from '../../core/filter/eval.js';
+import { generateDefaultValues } from '../../core/filter/generate-default-values.js';
+import { FilterTrait, filterTraitKey } from '../../core/filter/trait.js';
+import { emptyFilterGroup } from '../../core/filter/utils.js';
+import { fromJson } from '../../core/property/utils.js';
+import { SortManager, sortTraitKey } from '../../core/sort/manager.js';
+import { PropertyBase } from '../../core/view-manager/property.js';
+import { RowBase } from '../../core/view-manager/row.js';
+import { SingleViewBase, } from '../../core/view-manager/single-view.js';
+import { getCalendarExternalSources } from './source.js';
+const getStartColumnId = (data) => data?.date?.startColumnId;
+const getEndColumnId = (data) => {
+    return data?.date?.endColumnId;
+};
+const getDateData = (data) => ({
+    ...data.date,
+    startColumnId: getStartColumnId(data),
+});
+const getCardData = (data) => {
+    if (data) {
+        return data.card;
+    }
+    return {
+        visiblePropertyIds: [],
+    };
+};
+const toTimestamp = (date) => date instanceof Date ? date.getTime() : date;
+const isValidTimestamp = (value) => typeof value === 'number' && Number.isFinite(value);
+const createLinkedDocTitle = (docId) => {
+    const text = new Text();
+    new Doc().getMap('root').set('text', text.yText);
+    text.applyDelta([
+        {
+            insert: ' ',
+            attributes: { reference: { type: 'LinkedPage', pageId: docId } },
+        },
+    ]);
+    return text;
+};
+const getTitleDeltas = (value) => typeof value === 'object' && value != null && 'deltas$' in value
+    ? value.deltas$?.value
+    : undefined;
+const getTitleSegments = (value, title, getLinkedDocTitle) => {
+    const deltas = getTitleDeltas(value);
+    if (!Array.isArray(deltas)) {
+        return;
+    }
+    const segments = deltas.flatMap(delta => {
+        const item = delta;
+        const linkedDoc = item.attributes?.reference?.type === 'LinkedPage' &&
+            typeof item.attributes.reference.pageId === 'string';
+        const referenceTitle = item.attributes?.reference?.title;
+        const resolvedLinkedDocTitle = linkedDoc && typeof item.attributes?.reference?.pageId === 'string'
+            ? getLinkedDocTitle?.(item.attributes.reference.pageId, typeof referenceTitle === 'string' ? referenceTitle : undefined)
+            : undefined;
+        const text = resolvedLinkedDocTitle ||
+            (linkedDoc && typeof referenceTitle === 'string' && referenceTitle
+                ? referenceTitle
+                : typeof item.insert === 'string'
+                    ? item.insert.trim()
+                    : '');
+        if (linkedDoc) {
+            return {
+                text,
+                linkedDoc,
+            };
+        }
+        if (!text) {
+            return [];
+        }
+        return {
+            text,
+        };
+    });
+    const normalizedSegments = segments.reduce((result, segment) => {
+        const previous = result.at(-1);
+        if (previous?.linkedDoc &&
+            !previous.text &&
+            !segment.linkedDoc &&
+            segment.text) {
+            previous.text = segment.text;
+            return result;
+        }
+        result.push(segment);
+        return result;
+    }, []);
+    if (!normalizedSegments.some(segment => segment.linkedDoc)) {
+        return;
+    }
+    if (!normalizedSegments.some(segment => segment.text)) {
+        return title
+            ? [...normalizedSegments, { text: title }]
+            : normalizedSegments;
+    }
+    return normalizedSegments;
+};
+export class CalendarSingleView extends SingleViewBase {
+    get type() {
+        return this.data$.value?.mode ?? 'calendar';
+    }
+    constructor(viewManager, viewId) {
+        super(viewManager, viewId);
+        this.externalEntries$ = signal([]);
+        this.externalEntriesRequestId = 0;
+        this.propertiesRaw$ = computed(() => {
+            return this.dataSource.properties$.value.map(id => this.propertyGetOrCreate(id));
+        });
+        this.properties$ = this.propertiesRaw$;
+        this.detailProperties$ = computed(() => {
+            return this.propertiesRaw$.value.filter(property => property.type$.value !== 'title');
+        });
+        this.filter$ = computed(() => {
+            return this.data$.value?.filter ?? emptyFilterGroup;
+        });
+        this.sortList$ = computed(() => {
+            return this.data$.value?.sort;
+        });
+        this.emptyMonthHintDismissed$ = computed(() => {
+            return this.data$.value?.ui?.emptyMonthHintDismissed ?? false;
+        });
+        this.sortManager = this.traitSet(sortTraitKey, new SortManager(this.sortList$, this, {
+            setSortList: sortList => {
+                this.dataUpdate(data => ({
+                    sort: {
+                        ...data.sort,
+                        ...sortList,
+                    },
+                }));
+            },
+        }));
+        this.filterTrait = this.traitSet(filterTraitKey, new FilterTrait(this.filter$, this, {
+            filterSet: (filter) => {
+                this.dataUpdate(() => ({ filter }));
+            },
+        }));
+        this.mainProperties$ = computed(() => {
+            const card = getCardData(this.data$.value);
+            return {
+                titleColumn: card.titleColumnId ??
+                    this.propertiesRaw$.value.find(property => property.type$.value === 'title')?.id,
+            };
+        });
+        this.readonly$ = computed(() => {
+            return this.manager.readonly$.value;
+        });
+        this.dateProperties$ = computed(() => {
+            return this.propertiesRaw$.value.filter(property => property.type$.value === 'date');
+        });
+        this.dateMapping$ = computed(() => {
+            const propertyId = getStartColumnId(this.data$.value);
+            if (propertyId &&
+                this.dataSource.properties$.value.includes(propertyId) &&
+                this.dataSource.propertyTypeGet(propertyId) === 'date') {
+                return {
+                    status: 'ready',
+                    propertyId,
+                };
+            }
+            return {
+                status: 'setup',
+                propertyId,
+            };
+        });
+        this.startDateMapping$ = this.dateMapping$;
+        this.endDateMapping$ = computed(() => {
+            const propertyId = getEndColumnId(this.data$.value);
+            if (propertyId &&
+                this.dataSource.properties$.value.includes(propertyId) &&
+                this.dataSource.propertyTypeGet(propertyId) === 'date') {
+                return {
+                    status: 'ready',
+                    propertyId,
+                };
+            }
+            return {
+                status: 'setup',
+                propertyId,
+            };
+        });
+        this.visibleCardProperties$ = computed(() => {
+            const card = getCardData(this.data$.value);
+            const visiblePropertyIds = card.visiblePropertyIds ?? [];
+            const titleColumn = card.titleColumnId;
+            return visiblePropertyIds
+                .filter(propertyId => propertyId !== titleColumn)
+                .map(propertyId => this.propertyGetOrCreate(propertyId));
+        });
+        this.rowEntries$ = computed(() => {
+            const mapping = this.dateMapping$.value;
+            if (mapping.status !== 'ready') {
+                return [];
+            }
+            const endMapping = this.endDateMapping$.value;
+            return this.rows$.value.flatMap(row => {
+                const startAt = this.cellGetOrCreate(row.rowId, mapping.propertyId)
+                    .jsonValue$.value;
+                if (!isValidTimestamp(startAt)) {
+                    return [];
+                }
+                const endAt = endMapping.status === 'ready'
+                    ? this.cellGetOrCreate(row.rowId, endMapping.propertyId).jsonValue$
+                        .value
+                    : undefined;
+                const titleColumn = this.mainProperties$.value.titleColumn ?? 'title';
+                const titleCell = this.cellGetOrCreate(row.rowId, titleColumn);
+                const jsonTitle = titleCell.jsonValue$.value;
+                const title = (typeof jsonTitle === 'string'
+                    ? jsonTitle
+                    : titleCell.stringValue$.value) ?? '';
+                const docDisplayMeta = this.manager.dataSource.serviceGet(DocDisplayMetaProvider);
+                const resolveLinkedDocTitle = (pageId, title) => docDisplayMeta?.title(pageId, { title }).value;
+                const titleSegments = getTitleSegments(titleCell.value$.value, title, resolveLinkedDocTitle);
+                const cardProperties = this.visibleCardProperties$.value.flatMap(property => {
+                    const cell = this.cellGetOrCreate(row.rowId, property.id);
+                    const value = cell.stringValue$.value;
+                    if (!value) {
+                        return [];
+                    }
+                    return {
+                        propertyId: property.id,
+                        value,
+                    };
+                });
+                return {
+                    kind: 'row',
+                    id: `database:${row.rowId}`,
+                    sourceId: 'database',
+                    rowId: row.rowId,
+                    title,
+                    startAt,
+                    endAt: isValidTimestamp(endAt) && endAt >= startAt ? endAt : undefined,
+                    titleSegments,
+                    cardProperties,
+                    canResizeRange: endMapping.status === 'ready' && !this.readonly$.value,
+                };
+            });
+        });
+        this.entries$ = computed(() => {
+            return [...this.rowEntries$.value, ...this.externalEntries$.value];
+        });
+        this.externalSources$ = computed(() => {
+            const viewData = this.data$.value;
+            if (!viewData) {
+                return [];
+            }
+            return getCalendarExternalSources(this.dataSource, viewData);
+        });
+    }
+    isShow(rowId) {
+        if (this.filter$.value.conditions.length) {
+            const rowMap = Object.fromEntries(this.propertiesRaw$.value.map(column => [
+                column.id,
+                column.cellGetOrCreate(rowId).jsonValue$.value,
+            ]));
+            return evalFilter(this.filter$.value, rowMap);
+        }
+        return true;
+    }
+    rowsMapping(rows) {
+        return this.sortManager.sort(super.rowsMapping(rows));
+    }
+    propertyGetOrCreate(propertyId) {
+        return new CalendarProperty(this, propertyId);
+    }
+    rowGetOrCreate(rowId) {
+        return new CalendarRow(this, rowId);
+    }
+    setStartDateColumn(propertyId) {
+        this.dataUpdate(data => ({
+            date: {
+                ...getDateData(data),
+                startColumnId: propertyId,
+            },
+        }));
+    }
+    setDateColumn(propertyId) {
+        this.setStartDateColumn(propertyId);
+    }
+    setEndDateColumn(propertyId) {
+        this.dataUpdate(data => ({
+            date: {
+                ...getDateData(data),
+                endColumnId: propertyId,
+            },
+        }));
+    }
+    setWorkspaceCalendarEnabled(enabled) {
+        this.dataUpdate(data => ({
+            sources: {
+                ...data.sources,
+                workspaceCalendar: {
+                    ...(data.sources?.workspaceCalendar ?? { enabled: true }),
+                    enabled,
+                },
+            },
+        }));
+    }
+    setWorkspaceCalendarSubscriptionIds(subscriptionIds) {
+        this.dataUpdate(data => ({
+            sources: {
+                ...data.sources,
+                workspaceCalendar: {
+                    ...(data.sources?.workspaceCalendar ?? { enabled: true }),
+                    subscriptionIds,
+                },
+            },
+        }));
+    }
+    dismissEmptyMonthHint() {
+        this.dataUpdate(data => ({
+            ui: {
+                ...data.ui,
+                emptyMonthHintDismissed: true,
+            },
+        }));
+    }
+    getDocDisplayTitle(docId) {
+        return (this.manager.dataSource.serviceGet(DocDisplayMetaProvider)?.title(docId)
+            .value ?? 'Untitled');
+    }
+    createStartDateColumn() {
+        const id = this.propertyAdd('end', {
+            type: 'date',
+            name: 'Date',
+        });
+        if (id) {
+            this.setStartDateColumn(id);
+        }
+        return id;
+    }
+    createDateColumn() {
+        return this.createStartDateColumn();
+    }
+    createEndDateColumn() {
+        const id = this.propertyAdd('end', {
+            type: 'date',
+            name: 'End Date',
+        });
+        if (id) {
+            this.setEndDateColumn(id);
+        }
+        return id;
+    }
+    createRowOnDate(date) {
+        const mapping = this.startDateMapping$.value;
+        if (mapping.status !== 'ready') {
+            return;
+        }
+        const rowId = this.rowAdd('end');
+        const filter = this.filter$.value;
+        if (filter.conditions.length > 0) {
+            const defaultValues = generateDefaultValues(filter, this.vars$.value);
+            Object.entries(defaultValues).forEach(([propertyId, jsonValue]) => {
+                const property = this.propertyGetOrCreate(propertyId);
+                const propertyMeta = property.meta$.value;
+                if (propertyMeta) {
+                    const value = fromJson(propertyMeta.config, {
+                        value: jsonValue,
+                        data: property.data$.value,
+                        dataSource: this.dataSource,
+                    });
+                    this.cellGetOrCreate(rowId, propertyId).valueSet(value);
+                }
+            });
+        }
+        this.cellGetOrCreate(rowId, mapping.propertyId).jsonValueSet(toTimestamp(date));
+        this.dismissEmptyMonthHint();
+        return rowId;
+    }
+    createLinkedDocRowOnDate(date, docId) {
+        const rowId = this.createRowOnDate(date);
+        if (!rowId)
+            return;
+        const titleColumn = this.mainProperties$.value.titleColumn ?? 'title';
+        this.cellGetOrCreate(rowId, titleColumn).valueSet(createLinkedDocTitle(docId));
+        return rowId;
+    }
+    moveRowToDate(rowId, date) {
+        const mapping = this.startDateMapping$.value;
+        if (mapping.status !== 'ready') {
+            return;
+        }
+        const value = toTimestamp(date);
+        const oldStartAt = this.cellGetOrCreate(rowId, mapping.propertyId)
+            .jsonValue$.value;
+        const endMapping = this.endDateMapping$.value;
+        if (endMapping.status === 'ready' && isValidTimestamp(oldStartAt)) {
+            const oldEndAt = this.cellGetOrCreate(rowId, endMapping.propertyId)
+                .jsonValue$.value;
+            if (isValidTimestamp(oldEndAt) && oldEndAt >= oldStartAt) {
+                this.cellGetOrCreate(rowId, endMapping.propertyId).jsonValueSet(value + (oldEndAt - oldStartAt));
+            }
+        }
+        this.cellGetOrCreate(rowId, mapping.propertyId).jsonValueSet(value);
+    }
+    resizeRowRange(rowId, edge, date) {
+        const startMapping = this.startDateMapping$.value;
+        const endMapping = this.endDateMapping$.value;
+        if (startMapping.status !== 'ready' || endMapping.status !== 'ready') {
+            return;
+        }
+        const startCell = this.cellGetOrCreate(rowId, startMapping.propertyId);
+        const endCell = this.cellGetOrCreate(rowId, endMapping.propertyId);
+        const startAt = startCell.jsonValue$.value;
+        const endAt = endCell.jsonValue$.value;
+        if (!isValidTimestamp(startAt) || !isValidTimestamp(endAt)) {
+            return;
+        }
+        const value = toTimestamp(date);
+        if (edge === 'start') {
+            startCell.jsonValueSet(Math.min(value, endAt));
+        }
+        else {
+            endCell.jsonValueSet(Math.max(value, startAt));
+        }
+    }
+    async loadExternalEntries(range) {
+        const requestId = ++this.externalEntriesRequestId;
+        const viewData = this.data$.value;
+        if (!viewData) {
+            this.externalEntries$.value = [];
+            return [];
+        }
+        const results = await Promise.allSettled(this.externalSources$.value.map(source => Promise.resolve(source.getEntries(range))));
+        const entries = results.flatMap(result => result.status === 'fulfilled' ? result.value : []);
+        if (requestId === this.externalEntriesRequestId) {
+            this.externalEntries$.value = entries;
+        }
+        return entries;
+    }
+}
+export class CalendarProperty extends PropertyBase {
+    constructor(view, propertyId) {
+        super(view, propertyId);
+        this.hide$ = computed(() => false);
+    }
+    hideSet(_hide) { }
+    move(_position) { }
+}
+export class CalendarRow extends RowBase {
+    constructor(calendarView, rowId) {
+        super(calendarView, rowId);
+        this.calendarView = calendarView;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { CalendarViewData } from './types.js';
+export declare const calendarViewType: {
+    type: "calendar";
+    createModel: <Data extends import("../../index.js").DataViewDataType>(model: import("../../index.js").DataViewModelConfig<Data>) => import("../../index.js").DataViewModel<"calendar", Data> & {
+        createMeta: (renderer: import("../../index.js").DataViewRendererConfig) => import("../../index.js").ViewMeta<"calendar", Data>;
+    };
+};
+export declare const calendarViewModel: import("../../index.js").DataViewModel<"calendar", CalendarViewData> & {
+    createMeta: (renderer: import("../../index.js").DataViewRendererConfig) => import("../../index.js").ViewMeta<"calendar", CalendarViewData>;
+};