EventStore

import { EventStore } from '@forcecalendar/core';

Constructor

new EventStore(options?: { timezone?: string })

Event CRUD

Method	Signature	Returns
`addEvent`	`(data: EventData) => Event`	Created Event
`updateEvent`	`(id: string, updates: object) => Event`	Updated Event
`removeEvent`	`(id: string) => void`	—
`getEvent`	`(id: string) => Event \| undefined`	Event
`getAllEvents`	`() => Event[]`	All events
`clear`	`() => void`	—
`loadEvents`	`(events: EventData[]) => void`	—

Querying

Method	Signature	Returns
`queryEvents`	`(filters: QueryFilters) => Event[]`	Filtered events
`getEventsForDate`	`(date: Date, tz?: string) => Event[]`	Events on date
`getEventsInRange`	`(start: Date, end: Date, expand?: boolean, tz?: string) => Event[]`	Events in range
`getOverlappingEvents`	`(start: Date, end: Date, excludeId = null) => Event[]`	Overlapping events

QueryFilters

Field	Type
`start`	`Date`
`end`	`Date`
`date`	`Date`
`month`	`number`
`year`	`number`
`allDay`	`boolean`
`recurring`	`boolean`
`status`	`string`
`categories`	`string[]`
`hasAttendees`	`boolean`
`organizerEmail`	`string`
`sort`	`'start' \| 'end' \| 'title'`

Conflict Detection

Method	Signature	Returns
`hasConflicts`	`(start: Date, end: Date, excludeId = null) => boolean`	—
`checkConflicts`	`(event: Event, options?: object) => object`	Conflict details
`getAllConflicts`	`(start: Date, end: Date, options?: object) => Array<[Event, Event]>`	All conflict pairs
`getOverlapGroups`	`(date: Date, timedOnly = true) => Event[][]`	Overlap groups
`calculateEventPositions`	`(events: Event[]) => Map`	Positions
`getBusyPeriods`	`(attendeeEmails: string[], start: Date, end: Date, options?: object) => Array<{start, end}>`	Busy periods
`getFreePeriods`	`(start: Date, end: Date, durationMinutes: number, options?: object) => Array<{start, end}>`	Free periods
`addEventWithConflictCheck`	`(event: EventData, allowConflicts = true) => Event`	Created Event
`findEventsWithConflicts`	`() => Event[]`	Conflicting events

Batch Operations

Method	Signature	Returns
`startBatch`	`(enableRollback?: boolean) => void`	—
`commitBatch`	`() => void`	—
`rollbackBatch`	`() => void`	—
`executeBatch`	`(fn: Function, enableRollback?: boolean) => void`	—
`addEvents`	`(events: EventData[]) => Event[]`	Created events
`updateEvents`	`(updates: Array<{id, ...}>) => Event[]`	Updated events
`removeEvents`	`(ids: string[]) => void`	—

Recurrence

Method	Signature	Returns
`expandRecurringEvent`	`(event: Event, start: Date, end: Date) => Event[]`	Occurrences

Subscriptions

Method	Signature	Returns
`subscribe`	`(callback: Function) => Function`	Unsubscribe function

Lifecycle

Method	Signature	Returns
`destroy`	`() => void`	—

Snapshot and occurrence APIs

Method	Purpose
`reconcile(events, options?)`	Diff a complete snapshot; return added/updated/removed/unchanged
`resolveEventId(id)`	Resolve an occurrence identity to its master
`getOccurrence(id, timezone?)`	Read the specific occurrence
`iterateOccurrences(eventId, options?)`	Lazy single-use occurrence generator
`getNextOccurrence(eventId, after?, options?)`	Next occurrence or null
`takeOccurrences(eventId, count, options?)`	Bounded next occurrences

Reconcile options include removeMissing and isEquivalent. Lazy options include exclusive after/before bounds, inclusive and timezone. See the store guide.

On this page