@daypilot/daypilot-lite-angular 3.33.1 → 4.0.0

package/lib/core/daypilot-core.d.ts

@@ -1,5 +1,409 @@
 declare type GlobalDate = Date;
 export declare module DayPilot {
+    export class SchedulerPropsAndEvents {
+        backendUrl?: string;
+        businessBeginsHour?: number;
+        businessEndsHour?: number;
+        businessWeekends?: boolean;
+        cellDuration?: number;
+        cellGroupBy?: GroupBy;
+        cellSweeping?: boolean;
+        cellSweepingCacheSize?: number;
+        cellWidth?: number;
+        cellsMarkBusiness?: boolean;
+        contextMenu?: DayPilot.Menu;
+        days?: number;
+        durationBarHeight?: number;
+        durationBarVisible?: boolean;
+        dynamicEventRendering?: "Progressive" | "Disabled";
+        dynamicEventRenderingCacheSize?: number;
+        dynamicEventRenderingCacheSweeping?: boolean;
+        dynamicEventRenderingMargin?: number;
+        dynamicEventRenderingMarginX?: number;
+        dynamicEventRenderingMarginY?: number;
+        eventClickHandling?: "Enabled" | "Disabled";
+        eventDeleteHandling?: "Update" | "Disabled";
+        eventEndSpec?: "DateTime" | "Date";
+        eventHeight?: number;
+        eventMinWidth?: number;
+        eventMoveHandling?: "Update" | "Disabled";
+        eventResizeHandling?: "Update" | "Disabled";
+        eventResizeMargin?: number;
+        eventRightClickHandling?: "Enabled" | "Disabled" | "ContextMenu";
+        eventTapAndHoldHandling?: "Move" | "ContextMenu";
+        eventTextWrappingEnabled?: boolean;
+        eventsLoadMethod?: "GET" | "POST";
+        floatingEvents?: boolean;
+        floatingTimeHeaders?: boolean;
+        headerHeight?: number;
+        height?: number;
+        heightSpec?: "Auto" | "Max" | "Fixed";
+        locale?: string | DayPilot.Locale;
+        progressiveRowRendering?: boolean;
+        progressiveRowRenderingPreload?: number;
+        resources?: ResourceData[];
+        rowHeaderWidth?: number;
+        rowsLoadMethod?: "GET" | "POST";
+        scale?: "CellDuration" | "Minute" | "Hour" | "Day" | "Week";
+        scrollDelayCells?: number;
+        scrollDelayEvents?: number;
+        scrollDelayFloats?: number;
+        scrollDelayRows?: number;
+        showToolTip?: boolean;
+        snapToGrid?: boolean;
+        startDate?: DayPilot.Date | string;
+        tapAndHoldTimeout?: number;
+        theme?: string;
+        timeFormat?: "Auto" | "Clock12Hours" | "Clock24Hours";
+        timeHeaderClickHandling?: "Enabled" | "Disabled";
+        timeHeaderTextWrappingEnabled?: boolean;
+        timeHeaders?: TimeHeaderData[];
+        timeRangeClickHandling?: "Enabled" | "Disabled";
+        timeRangeSelectedHandling?: "Enabled" | "Disabled";
+        useEventBoxes?: "Always" | "Never";
+        visible?: boolean;
+        weekStarts?: "Auto" | number;
+        width?: string;
+        xssProtection?: "Enabled" | "Disabled";
+        onAfterUpdate?: EventHandler<SchedulerAfterUpdateArgs>;
+        onBeforeEventRender?: EventHandler<SchedulerBeforeEventRenderArgs>;
+        onBeforeRowHeaderRender?: EventHandler<SchedulerBeforeRowHeaderRenderArgs>;
+        onBeforeTimeHeaderRender?: EventHandler<SchedulerBeforeTimeHeaderRenderArgs>;
+        onEventClick?: EventHandler<SchedulerEventClickArgs>;
+        onEventClicked?: EventHandler<SchedulerEventClickedArgs>;
+        onEventDelete?: EventHandler<SchedulerEventDeleteArgs>;
+        onEventDeleted?: EventHandler<SchedulerEventDeletedArgs>;
+        onEventMove?: EventHandler<SchedulerEventMoveArgs>;
+        onEventMoved?: EventHandler<SchedulerEventMovedArgs>;
+        onEventResize?: EventHandler<SchedulerEventResizeArgs>;
+        onEventResized?: EventHandler<SchedulerEventResizedArgs>;
+        onEventRightClick?: EventHandler<SchedulerEventRightClickArgs>;
+        onEventRightClicked?: EventHandler<SchedulerEventRightClickedArgs>;
+        onRowClick?: EventHandler<SchedulerRowClickArgs>;
+        onRowClicked?: EventHandler<SchedulerRowClickedArgs>;
+        onTimeHeaderClick?: EventHandler<SchedulerTimeHeaderClickArgs>;
+        onTimeHeaderClicked?: EventHandler<SchedulerTimeHeaderClickedArgs>;
+        onTimeHeaderRightClick?: EventHandler<SchedulerTimeHeaderRightClickArgs>;
+        onTimeHeaderRightClicked?: EventHandler<SchedulerTimeHeaderRightClickedArgs>;
+        onTimeRangeClick?: EventHandler<SchedulerTimeRangeClickArgs>;
+        onTimeRangeClicked?: EventHandler<SchedulerTimeRangeClickedArgs>;
+        onTimeRangeSelect?: EventHandler<SchedulerTimeRangeSelectArgs>;
+        onTimeRangeSelected?: EventHandler<SchedulerTimeRangeSelectedArgs>;
+    }
+    export class SchedulerConfig extends SchedulerPropsAndEvents {
+        events?: EventData[];
+    }
+    export class Scheduler extends SchedulerPropsAndEvents {
+        v: string;
+        events: {
+            list: EventData[];
+            add(e: DayPilot.Event): void;
+            add(data: EventData): void;
+            all(): DayPilot.Event[];
+            find(id: EventId): DayPilot.Event;
+            find(filter: (e: DayPilot.Event) => boolean): DayPilot.Event;
+            findAll(filter: (e: DayPilot.Event) => boolean): DayPilot.Event[];
+            findAll(example: any): DayPilot.Event[];
+            forRange(start?: DayPilot.Date | string, end?: DayPilot.Date | string): DayPilot.Event[];
+            load(url: string, success: (args: {
+                data: any;
+                preventDefault(): void;
+            }) => void, error: (args: {
+                request: XMLHttpRequest;
+                exception: any;
+            }) => void): void;
+            remove(e: DayPilot.Event): void;
+            remove(data: EventData): void;
+            remove(id: EventId): void;
+            scrollIntoView(e: DayPilot.Event): void;
+            update(e: DayPilot.Event): void;
+            update(data: EventData): void;
+        };
+        rows: {
+            add(data: ResourceData): void;
+            all(): DayPilot.Row[];
+            each(f: () => DayPilot.Row): void;
+            find(filter: (row: DayPilot.Row) => boolean, startIndex?: number): DayPilot.Row;
+            find(id: ResourceId, start?: DayPilot.Date | string): DayPilot.Row;
+            load(url: string, success: (args: {
+                data: any;
+                preventDefault(): void;
+            }) => void, error: (args: {
+                request: XMLHttpRequest;
+                exception: any;
+            }) => void): void;
+            remove(row: DayPilot.Row): void;
+            remove(id: ResourceId): void;
+            sort(spec?: string | {
+                field: string;
+                order?: "asc" | "desc";
+            }): void;
+            update(row: DayPilot.Row | ResourceData): void;
+        };
+        constructor(id: string | HTMLElement, options?: SchedulerConfig);
+        clearSelection(): void;
+        dispose(): void;
+        disposed(): boolean;
+        dragInProgress(): boolean;
+        getDate(pixels: number, precise?: boolean, isEnd?: boolean): DayPilot.Date;
+        getScrollX(): number;
+        getScrollY(): number;
+        getViewport(): SchedulerViewport;
+        hide(): void;
+        init(): void;
+        scrollTo(date: string | DayPilot.Date): void;
+        scrollToResource(id: ResourceId | DayPilot.Row): void;
+        selectTimeRange(start: DayPilot.Date | string, end: DayPilot.Date | string, resource: ResourceId, dontFireEvent?: boolean): void;
+        setHeight(pixels: number): void;
+        setScroll(scrollX: number, scrollY: number): void;
+        setScrollX(scrollX: number): void;
+        setScrollY(scrollY: number): void;
+        show(): void;
+        update(options?: SchedulerConfig): void;
+        visibleStart(): DayPilot.Date;
+        visibleEnd(): DayPilot.Date;
+    }
+    export interface SchedulerAfterUpdateArgs {
+    }
+    export interface SchedulerBeforeEventRenderArgs {
+        readonly control: DayPilot.Scheduler;
+        readonly data: EventData;
+    }
+    export interface SchedulerBeforeRowHeaderRenderArgs {
+        readonly row: RenderRow;
+    }
+    export interface SchedulerBeforeTimeHeaderRenderArgs {
+        readonly control: Scheduler;
+        readonly header: {
+            readonly start: DayPilot.Date;
+            readonly end: DayPilot.Date;
+            readonly level: number;
+            areas: AreaData[];
+            text: string;
+            html: string;
+            toolTip: string;
+            backColor: string;
+            fontColor: string;
+            cssClass: string;
+        };
+    }
+    export interface SchedulerEventClickArgs {
+        readonly e: DayPilot.Event;
+        readonly div: HTMLElement;
+        readonly ctrl: boolean;
+        readonly meta: boolean;
+        readonly shift: boolean;
+        readonly control: DayPilot.Scheduler;
+        readonly originalEvent: MouseEvent;
+        preventDefault(): void;
+    }
+    export interface SchedulerEventClickedArgs {
+        readonly e: DayPilot.Event;
+        readonly div: HTMLElement;
+        readonly ctrl: boolean;
+        readonly meta: boolean;
+        readonly shift: boolean;
+        readonly control: DayPilot.Scheduler;
+        readonly originalEvent: MouseEvent;
+    }
+    export interface SchedulerEventDeleteArgs {
+        readonly e: DayPilot.Event;
+        readonly control: DayPilot.Scheduler;
+        preventDefault(): void;
+    }
+    export interface SchedulerEventDeletedArgs {
+        readonly e: DayPilot.Event;
+        readonly control: DayPilot.Scheduler;
+    }
+    export interface SchedulerEventMoveArgs {
+        async: boolean;
+        readonly areaData: any;
+        readonly control: DayPilot.Scheduler;
+        readonly e: DayPilot.Event;
+        newStart: DayPilot.Date;
+        newEnd: DayPilot.Date;
+        newResource: ResourceId;
+        readonly ctrl: boolean;
+        readonly shift: boolean;
+        readonly meta: boolean;
+        loaded(): void;
+        preventDefault(): void;
+    }
+    export interface SchedulerEventMovedArgs {
+        readonly async: boolean;
+        readonly areaData: any;
+        readonly control: DayPilot.Scheduler;
+        readonly e: DayPilot.Event;
+        readonly newStart: DayPilot.Date;
+        readonly newEnd: DayPilot.Date;
+        readonly newResource: ResourceId;
+        readonly ctrl: boolean;
+        readonly shift: boolean;
+        readonly meta: boolean;
+    }
+    export interface SchedulerEventResizeArgs {
+        readonly areaData: any;
+        async: boolean;
+        readonly control: DayPilot.Scheduler;
+        readonly e: DayPilot.Event;
+        newStart: DayPilot.Date;
+        newEnd: DayPilot.Date;
+        readonly what: "start" | "end";
+        loaded(): void;
+        preventDefault(): void;
+    }
+    export interface SchedulerEventResizedArgs {
+        readonly areaData: any;
+        readonly async: boolean;
+        readonly control: DayPilot.Scheduler;
+        readonly e: DayPilot.Event;
+        readonly newStart: DayPilot.Date;
+        readonly newEnd: DayPilot.Date;
+        readonly what: "start" | "end";
+    }
+    export interface SchedulerEventRightClickArgs {
+        readonly e: DayPilot.Event;
+        readonly div: HTMLElement;
+        readonly originalEvent: MouseEvent;
+        preventDefault(): void;
+    }
+    export interface SchedulerEventRightClickedArgs {
+        readonly e: DayPilot.Event;
+        readonly div: HTMLElement;
+        readonly originalEvent: MouseEvent;
+    }
+    export interface SchedulerRowClickArgs {
+        readonly row: DayPilot.Row;
+        readonly ctrl: boolean;
+        readonly shift: boolean;
+        readonly meta: boolean;
+        readonly originalEvent: MouseEvent;
+        preventDefault(): void;
+    }
+    export interface SchedulerRowClickedArgs {
+        readonly row: DayPilot.Row;
+        readonly ctrl: boolean;
+        readonly shift: boolean;
+        readonly meta: boolean;
+        readonly originalEvent: MouseEvent;
+    }
+    export interface SchedulerTimeHeaderClickArgs {
+        readonly control: Scheduler;
+        readonly header: {
+            readonly start: DayPilot.Date;
+            readonly end: DayPilot.Date;
+            readonly level: number;
+        };
+        readonly originalEvent: MouseEvent;
+        readonly ctrl: boolean;
+        readonly shift: boolean;
+        readonly meta: boolean;
+        preventDefault(): void;
+    }
+    export interface SchedulerTimeHeaderClickedArgs {
+        readonly control: Scheduler;
+        readonly header: {
+            readonly start: DayPilot.Date;
+            readonly end: DayPilot.Date;
+            readonly level: number;
+        };
+        readonly originalEvent: MouseEvent;
+        readonly ctrl: boolean;
+        readonly shift: boolean;
+        readonly meta: boolean;
+    }
+    export interface SchedulerTimeHeaderRightClickArgs {
+        readonly header: {
+            readonly start: DayPilot.Date;
+            readonly end: DayPilot.Date;
+            readonly level: number;
+        };
+        preventDefault(): void;
+    }
+    export interface SchedulerTimeHeaderRightClickedArgs {
+        readonly header: {
+            readonly start: DayPilot.Date;
+            readonly end: DayPilot.Date;
+            readonly level: number;
+        };
+    }
+    export interface SchedulerTimeRangeClickArgs {
+        readonly start: DayPilot.Date;
+        readonly end: DayPilot.Date;
+        readonly resource: ResourceId;
+        preventDefault(): void;
+    }
+    export interface SchedulerTimeRangeClickedArgs {
+        readonly start: DayPilot.Date;
+        readonly end: DayPilot.Date;
+        readonly resource: ResourceId;
+    }
+    export interface SchedulerTimeRangeSelectArgs {
+        readonly start: DayPilot.Date;
+        readonly end: DayPilot.Date;
+        readonly resource: ResourceId;
+        readonly control: DayPilot.Scheduler;
+        preventDefault(): void;
+    }
+    export interface SchedulerTimeRangeSelectedArgs {
+        readonly start: DayPilot.Date;
+        readonly end: DayPilot.Date;
+        readonly resource: ResourceId;
+        readonly control: DayPilot.Scheduler;
+    }
+    export type GroupBy = "Minute" | "Hour" | "Day" | "Week" | "Month" | "Quarter" | "Year" | "Cell" | "None";
+    export interface SchedulerViewport {
+        start: DayPilot.Date;
+        end: DayPilot.Date;
+        resources: ResourceId[];
+    }
+    export interface ResourceData {
+        id?: ResourceId;
+        name?: string;
+        start?: DayPilot.Date | string;
+        end?: DayPilot.Date | string;
+        areas?: AreaData[];
+        ariaLabel?: string;
+        backColor?: string;
+        fontColor?: string;
+        cssClass?: string;
+        html?: string;
+        tags?: any;
+        toolTip?: string;
+        [prop: string]: any;
+    }
+    export interface TimeHeaderData {
+        groupBy: GroupBy;
+        format?: string;
+        height?: number;
+    }
+    export class Row {
+        events: {
+            all(): DayPilot.Event[];
+            isEmpty(): boolean;
+            forRange(start: string | DayPilot.Date, end: string | DayPilot.Date): DayPilot.Event[];
+            totalDuration(): DayPilot.Duration;
+        };
+        readonly calendar: DayPilot.Scheduler;
+        readonly data: any;
+        readonly id: ResourceId;
+        readonly index: number;
+        readonly level: number;
+        readonly name: string;
+        addClass(className: string): void;
+        remove(): void;
+        removeClass(className: string): void;
+    }
+    export class RenderRow extends Row {
+        areas: AreaData[];
+        backColor: string;
+        cssClass: string;
+        fontColor: string;
+        horizontalAlignment: HorizontalAlignment;
+        html: string;
+        text: string;
+        toolTip: string;
+    }
     export class CalendarPropsAndEvents {
         backendUrl?: string;
         businessBeginsHour?: number;
@@ -455,11 +859,16 @@ export declare module DayPilot {
         selectionStart?: DayPilot.Date;
         selectMode?: "Day" | "Week" | "Month" | "None";
         showMonths?: number;
+        showToday?: boolean;
         showWeekNumbers?: boolean;
         skipMonths?: number;
         startDate?: DayPilot.Date | string;
         theme?: string;
         titleHeight?: number;
+        todayHeight?: number;
+        todayHtml?: string;
+        todayPosition?: "Top" | "Bottom";
+        todayText?: string;
         weekStarts?: "Auto" | number;
         weekNumberAlgorithm?: "Auto" | "US" | "ISO8601";
         timeRangeSelectedHandling?: "Bind" | "None";
@@ -467,6 +876,7 @@ export declare module DayPilot {
         onBeforeCellRender?: EventHandler<NavigatorBeforeCellRenderArgs>;
         onTimeRangeSelect?: EventHandler<NavigatorTimeRangeSelectArgs>;
         onTimeRangeSelected?: EventHandler<NavigatorTimeRangeSelectedArgs>;
+        onTodayClick?: EventHandler<NavigatorTodayClickArgs>;
         onVisibleRangeChange?: EventHandler<NavigatorVisibleRangeChangeArgs>;
         onVisibleRangeChanged?: EventHandler<NavigatorVisibleRangeChangedArgs>;
     }
@@ -518,6 +928,9 @@ export declare module DayPilot {
         readonly days: number;
         readonly mode: "Day" | "Week" | "Month" | "None" | "FreeHand";
     }
+    export interface NavigatorTodayClickArgs {
+        preventDefault(): void;
+    }
     interface NavigatorVisibleRangeChangeArgs {
         readonly start: DayPilot.Date;
         readonly end: DayPilot.Date;
@@ -719,33 +1132,6 @@ export declare module DayPilot {
         static lighter(color: string, steps?: number): string;
         static contrasting(color: string, light?: string, dark?: string): string;
     }
-    export class Http {
-        static get(url: string, options?: HttpGetOptions): Promise<HttpPromiseArgs>;
-        static post(url: string, data?: object | string, options?: HttpPostOptions): Promise<HttpPromiseArgs>;
-        static put(url: string, data?: object | string, options?: HttpPutOptions): Promise<HttpPromiseArgs>;
-        static delete(url: string, options?: HttpDeleteOptions): Promise<HttpPromiseArgs>;
-    }
-    export interface HttpDeleteOptions {
-        headers?: HttpHeaders;
-    }
-    export interface HttpGetOptions {
-        headers?: HttpHeaders;
-    }
-    export interface HttpPostOptions {
-        headers?: HttpHeaders;
-        contentType?: string;
-    }
-    export interface HttpPutOptions {
-        headers?: HttpHeaders;
-        contentType?: string;
-    }
-    export interface HttpPromiseArgs {
-        readonly data: any;
-        readonly request: XMLHttpRequest;
-    }
-    export interface HttpHeaders {
-        [header: string]: string;
-    }
     export class Duration {
         ticks: number;
         constructor(ticks: number);

package/lib/daypilot-scheduler.component.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, DoCheck, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { DayPilot } from "./core/daypilot-core";
+import * as i0 from "@angular/core";
+export declare class DayPilotSchedulerComponent implements OnInit, OnDestroy, AfterViewInit, DoCheck {
+    control: DayPilot.Scheduler;
+    viewChange: EventEmitter<DayPilot.Date>;
+    events: DayPilot.EventData[];
+    config: any;
+    private _requestUpdateFull;
+    private _requestUpdateEvents;
+    private _requestViewChange;
+    private _hashOptions;
+    private _hashEvents;
+    private _id;
+    get id(): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    private dispose;
+    private updateOptions;
+    private updateEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DayPilotSchedulerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DayPilotSchedulerComponent, "daypilot-scheduler", never, { "events": "events"; "config": "config"; }, { "viewChange": "viewChange"; }, never, never>;
+}

package/lib/daypilot.module.d.ts

@@ -1,9 +1,10 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./daypilot-calendar.component";
-import * as i2 from "./daypilot-month.component";
-import * as i3 from "./daypilot-navigator.component";
+import * as i2 from "./daypilot-scheduler.component";
+import * as i3 from "./daypilot-month.component";
+import * as i4 from "./daypilot-navigator.component";
 export declare class DayPilotModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DayPilotModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DayPilotModule, [typeof i1.DayPilotCalendarComponent, typeof i2.DayPilotMonthComponent, typeof i3.DayPilotNavigatorComponent], never, [typeof i1.DayPilotCalendarComponent, typeof i2.DayPilotMonthComponent, typeof i3.DayPilotNavigatorComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DayPilotModule, [typeof i1.DayPilotCalendarComponent, typeof i2.DayPilotSchedulerComponent, typeof i3.DayPilotMonthComponent, typeof i4.DayPilotNavigatorComponent], never, [typeof i1.DayPilotCalendarComponent, typeof i2.DayPilotSchedulerComponent, typeof i3.DayPilotMonthComponent, typeof i4.DayPilotNavigatorComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DayPilotModule>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daypilot/daypilot-lite-angular",
-  "version": "3.33.1",
+  "version": "4.0.0",
   "description": "DayPilot Lite for Angular",
   "homepage": "https://javascript.daypilot.org/",
   "author": "Annpoint, s.r.o.",
@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "tslib": "^2.3.0",
-    "@daypilot/daypilot-lite-javascript": "3.33.1"
+    "@daypilot/daypilot-lite-javascript": "4.0.0"
   },
   "module": "fesm2015/daypilot-daypilot-lite-angular.mjs",
   "es2020": "fesm2020/daypilot-daypilot-lite-angular.mjs",

package/public-api.d.ts

@@ -1,4 +1,5 @@
 export * from './lib/daypilot-calendar.component';
+export * from './lib/daypilot-scheduler.component';
 export * from './lib/daypilot-month.component';
 export * from './lib/daypilot-navigator.component';
 export * from './lib/daypilot.module';