@formicoidea/labre-core 1.0.0 → 2.0.0

package/dist/_pkgs/affine-database-engine/view-presets/calendar/layout.js

@@ -1,138 +0,0 @@
-const startOfDay = (date) => new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
-const addDays = (date, days) => {
-    const current = new Date(date);
-    return startOfDay(new Date(current.getFullYear(), current.getMonth(), current.getDate() + days));
-};
-const endOfDay = (date) => addDays(date, 1) - 1;
-const toDate = (value) => value instanceof Date ? value : new Date(value);
-export const getCalendarVisibleMonthRange = (month, weekStartsOn = 0) => {
-    const cursor = toDate(month);
-    const monthStart = new Date(cursor.getFullYear(), cursor.getMonth(), 1);
-    const monthEnd = new Date(cursor.getFullYear(), cursor.getMonth() + 1, 0);
-    const startOffset = (monthStart.getDay() - weekStartsOn + 7) % 7;
-    const endOffset = (weekStartsOn + 6 - monthEnd.getDay() + 7) % 7;
-    const from = startOfDay(new Date(monthStart.getFullYear(), monthStart.getMonth(), monthStart.getDate() - startOffset));
-    const to = endOfDay(startOfDay(new Date(monthEnd.getFullYear(), monthEnd.getMonth(), monthEnd.getDate() + endOffset)));
-    return {
-        from,
-        to,
-        monthStart: startOfDay(monthStart),
-        monthEnd: endOfDay(startOfDay(monthEnd)),
-    };
-};
-const isRangeEntry = (entry) => entry.endAt != null &&
-    getRangeEndDay(entry) > startOfDay(new Date(entry.startAt));
-const getRangeEndDay = (entry) => {
-    const endAt = entry.endAt ?? entry.startAt;
-    const end = new Date(endAt);
-    if (entry.kind === 'external' &&
-        entry.allDay &&
-        endAt > entry.startAt &&
-        end.getHours() === 0 &&
-        end.getMinutes() === 0 &&
-        end.getSeconds() === 0 &&
-        end.getMilliseconds() === 0) {
-        return addDays(startOfDay(end), -1);
-    }
-    return startOfDay(end);
-};
-const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
-const getDayOffset = (days, date) => days.findIndex(day => day.date === date);
-const assignSegmentSlots = (weeks, segments) => {
-    for (let weekIndex = 0; weekIndex < weeks.length; weekIndex++) {
-        const weekSegments = segments.filter(segment => segment.weekIndex === weekIndex);
-        const slots = [];
-        for (const segment of weekSegments) {
-            let slot = 0;
-            while (slots[slot]?.some((occupied, index) => occupied &&
-                index >= segment.startIndex &&
-                index < segment.startIndex + segment.span)) {
-                slot++;
-            }
-            const slotDays = (slots[slot] ??= Array.from({ length: 7 }, () => false));
-            for (let index = segment.startIndex; index < segment.startIndex + segment.span; index++) {
-                slotDays[index] = true;
-            }
-            segment.slot = slot;
-        }
-    }
-};
-export const getCalendarDaySegmentSlots = (day, ignoredEntryId) => {
-    return Math.max(0, ...day.segments
-        .filter(segment => segment.entry.id !== ignoredEntryId)
-        .map(segment => segment.slot + 1));
-};
-export const getCalendarDayContentSlots = (day, ignoredEntryId) => {
-    return (getCalendarDaySegmentSlots(day, ignoredEntryId) +
-        day.entries.filter(entry => entry.id !== ignoredEntryId).length);
-};
-export const createCalendarMonthLayout = ({ month, entries, weekStartsOn = 0, }) => {
-    const range = getCalendarVisibleMonthRange(month, weekStartsOn);
-    const cursor = toDate(month);
-    const days = [];
-    const dayByTime = new Map();
-    for (let date = range.from; date <= range.to; date = addDays(date, 1)) {
-        const day = {
-            date,
-            inMonth: new Date(date).getMonth() === cursor.getMonth() &&
-                new Date(date).getFullYear() === cursor.getFullYear(),
-            entries: [],
-            segments: [],
-        };
-        days.push(day);
-        dayByTime.set(date, day);
-    }
-    for (const entry of entries) {
-        if (isRangeEntry(entry)) {
-            continue;
-        }
-        const day = dayByTime.get(startOfDay(new Date(entry.startAt)));
-        if (day) {
-            day.entries.push(entry);
-        }
-    }
-    const segments = [];
-    const rangeEntries = entries.filter(isRangeEntry);
-    const visibleEndDay = startOfDay(new Date(range.to));
-    for (const entry of rangeEntries) {
-        const entryStart = startOfDay(new Date(entry.startAt));
-        const entryEnd = getRangeEndDay(entry);
-        if (entryEnd < range.from || entryStart > visibleEndDay) {
-            continue;
-        }
-        const start = clamp(entryStart, range.from, visibleEndDay);
-        const end = clamp(entryEnd, range.from, visibleEndDay);
-        const startOffset = getDayOffset(days, start);
-        const endOffset = getDayOffset(days, end);
-        if (startOffset < 0 || endOffset < 0) {
-            continue;
-        }
-        let offset = startOffset;
-        while (offset <= endOffset) {
-            const weekIndex = Math.floor(offset / 7);
-            const startIndex = offset % 7;
-            const weekEndOffset = weekIndex * 7 + 6;
-            const span = Math.min(endOffset, weekEndOffset) - offset + 1;
-            const segment = {
-                entry,
-                weekIndex,
-                startIndex,
-                span,
-                slot: 0,
-                startsBeforeWeek: startOffset < weekIndex * 7,
-                endsAfterWeek: endOffset > weekEndOffset,
-            };
-            segments.push(segment);
-            for (let index = 0; index < span; index++) {
-                days[offset + index]?.segments.push(segment);
-            }
-            offset += span;
-        }
-    }
-    const weeks = [];
-    for (let index = 0; index < days.length; index += 7) {
-        weeks.push(days.slice(index, index + 7));
-    }
-    assignSegmentSlots(weeks, segments);
-    return { from: range.from, to: range.to, weeks, days, segments };
-};

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/actions.d.ts

@@ -1,7 +0,0 @@
-import type { DataViewRootUILogic } from '../../../core/data-view.js';
-import type { CalendarSingleView } from '../calendar-view-manager.js';
-import type { CalendarEntry } from '../types.js';
-export declare const formatEntryTime: (entry: CalendarEntry) => string;
-export declare const openCalendarEntry: (root: DataViewRootUILogic, view: CalendarSingleView, entry: CalendarEntry, target: HTMLElement, options?: {
-    selectEntry?: (entryId: string | undefined) => void;
-}) => void;

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/actions.js

@@ -1,64 +0,0 @@
-import { popMenu, popupTargetFromElement, } from '../../../../affine-components/context-menu/index.js';
-import { CalendarPanelIcon, DateTimeIcon, PinIcon, TextIcon, } from '@blocksuite/icons/lit';
-import { html } from 'lit';
-const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
-    dateStyle: 'medium',
-    timeStyle: 'short',
-});
-const dateFormatter = new Intl.DateTimeFormat(undefined, {
-    dateStyle: 'medium',
-});
-export const formatEntryTime = (entry) => {
-    const formatter = entry.allDay ? dateFormatter : dateTimeFormatter;
-    const start = formatter.format(new Date(entry.startAt));
-    if (!entry.endAt) {
-        return start;
-    }
-    return `${start} - ${formatter.format(new Date(entry.endAt))}`;
-};
-export const openCalendarEntry = (root, view, entry, target, options) => {
-    if (entry.kind === 'row') {
-        options?.selectEntry?.(entry.id);
-        root.openDetailPanel({
-            view,
-            rowId: entry.rowId,
-            onClose: () => options?.selectEntry?.(undefined),
-        });
-        return;
-    }
-    popMenu(popupTargetFromElement(target), {
-        options: {
-            items: [
-                () => html `
-          <div class="calendar-event-popover">
-            <div class="calendar-event-popover-title">${entry.title}</div>
-            <div class="calendar-event-popover-row">
-              <span class="calendar-event-popover-icon"
-                >${CalendarPanelIcon()}</span
-              >
-              <span>${entry.calendarName ?? 'Calendar event'}</span>
-            </div>
-            <div class="calendar-event-popover-row">
-              <span class="calendar-event-popover-icon">${DateTimeIcon()}</span>
-              <span>${formatEntryTime(entry)}</span>
-            </div>
-            ${entry.location
-                    ? html `<div class="calendar-event-popover-row">
-                  <span class="calendar-event-popover-icon">${PinIcon()}</span>
-                  <span>${entry.location}</span>
-                </div>`
-                    : ''}
-            ${entry.description
-                    ? html `<div class="calendar-event-popover-row">
-                  <span class="calendar-event-popover-icon">${TextIcon()}</span>
-                  <span class="calendar-event-popover-description"
-                    >${entry.description}</span
-                  >
-                </div>`
-                    : ''}
-          </div>
-        `,
-            ],
-        },
-    });
-};

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/dnd.d.ts

@@ -1,32 +0,0 @@
-import type { DndController } from '../../../../std/index.js';
-import type { CalendarEntry, CalendarRowEntry } from '../types.js';
-export type CalendarDndEntity = {
-    type: 'calendar-entry';
-    entryId: string;
-} | {
-    type: 'doc';
-    docId: string;
-};
-export declare const getCalendarDndEntity: (data: unknown) => CalendarDndEntity | undefined;
-export type CalendarDndCallbacks = {
-    getEntry: (entryId: string) => CalendarEntry | undefined;
-    canDragEntry: () => boolean;
-    canDrop: (entity: CalendarDndEntity) => boolean;
-    onEntryDragStart: (entry: CalendarRowEntry) => void;
-    onEntryDragEnd: () => void;
-    onDropTargetChange: (date: number | undefined, entity?: CalendarDndEntity) => void;
-    onDrop: (entity: CalendarDndEntity, date: number) => void;
-};
-export declare class CalendarDnd {
-    private readonly dnd;
-    private readonly callbacks;
-    private readonly entryCleanups;
-    private rootCleanup?;
-    constructor(dnd: DndController | undefined, callbacks: CalendarDndCallbacks);
-    bindRoot(element?: Element): void;
-    bindEntry(key: string, entry: CalendarEntry, element?: Element, disabled?: boolean): void;
-    cleanup(): void;
-    private cleanupEntry;
-    private cleanupRoot;
-    private updateDropTarget;
-}

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/dnd.js

@@ -1,159 +0,0 @@
-import { getCalendarDateFromPoint } from './hit-test.js';
-const isRecord = (value) => typeof value === 'object' && value !== null;
-export const getCalendarDndEntity = (data) => {
-    if (!isRecord(data)) {
-        return;
-    }
-    const bsEntity = data.bsEntity;
-    if (isRecord(bsEntity)) {
-        if (bsEntity.type === 'calendar-entry' &&
-            typeof bsEntity.entryId === 'string') {
-            return {
-                type: 'calendar-entry',
-                entryId: bsEntity.entryId,
-            };
-        }
-        if (bsEntity.type === 'doc' && typeof bsEntity.docId === 'string') {
-            return {
-                type: 'doc',
-                docId: bsEntity.docId,
-            };
-        }
-    }
-    const entity = data.entity;
-    if (isRecord(entity) &&
-        entity.type === 'doc' &&
-        typeof entity.id === 'string') {
-        return {
-            type: 'doc',
-            docId: entity.id,
-        };
-    }
-    return;
-};
-export class CalendarDnd {
-    constructor(dnd, callbacks) {
-        this.dnd = dnd;
-        this.callbacks = callbacks;
-        this.entryCleanups = new Map();
-    }
-    bindRoot(element) {
-        if (!this.dnd || !(element instanceof HTMLElement)) {
-            this.cleanupRoot();
-            return;
-        }
-        if (this.rootCleanup?.element === element) {
-            return;
-        }
-        this.cleanupRoot();
-        const cleanup = this.dnd.dropTarget({
-            element,
-            getIsSticky: () => true,
-            setDropData: ({ input }) => ({
-                date: getCalendarDateFromPoint(element, input.clientX, input.clientY),
-            }),
-            canDrop: ({ source, input }) => {
-                const entity = getCalendarDndEntity(source.data);
-                const date = getCalendarDateFromPoint(element, input.clientX, input.clientY);
-                return entity && date !== undefined
-                    ? this.callbacks.canDrop(entity)
-                    : false;
-            },
-            onDrag: ({ source, location }) => {
-                this.updateDropTarget(element, source.data, location.current.input);
-            },
-            onDragEnter: ({ source, location }) => {
-                this.updateDropTarget(element, source.data, location.current.input);
-            },
-            onDragLeave: () => {
-                this.callbacks.onDropTargetChange(undefined);
-            },
-            onDrop: ({ source, location }) => {
-                const entity = getCalendarDndEntity(source.data);
-                const date = getCalendarDateFromPoint(element, location.current.input.clientX, location.current.input.clientY);
-                if (entity && date !== undefined && this.callbacks.canDrop(entity)) {
-                    this.callbacks.onDrop(entity, date);
-                }
-                this.callbacks.onDropTargetChange(undefined);
-            },
-        });
-        this.rootCleanup = { element, cleanup };
-    }
-    bindEntry(key, entry, element, disabled = false) {
-        if (!this.dnd ||
-            !(element instanceof HTMLElement) ||
-            entry.kind !== 'row' ||
-            disabled) {
-            this.cleanupEntry(key);
-            if (element instanceof HTMLElement) {
-                element.setAttribute('draggable', 'false');
-            }
-            return;
-        }
-        const current = this.entryCleanups.get(key);
-        if (current?.element === element) {
-            return;
-        }
-        this.cleanupEntry(key);
-        const cleanup = this.dnd.draggable({
-            element,
-            canDrag: () => {
-                const currentEntry = this.callbacks.getEntry(entry.id);
-                return currentEntry?.kind === 'row'
-                    ? this.callbacks.canDragEntry()
-                    : false;
-            },
-            setDragData: () => ({
-                type: 'calendar-entry',
-                entryId: entry.id,
-            }),
-            setDragPreview: ({ container, setOffset }) => {
-                const currentEntry = this.callbacks.getEntry(entry.id);
-                const preview = document.createElement('div');
-                preview.textContent = currentEntry?.title || 'Untitled';
-                preview.style.cssText =
-                    'padding:0 6px;height:22px;line-height:22px;border-radius:4px;' +
-                        'font-size:12px;white-space:nowrap;overflow:hidden;' +
-                        'background:var(--affine-hover-color,#f5f5f5);' +
-                        'color:var(--affine-text-primary-color,#333);' +
-                        'max-width:140px;text-overflow:ellipsis;pointer-events:none;';
-                container.append(preview);
-                setOffset({ x: 10, y: 11 });
-            },
-            onDragStart: () => {
-                const currentEntry = this.callbacks.getEntry(entry.id);
-                if (currentEntry?.kind === 'row') {
-                    this.callbacks.onEntryDragStart(currentEntry);
-                }
-            },
-            onDrop: () => {
-                this.callbacks.onEntryDragEnd();
-            },
-        });
-        this.entryCleanups.set(key, { element, cleanup });
-    }
-    cleanup() {
-        this.cleanupRoot();
-        for (const key of this.entryCleanups.keys()) {
-            this.cleanupEntry(key);
-        }
-    }
-    cleanupEntry(key) {
-        this.entryCleanups.get(key)?.cleanup();
-        this.entryCleanups.delete(key);
-    }
-    cleanupRoot() {
-        this.rootCleanup?.cleanup();
-        this.rootCleanup = undefined;
-    }
-    updateDropTarget(root, data, input) {
-        const entity = getCalendarDndEntity(data);
-        const date = getCalendarDateFromPoint(root, input.clientX, input.clientY);
-        if (entity && date !== undefined && this.callbacks.canDrop(entity)) {
-            this.callbacks.onDropTargetChange(date, entity);
-        }
-        else {
-            this.callbacks.onDropTargetChange(undefined);
-        }
-    }
-}

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/effect.d.ts

@@ -1 +0,0 @@
-export declare function pcEffects(): void;

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/effect.js

@@ -1,7 +0,0 @@
-import { CalendarViewUI } from './view.js';
-export function pcEffects() {
-    if (customElements.get('affine-data-view-calendar')) {
-        return;
-    }
-    customElements.define('affine-data-view-calendar', CalendarViewUI);
-}

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/hit-test.d.ts

@@ -1 +0,0 @@
-export declare const getCalendarDateFromPoint: (root: HTMLElement, clientX: number, clientY: number) => number | undefined;

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/hit-test.js

@@ -1,28 +0,0 @@
-export const getCalendarDateFromPoint = (root, clientX, clientY) => {
-    const doc = root.ownerDocument;
-    const hitStack = doc.elementsFromPoint(clientX, clientY);
-    for (const element of hitStack) {
-        const day = element.closest('.calendar-day[data-date]');
-        if (day && root.contains(day)) {
-            return Number(day.dataset['date']);
-        }
-    }
-    for (const element of hitStack) {
-        const week = element.closest('.calendar-week') ??
-            element.closest('.calendar-segments')?.parentElement;
-        if (week && root.contains(week)) {
-            const days = week.querySelectorAll('.calendar-day');
-            for (const day of days) {
-                const rect = day.getBoundingClientRect();
-                if (clientX >= rect.left &&
-                    clientX < rect.right &&
-                    clientY >= rect.top &&
-                    clientY < rect.bottom &&
-                    day.dataset['date']) {
-                    return Number(day.dataset['date']);
-                }
-            }
-        }
-    }
-    return;
-};

package/dist/_pkgs/affine-database-engine/view-presets/calendar/pc/styles.d.ts

@@ -1 +0,0 @@
-export declare const calendarViewStyles: import("lit").CSSResult;