ezux 1.1.13 → 1.1.18

package/dist/components/EzScheduler/services/CollisionDetectionService.d.ts

@@ -0,0 +1,19 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { SchedulerEvent } from '../EzScheduler.types';
+export declare class CollisionDetectionService implements IService {
+    name: string;
+    /**
+     * Checks if a new event overlaps with any existing events.
+     * @param event The event to check.
+     * @param events List of existing events.
+     * @returns True if overlap is found, otherwise false.
+     */
+    hasOverlap(event: SchedulerEvent, events: SchedulerEvent[]): boolean;
+    /**
+     * Groups events that overlap to determine rendering columns/positions.
+     * @param events Sorted list of events.
+     * @returns Array of event groups (arrays).
+     */
+    groupOverlappingEvents(events: SchedulerEvent[]): SchedulerEvent[][];
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/DragAndDropService.d.ts

@@ -0,0 +1,16 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { SchedulerEvent } from '../EzScheduler.types';
+import { DragEndEvent } from '@dnd-kit/core';
+export declare class DragAndDropService implements IService {
+    name: string;
+    calculateNewTimes(event: SchedulerEvent, deltaMinutes: number): {
+        start: Date;
+        end: Date;
+    };
+    handleDragEnd(event: DragEndEvent, events: SchedulerEvent[], _slotDuration?: number): {
+        eventId: string;
+        newStart: Date;
+        newEnd: Date;
+    } | null;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/HistoryService.d.ts

@@ -0,0 +1,31 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { BaseService } from '../../../shared/services/BaseService';
+import { SchedulerEvent } from '../EzScheduler.types';
+export interface HistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export type HistoryActionType = 'ADD_EVENT' | 'UPDATE_EVENT' | 'DELETE_EVENT' | 'BATCH_UPDATE';
+export interface HistoryAction {
+    type: HistoryActionType;
+    previousState: SchedulerEvent[] | SchedulerEvent | null;
+    newState: SchedulerEvent[] | SchedulerEvent | null;
+    timestamp: number;
+    description: string;
+}
+export declare class HistoryService extends BaseService<HistoryState> implements IService {
+    name: string;
+    private undoStack;
+    private redoStack;
+    private maxHistorySize;
+    constructor();
+    /**
+     * Records an action for potential undo
+     */
+    record(action: Omit<HistoryAction, 'timestamp'>): void;
+    undo(): HistoryAction | null;
+    redo(): HistoryAction | null;
+    clear(): void;
+    private updateState;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/ICalendarImportService.d.ts

@@ -0,0 +1,16 @@
+import { SchedulerEvent } from '../EzScheduler.types';
+/**
+ * Service for importing iCalendar (.ics) files
+ */
+export declare class ICalendarImportService {
+    /**
+     * Parse iCalendar content and convert to Scheduler events
+     */
+    parse(content: string | Blob): Promise<SchedulerEvent[]>;
+    private parseICalendarText;
+    private parseVEvent;
+    private unfoldLines;
+    private parseLine;
+    private parseDateTime;
+    private unescapeValue;
+}

package/dist/components/EzScheduler/services/PrintService.d.ts

@@ -0,0 +1,7 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { SchedulerEvent } from '../EzScheduler.types';
+export declare class PrintService implements IService {
+    name: string;
+    print(_schedulerElementId: string, _events: SchedulerEvent[]): void;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/RecurrenceEngine.d.ts

@@ -0,0 +1,7 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { SchedulerEvent } from '../EzScheduler.types';
+export declare class RecurrenceEngine implements IService {
+    name: string;
+    expandEvents(events: SchedulerEvent[], start: Date, end: Date): SchedulerEvent[];
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/ReminderService.d.ts

@@ -0,0 +1,17 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { SchedulerEvent, Reminder } from '../EzScheduler.types';
+export declare class ReminderService implements IService {
+    name: string;
+    private timer;
+    private checkInterval;
+    private onReminderTriggered?;
+    constructor();
+    start(onTrigger: (event: SchedulerEvent, reminder: Reminder) => void): void;
+    stop(): void;
+    private checkReminders;
+    /**
+     * Calculates trigger time for a reminder
+     */
+    getTriggerTime(eventStart: Date, minutesBefore: number): Date;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/SchedulerService.d.ts

@@ -0,0 +1,71 @@
+import { SchedulerEvent, Resource, ISchedulerService } from '../EzScheduler.types';
+/**
+ * Service for managing scheduler data and operations.
+ * @group Services
+ */
+export declare class SchedulerService implements ISchedulerService {
+    name: string;
+    private events;
+    private resources;
+    constructor(initialEvents?: SchedulerEvent[]);
+    /**
+     * Initializes the service.
+     * @group Methods
+     */
+    init(): Promise<void>;
+    /**
+     * Cleans up the service.
+     * @group Methods
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Seeds the mock database with initial data.
+     * @param events Initial events
+     * @param resources Initial resources
+     * @group Methods
+     */
+    initializeWithData(events: SchedulerEvent[], resources?: Resource[]): void;
+    /**
+     * Retrieves events within a date range.
+     * @param start Start date
+     * @param end End date
+     * @returns Promise resolving to an array of scheduler events
+     * @group Methods
+     */
+    getEvents(start?: Date, end?: Date): Promise<SchedulerEvent[]>;
+    /**
+     * Adds a new event to the scheduler.
+     * @param event The event to add
+     * @returns Promise resolving to the added event
+     * @group Methods
+     */
+    addEvent(event: Partial<SchedulerEvent>): Promise<SchedulerEvent>;
+    /**
+     * Updates an existing event.
+     * @param event The event to update
+     * @returns Promise resolving to the updated event
+     * @group Methods
+     */
+    updateEvent(event: SchedulerEvent): Promise<SchedulerEvent>;
+    /**
+     * Deletes an event by ID.
+     * @param id The ID of the event to delete
+     * @returns Promise void
+     * @group Methods
+     */
+    deleteEvent(id: string | number): Promise<void>;
+    /**
+     * Retrieves all resources.
+     * @returns Promise resolving to an array of resources
+     * @group Methods
+     */
+    getResources(): Promise<Resource[]>;
+    /**
+     * Adds a new resource.
+     * @param resource The resource to add
+     * @returns Promise resolving to the added resource
+     * @group Methods
+     */
+    addResource(resource: Resource): Promise<Resource>;
+    private simulateLatency;
+}

package/dist/components/EzScheduler/services/SearchService.d.ts

@@ -0,0 +1,11 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { SchedulerEvent } from '../EzScheduler.types';
+export interface SearchOptions {
+    fields?: ('title' | 'description' | 'location')[];
+    matchCase?: boolean;
+}
+export declare class SearchService implements IService {
+    name: string;
+    search(events: SchedulerEvent[], query: string, options?: SearchOptions): SchedulerEvent[];
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/SecurityService.d.ts

@@ -0,0 +1,25 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+export interface UserContext {
+    userId: string;
+    tenantId: string;
+    roles: string[];
+    permissions?: string[];
+}
+export declare class SecurityService implements IService {
+    name: string;
+    private currentUser;
+    setUser(user: UserContext): void;
+    getUser(): UserContext | null;
+    /**
+     * Checks if the current user has permission for a specific action.
+     * @param action The action to check (e.g., 'edit_event', 'delete_event').
+     * @param resourceId Optional resource ID if checking specific resource access.
+     */
+    hasPermission(action: string, _resourceId?: string): boolean;
+    /**
+     * Checks if the data belongs to the current user's tenant.
+     * @param dataTenantId The tenant ID associated with the data.
+     */
+    validateTenant(dataTenantId: string): boolean;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/TimezoneService.d.ts

@@ -0,0 +1,20 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+export declare class TimezoneService implements IService {
+    name: string;
+    constructor();
+    /**
+     * Converts a date to a specific timezone
+     * @param date Date object
+     * @param timeZone Target time zone (e.g., 'America/New_York')
+     */
+    toTimezone(date: Date | string | number, timeZone: string): Date;
+    /**
+     * Formats a date in a specific timezone
+     */
+    formatInTimezone(date: Date | string | number, timeZone: string, options?: Intl.DateTimeFormatOptions): string;
+    /**
+     * Get local browser timezone name
+     */
+    getLocalTimezone(): string;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/VirtualScrollingService.d.ts

@@ -0,0 +1,34 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { BaseService } from '../../../shared/services/BaseService';
+export interface VirtualScrollState {
+    offsets: Record<string, {
+        top: number;
+        left: number;
+    }>;
+}
+export type ScrollDirection = 'vertical' | 'horizontal' | 'both';
+/**
+ * High-performance service for coordinating virtualization state across components.
+ * Supports bidirectional syncing for complex layouts (Timeline, Resource Headers).
+ */
+export declare class VirtualScrollingService extends BaseService<VirtualScrollState> implements IService {
+    name: string;
+    private registrants;
+    constructor();
+    /**
+     * Registers a callback for external scroll control
+     */
+    register(id: string, onUpdate: (offset: {
+        top: number;
+        left: number;
+    }) => void): () => boolean;
+    /**
+     * Updates the scroll offset and syncs with all other registrants
+     * @param id The source component ID
+     * @param top Vertical offset
+     * @param left Horizontal offset
+     * @param direction Which axis to sync (optimization)
+     */
+    setScrollOffset(id: string, top: number, left: number, _direction?: ScrollDirection): void;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/state/scheduler.store.d.ts

@@ -0,0 +1,27 @@
+import { Store } from '@tanstack/store';
+import { SchedulerEvent, Resource, ViewType, ResourceModel, View } from '../EzScheduler.types';
+export interface SchedulerState {
+    events: SchedulerEvent[];
+    resources: (Resource | ResourceModel)[];
+    view: ViewType | View;
+    currentDate: Date;
+    selectedDate: Date;
+    selectedEventId: string | null;
+    slotDuration: number;
+    is24Hour: boolean;
+}
+export declare const createSchedulerStore: (initialState: Partial<SchedulerState>) => Store<SchedulerState, never>;
+export declare const createSchedulerActions: (store: Store<SchedulerState>) => {
+    setEvents: (events: SchedulerEvent[]) => void;
+    addEvent: (event: SchedulerEvent) => void;
+    updateEvent: (updatedEvent: SchedulerEvent) => void;
+    deleteEvent: (id: string | number) => void;
+    setResources: (resources: (Resource | ResourceModel)[]) => void;
+    setView: (view: ViewType) => void;
+    setCurrentDate: (date: Date) => void;
+    setSelectedDate: (date: Date) => void;
+    setSelectedEventId: (id: string | null) => void;
+    setSlotDuration: (duration: number) => void;
+    setIs24Hour: (is24: boolean) => void;
+};
+export type SchedulerActions = ReturnType<typeof createSchedulerActions>;

package/dist/components/EzScheduler/templates/CellTemplate.d.ts

@@ -0,0 +1,42 @@
+import { default as React } from 'react';
+import { SchedulerEvent } from '../EzScheduler.types';
+/**
+ * Props for the CellTemplate component.
+ */
+export interface CellTemplateProps {
+    /**
+     * The date representing this cell.
+     * @group Properties
+     */
+    date: Date;
+    /**
+     * The type of view context.
+     * @group Properties
+     */
+    type: 'month' | 'week' | 'day';
+    /**
+     * Events occurring on this date.
+     * @group Properties
+     */
+    events?: SchedulerEvent[];
+    /**
+     * Custom content for the cell.
+     * @group Properties
+     */
+    children?: React.ReactNode;
+    /**
+     * Custom CSS class name.
+     * @group Properties
+     */
+    className?: string;
+    /**
+     * Callback when the cell is clicked.
+     * @group Events
+     */
+    onClick?: (date: Date) => void;
+}
+/**
+ * Default template for rendering a scheduler cell.
+ * @group Models
+ */
+export declare const CellTemplate: React.FC<CellTemplateProps>;

package/dist/components/EzScheduler/templates/EditorTemplate.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { SchedulerEvent } from '../EzScheduler.types';
+/**
+ * Props for the EditorTemplate component.
+ */
+export interface EditorTemplateProps {
+    /**
+     * The event being edited or created.
+     * @group Properties
+     */
+    event?: Partial<SchedulerEvent>;
+    /**
+     * Callback when the event is saved.
+     * @group Events
+     */
+    onSave: (event: SchedulerEvent) => void;
+    /**
+     * Callback when editing is cancelled.
+     * @group Events
+     */
+    onCancel: () => void;
+    /**
+     * Callback when the event is deleted.
+     * @group Events
+     */
+    onDelete?: (id: string) => void;
+}
+/**
+ * Default template for the event editor dialog.
+ * @group Models
+ */
+export declare const EditorTemplate: React.FC<EditorTemplateProps>;

package/dist/components/EzScheduler/templates/HeaderTemplate.d.ts

@@ -0,0 +1,36 @@
+import { default as React } from 'react';
+/**
+ * Props for the HeaderTemplate component.
+ */
+export interface HeaderTemplateProps {
+    /**
+     * The date representing this header.
+     * @group Properties
+     */
+    date: Date;
+    /**
+     * The type of header.
+     * @group Properties
+     */
+    type: 'day' | 'week' | 'month' | 'resource';
+    /**
+     * Date format string for display.
+     * @group Properties
+     */
+    formatString?: string;
+    /**
+     * Custom text for the header.
+     * @group Properties
+     */
+    text?: string;
+    /**
+     * Custom CSS class name.
+     * @group Properties
+     */
+    className?: string;
+}
+/**
+ * Default template for rendering a scheduler header.
+ * @group Models
+ */
+export declare const HeaderTemplate: React.FC<HeaderTemplateProps>;

package/dist/components/EzScheduler/useEzScheduler.d.ts

@@ -0,0 +1,104 @@
+import { EzSchedulerProps, ViewType } from './EzScheduler.types';
+import { HistoryService } from './services/HistoryService';
+import { SearchService } from './services/SearchService';
+import { TimezoneService } from './services/TimezoneService';
+import { AttendeeService } from './services/AttendeeService';
+import { ReminderService } from './services/ReminderService';
+/**
+ * Orchestrator hook for EzScheduler.
+ * Delegates responsibilities to specialized sub-hooks and provides a unified interface for managing scheduler state and operations.
+ *
+ * @param props - Scheduler properties of type {@link EzSchedulerProps}
+ * @returns An object containing the consolidated state and API methods for the scheduler
+ * @group Hooks
+ */
+export declare const useEzScheduler: (props: EzSchedulerProps) => {
+    /**
+     * Namespaced state properties
+     * @group State
+     */
+    state: {
+        currentView: import('./EzScheduler.types').View | ViewType;
+        selectedDate: Date;
+        currentDate: Date;
+        events: import('./EzScheduler.types').SchedulerEvent[];
+        resources: (import('./EzScheduler.types').ResourceModel | import('./EzScheduler.types').Resource)[];
+        viewEvents: import('./EzScheduler.types').SchedulerEvent[];
+        daysInView: Date[];
+        allEvents: import('./EzScheduler.types').SchedulerEvent[];
+        slotDuration: number;
+        is24Hour: boolean;
+        isUpdating: boolean;
+        selectedIndex: number;
+        highlightedEventId: string | null;
+    };
+    /**
+     * Namespaced action methods
+     * @group Actions
+     */
+    actions: {
+        nextPeriod: () => void;
+        prevPeriod: () => void;
+        today: () => void;
+        setView: (view: ViewType) => void;
+        setDate: (date: Date) => void;
+        setCurrentDate: (date: Date) => void;
+        addEvent: import('@tanstack/react-query').UseMutateAsyncFunction<import('./EzScheduler.types').SchedulerEvent, Error, Partial<import('./EzScheduler.types').SchedulerEvent>, {
+            previousEvents: unknown;
+            queryKey: string[];
+        }>;
+        updateEvent: import('@tanstack/react-query').UseMutateAsyncFunction<import('./EzScheduler.types').SchedulerEvent, Error, import('./EzScheduler.types').SchedulerEvent, {
+            previousEvents: unknown;
+            queryKey: string[];
+        }>;
+        deleteEvent: import('@tanstack/react-query').UseMutateAsyncFunction<string | number, Error, string | number, {
+            previousEvents: unknown;
+            queryKey: string[];
+        }>;
+        setSlotDuration: (duration: number) => void;
+        setIs24Hour: (is24: boolean) => void;
+        setSelectedIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+        setHighlightedEventId: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+    };
+    /**
+     * Namespaced core services
+     * @group Services
+     */
+    services: {
+        schedulerService: import('./services/SchedulerService').SchedulerService;
+        recurrenceEngine: import('./services/RecurrenceEngine').RecurrenceEngine;
+        historyService: HistoryService;
+        searchService: SearchService;
+        timezoneService: TimezoneService;
+        attendeeService: AttendeeService;
+        reminderService: ReminderService;
+        serviceRegistry: import('../../shared/services/ServiceRegistry').ServiceRegistry;
+    };
+    /**
+     * Scheduler configuration properties
+     * @group Config
+     */
+    config: {
+        showWeekend: boolean;
+        timeFormat: string | undefined;
+        weekRule: import('./EzScheduler.types').WeekRule;
+        monthsCount: number;
+        eventDragArea: string | undefined;
+        dir: "ltr" | "rtl";
+    };
+    /**
+     * DOM and component references
+     * @group Refs
+     */
+    refs: {
+        parentRef: import('react').RefObject<HTMLDivElement | null>;
+        rowVirtualizer: import('@tanstack/virtual-core').Virtualizer<HTMLDivElement, Element>;
+        columnVirtualizer: import('@tanstack/virtual-core').Virtualizer<HTMLDivElement, Element> | undefined;
+    };
+    baseState: import('../../shared/hooks').BaseComponentState;
+    baseApi: {
+        showSpinner: () => void;
+        hideSpinner: () => void;
+    };
+    dir: "ltr" | "rtl";
+};

package/dist/components/EzScheduler/utils/createDragConstraint.d.ts

@@ -0,0 +1,7 @@
+import { Modifier } from '@dnd-kit/core';
+/**
+ * Creates a drag constraint modifier that restricts dragging to a specified area
+ * @param selector - CSS selector for the constraint boundary element
+ * @returns Modifier function or undefined if no selector provided
+ */
+export declare function createDragConstraint(selector?: string): Modifier | undefined;

package/dist/components/EzScheduler/utils/getWeekNumber.d.ts

@@ -0,0 +1,8 @@
+import { WeekRule } from '../EzScheduler.types';
+/**
+ * Calculate week number based on the specified week rule
+ * @param date - The date to calculate week number for
+ * @param weekRule - The week numbering rule to use
+ * @returns Week number
+ */
+export declare function getWeekNumber(date: Date, weekRule?: WeekRule): number;

package/dist/components/EzScheduler/utils/sanitizeHtml.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+/**
+ * Sanitizes HTML content using DOMPurify
+ * @param html - The HTML string to sanitize
+ * @param enabled - Whether sanitization is enabled
+ * @returns Sanitized HTML string or original if disabled
+ */
+export declare function sanitizeHtml(html: string, enabled?: boolean): string;
+/**
+ * Renders template content safely.
+ * @param template - Template content (React node or HTML string)
+ * @param data - Data to pass to template function
+ * @param _enableSanitizer - Deprecated. String templates are always sanitized before dangerouslySetInnerHTML.
+ * @returns Rendered content
+ */
+export declare function renderTemplate(template: ((data: any) => React.ReactNode) | string | undefined, data: any, _enableSanitizer?: boolean): React.ReactNode | {
+    __html: string;
+} | null;

package/dist/components/EzScheduler/views/AgendaView.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { SchedulerEvent } from '../EzScheduler.types';
+/**
+ * Props for the AgendaView component.
+ */
+interface AgendaViewProps {
+    /**
+     * List of days to display in the agenda.
+     * @group Properties
+     */
+    daysInView: Date[];
+    /**
+     * List of events to display.
+     * @group Properties
+     */
+    visibleEvents: SchedulerEvent[];
+    /**
+     * Callback when an event is clicked.
+     * @group Events
+     */
+    onEventClick?: (event: SchedulerEvent) => void;
+}
+/**
+ * A linear list view of events, grouped by day.
+ * @group Views
+ */
+export declare const AgendaView: React.FC<AgendaViewProps>;
+export {};