@svar-ui/gantt-store 2.2.1 → 2.4.0

package/dist/types/DataStore.d.ts

@@ -1,16 +1,21 @@
 import { Store, EventBus } from "@wx/lib-state";
 import type { TDataConfig, TWritableCreator, TID } from "@wx/lib-state";
+import { HistoryManager } from "./modules/HistoryManager.pro";
 import type { IData, IDataConfig, ITask, TMethodsConfig, ILink, IVisibleArea, IParsedTask, TScrollTask } from "./types";
 export default class DataStore extends Store<IData> {
     in: EventBus<TMethodsConfig, keyof TMethodsConfig>;
     private _router;
+    private _modules;
     constructor(w: TWritableCreator);
     init(state: Partial<IDataConfig>): void;
+    private enableModule;
+    private disableModule;
     setState(state: Partial<IData>, ctx?: TDataConfig): {
         [key: string]: () => void;
     };
     setStateAsync(state: Partial<IData>): void;
     getTask(id: TID): IParsedTask;
+    getHistory(): HistoryManager;
     serialize(): Partial<ITask>[];
     private changeScale;
     private isScheduled;
@@ -30,13 +35,17 @@ export type IDataMethodsConfig = CombineTypes<{
         target?: TID;
         mode?: "before" | "after" | "child";
         show?: TScrollTask["mode"];
+        select?: boolean;
+        eventSource?: string;
     };
     ["update-task"]: {
         id: TID;
+        segmentIndex?: number;
         task: Partial<ITask>;
         diff?: number;
         inProgress?: boolean;
         eventSource?: string;
+        skipUndo?: boolean;
     };
     ["delete-task"]: {
         id: TID;
@@ -54,6 +63,7 @@ export type IDataMethodsConfig = CombineTypes<{
     };
     ["drag-task"]: {
         id: TID;
+        segmentIndex?: number;
         width?: number;
         left?: number;
         top?: number;
@@ -66,11 +76,12 @@ export type IDataMethodsConfig = CombineTypes<{
         source?: TID;
         lazy?: boolean;
         eventSource?: string;
+        skipUndo?: boolean;
     };
     ["move-task"]: {
         id: TID;
         target?: TID;
-        mode?: "before" | "after" | "up" | "down" | "child";
+        mode: "before" | "after" | "up" | "down" | "child";
         inProgress?: boolean;
         source?: TID;
     };
@@ -84,6 +95,8 @@ export type IDataMethodsConfig = CombineTypes<{
     ["add-link"]: {
         id?: TID;
         link: Partial<ILink>;
+        eventSource?: string;
+        skipUndo: boolean;
     };
     ["update-link"]: {
         id: TID;
@@ -127,7 +140,19 @@ export type IDataMethodsConfig = CombineTypes<{
         event: any;
         eventSource?: string;
     };
+    ["schedule-tasks"]: {
+        id?: TID;
+        task?: Partial<ITask>;
+    };
+    ["undo"]: void;
+    ["redo"]: void;
+    ["split-task"]: {
+        id: TID;
+        segmentIndex?: number;
+    };
 }, {
     skipProvider?: boolean;
+    spipUndo?: boolean;
+    [key: string]: any;
 }>;
 export {};

package/dist/types/GanttDataTree.d.ts

@@ -9,8 +9,9 @@ export default class GanttDataTree extends DataTree<IParsedTask> {
     getIndexById(id: TID): number;
     add(task: Partial<ITask>, index: number): IParsedTask;
     copy(taskObj: ITask, parent: TID, ind: number): TID[][];
-    normalizeTask(task: Partial<ITask>, tasks?: Partial<ITask>[]): ITask;
+    normalizeTask(task: Partial<ITask>): ITask;
     getSummaryId(id: TID): TID | null;
+    getSummaryId(id: TID, all: true): TID[] | null;
     sort(conf: TSort[]): void;
     sortBranch(conf: TSort[], parent?: TID): void;
     serialize(): Partial<ITask>[];

package/dist/types/columns.d.ts

@@ -1,3 +1,3 @@
-import type { GanttColumn } from "./types";
-export declare function normalizeColumns(columns: GanttColumn[]): GanttColumn[];
-export declare const defaultColumns: GanttColumn[];
+import type { IGanttColumn } from "./types";
+export declare function normalizeColumns(columns: IGanttColumn[]): IGanttColumn[];
+export declare const defaultColumns: IGanttColumn[];

package/dist/types/helpers/actionHandlers.d.ts

@@ -1,5 +1,8 @@
 import type { TID } from "@wx/lib-state";
+import type { IDataHash } from "../types";
 import { IOptionConfig } from "./menuOptions";
 import { IButtonConfig } from "./toolbarButtons";
-export declare function handleAction(api: any, action: string, target: TID | null, _: any): void;
+type TTarget = TID | IDataHash | null;
+export declare function handleAction(api: any, action: string, target: TTarget, _: any): void;
 export declare function isHandledAction(options: IOptionConfig[] | IButtonConfig[], id: TID): boolean;
+export {};

package/dist/types/helpers/editorItems.d.ts

@@ -0,0 +1,3 @@
+import type { TEditorItem, IDataConfig } from "../types";
+export declare function getEditorItems(config: IDataConfig): TEditorItem[];
+export declare const defaultEditorItems: TEditorItem[];

package/dist/types/helpers/getCircularLinks.d.ts

@@ -0,0 +1,3 @@
+import { TID } from "@wx/lib-state";
+import { ILink } from "src/types";
+export declare function getCircularLinks(links: ILink[]): Set<TID>;

package/dist/types/helpers/menuOptions.d.ts

@@ -1,5 +1,6 @@
 import type { TID } from "@wx/lib-state";
-import type { ITask, IGanttTask } from "../types";
+import type { IParsedTask, IHistory, IData, IDataConfig, IDataHash } from "../types";
+export declare function getMenuOptions(config: IDataConfig): IOptionConfig[];
 export interface IOptionConfig {
     id?: TID;
     separator?: boolean;
@@ -7,9 +8,10 @@ export interface IOptionConfig {
     icon?: string;
     data?: IOptionConfig[];
     type?: string;
-    check?: (task: ITask, _tasks?: IGanttTask[]) => boolean | TID;
+    isDisabled?: ((task: IParsedTask, state: IData, target?: TID | IDataHash) => boolean) | ((history: IHistory) => boolean);
     dataFactory?: (obj: any) => IOptionConfig;
     subtext?: string;
+    isHidden?: (task: IParsedTask, state: IData, target?: TID | IDataHash) => boolean;
 }
 export declare function assignChecks<T extends IOptionConfig>(items: T[]): T[];
 export declare const defaultMenuOptions: IOptionConfig[];

package/dist/types/helpers/toolbarButtons.d.ts

@@ -1,3 +1,6 @@
+import type { IData, IDataHash, IParsedTask, IHistory, IDataConfig } from "../types";
+import type { TID } from "@wx/lib-state";
+export declare function getToolbarButtons(config: IDataConfig): IButtonConfig[];
 export interface IButtonConfig {
     id?: string;
     comp: string;
@@ -5,6 +8,7 @@ export interface IButtonConfig {
     icon?: string;
     type?: string;
     menuText?: string;
-    check?: (params: any) => boolean;
+    isDisabled?: ((task: IParsedTask, state: IData, target?: TID | IDataHash) => boolean) | ((history: IHistory) => boolean);
+    isHidden?: (task: IParsedTask, state: IData, target?: TID | IDataHash) => boolean;
 }
 export declare const defaultToolbarButtons: IButtonConfig[];

package/dist/types/index.d.ts

@@ -1,12 +1,16 @@
 export { default as DataStore } from "./DataStore";
 export { grid } from "./dom/scales";
-export { placeLink } from "./links";
+export { placeLink, normalizeLinks } from "./links";
 export { getDiffer, getAdder, getUnitStart, format, registerScaleUnit, } from "./time";
 export { handleAction, isHandledAction } from "./helpers/actionHandlers";
-export { defaultToolbarButtons } from "./helpers/toolbarButtons";
-export { defaultMenuOptions } from "./helpers/menuOptions";
-export { defaultEditorItems } from "./editorItems";
+export { defaultToolbarButtons, getToolbarButtons, } from "./helpers/toolbarButtons";
+export { defaultMenuOptions, getMenuOptions } from "./helpers/menuOptions";
+export { defaultEditorItems, getEditorItems } from "./helpers/editorItems";
 export { defaultColumns } from "./columns";
 export { defaultTaskTypes } from "./taskTypes";
-export { normalizeDates } from "./normalizeDates";
-export type { TID, ITask, ILink, IZoomConfig, GanttColumn, TMethodsConfig, } from "./types";
+export { prepareEditTask, parseTaskDates } from "./normalizeDates";
+export { normalizeZoom } from "./scales";
+export { isSegmentMoveAllowed, extendDragOptions } from "./tasks";
+import { Calendar as _Calendar } from "@wx/lib-schedule";
+export declare const Calendar: typeof _Calendar;
+export type { TID, IApi, ITask, ILink, IConfig, IZoomConfig, IGanttColumn, TMethodsConfig, IGanttTask, IMarker, IScheduleConfig, ICriticalPathConfig, IScaleConfig, } from "./types";

package/dist/types/links.d.ts

@@ -1,4 +1,4 @@
-import type { IGanttTask, IGanttLink } from "./types";
+import type { IGanttTask, IGanttLink, ILink } from "./types";
 export declare const updateLink: (link: IGanttLink, startTask: IGanttTask, endTask: IGanttTask, height: number, baselines: boolean) => IGanttLink;
 export declare function placeLink(box: {
     left: number;
@@ -16,3 +16,10 @@ export declare function placeLink(box: {
     top: number;
     p: string;
 };
+export declare function normalizeLinks(links: ILink[]): {
+    id: import("@wx/lib-state").TID;
+    type: import("./types").TLinkType;
+    source: import("@wx/lib-state").TID;
+    target: import("@wx/lib-state").TID;
+    lag?: number;
+}[];

package/dist/types/modules/AutoScheduler.pro.d.ts

@@ -0,0 +1,15 @@
+import { EventTracker } from "./EventTracker.pro";
+import type { TID } from "../types";
+export declare class AutoSchedulerModule extends EventTracker {
+    private taskTracker;
+    private linkTracker;
+    init(): void;
+    destroy(): void;
+    schedule(id?: TID, deleteInvalidLinks?: boolean): void;
+    protected getDefaultTag(): string;
+    private setupScheduleHandler;
+    private setupTaskHandlers;
+    private setupLinkHandlers;
+    private deleteInvalidLinks;
+    private getInvalidLinks;
+}

package/dist/types/modules/ChangeTracker.pro.d.ts

@@ -0,0 +1,10 @@
+import type { TID } from "../types";
+export declare class ChangeTracker<T extends {
+    id?: TID;
+}> {
+    private prevState;
+    track(id: TID, item: Partial<T>, properties: (keyof T)[]): void;
+    hasChanged(id: TID, item: Partial<T>, properties: (keyof T)[]): boolean;
+    clear(id?: TID): void;
+    getSnapshot(id: TID): Partial<T> | undefined;
+}

package/dist/types/modules/CriticalPath.pro.d.ts

@@ -0,0 +1,11 @@
+import { EventTracker } from "./EventTracker.pro";
+export declare class CriticalPathModule extends EventTracker {
+    private taskTracker;
+    private linkTracker;
+    init(): void;
+    destroy(): void;
+    calculate(): void;
+    protected getDefaultTag(): string;
+    private setupTaskHandlers;
+    private setupLinkHandlers;
+}

package/dist/types/modules/EventTracker.pro.d.ts

@@ -0,0 +1,20 @@
+import { EventBus } from "@wx/lib-state";
+import type { TMethodsConfig, IData } from "../types";
+export declare abstract class EventTracker {
+    protected in: EventBus<TMethodsConfig, keyof TMethodsConfig>;
+    protected getState: () => Partial<IData>;
+    protected setState: (state: Partial<IData>) => void;
+    protected getHistory: () => any;
+    private _timer;
+    private _tags;
+    constructor(eventBus: EventBus<TMethodsConfig, keyof TMethodsConfig>, stateGetter: () => Partial<IData>, stateSetter: (state: Partial<IData>) => void, historyGetter: () => any);
+    abstract init(): void;
+    abstract destroy(): void;
+    protected debounce(code: () => void, delay?: number): void;
+    protected shouldTrack(ev: any, noTrack?: Record<string, number>): boolean;
+    protected registerHandler<K extends keyof TMethodsConfig>(type: "on" | "intercept", event: K, handler: (ev: TMethodsConfig[K]) => void, tag?: string): void;
+    protected on<K extends keyof TMethodsConfig>(event: K, handler: (ev: TMethodsConfig[K]) => void, tag?: string): void;
+    protected intercept<K extends keyof TMethodsConfig>(event: K, handler: (ev: TMethodsConfig[K]) => void, tag?: string): void;
+    protected detachHandlers(): void;
+    protected abstract getDefaultTag(): string;
+}

package/dist/types/modules/HistoryManager.pro.d.ts

@@ -0,0 +1,48 @@
+import { IDataHash, TMethodsConfig } from "../types";
+import { EventTracker } from "./EventTracker.pro";
+type TActionType = keyof TMethodsConfig;
+type TBatchAction = "batch";
+type TAllActionTypes = TActionType | TBatchAction;
+type TSubActionData = IDataHash & {
+    action?: TActionType;
+};
+interface IActionData<T extends TAllActionTypes> {
+    action: T;
+    data: T extends TActionType ? TMethodsConfig[T] | TSubActionData : IHistoryEntry[];
+}
+interface IHistoryEntry extends IActionData<TAllActionTypes> {
+    source: IActionData<TAllActionTypes>;
+}
+interface IActionHandlers {
+    handler: (ev: any) => IHistoryEntry;
+    getSnapshot?: (ev: any) => IDataHash;
+    progress?: boolean;
+}
+export declare class HistoryManager extends EventTracker {
+    private undo;
+    private redo;
+    private progress;
+    private _dataSnapshot;
+    private _batch;
+    private _isBatching;
+    init(): void;
+    destroy(): void;
+    protected getDefaultTag(): string;
+    getHandlers(): {
+        [key: string]: IActionHandlers;
+    };
+    resetHistory(): void;
+    private setHandlers;
+    private setPrevData;
+    private getPrevData;
+    private addToHistory;
+    startBatch(): void;
+    endBatch(): void;
+    handleUndo(): void;
+    handleRedo(): void;
+    private executeHistoryEntry;
+    private resetStateHistory;
+    private setStateHistory;
+    private getOrder;
+}
+export {};

package/dist/types/normalizeDates.d.ts

@@ -1,4 +1,6 @@
-import type { ITask } from "./types";
-export declare function prepareTask(currentTask: Partial<ITask>, task: Partial<ITask>, unit: "day" | "hour"): void;
-export declare function normalizeDates(task: Partial<ITask>, unit: "day" | "hour", edit?: boolean, key?: string): void;
+import type { ITask, IData } from "./types";
+export declare function parseTaskDates(tasks: ITask[], state: Partial<IData>): void;
+export declare function normalizeDates(task: Partial<ITask>, state: Partial<IData>): void;
+export declare function calcDates(task: Partial<ITask>, state: Partial<IData>, isBaseline?: boolean): void;
 export declare function getFields(isBaseline: boolean): string[];
+export declare function prepareEditTask(task: Partial<ITask>, state: Partial<IData>, key: string): void;

package/dist/types/scales.d.ts

@@ -1,20 +1,21 @@
-import type { GanttScale, GanttScaleData, IZoomConfig } from "./types";
+import type { IScaleConfig, GanttScaleData, IUnitFormats, IZoomConfig, TLengthUnit } from "./types";
 import type GanttDataTree from "./GanttDataTree";
-export declare function getMinUnit(scales: GanttScale[]): GanttScale;
+import { Day } from "date-fns";
+export declare function getMinUnit(scales: IScaleConfig[]): IScaleConfig;
 export declare const units: string[];
 export declare function calcScales(prevStart: Date, prevEnd: Date, autoScale: boolean, minUnit?: string, tasks?: GanttDataTree): {
     _start: Date;
     _end: Date;
 };
-export declare function resetScales(start: Date, end: Date, lengthUnit: string, width: number, height: number, scales: GanttScale[]): GanttScaleData | null;
-export declare function normalizeZoom(zoom: boolean | IZoomConfig, scales: GanttScale[], cellWidth: number): {
-    _zoom: IZoomConfig;
-    scales: GanttScale[];
+export declare function resetScales(start: Date, end: Date, lengthUnit: TLengthUnit, width: number, height: number, _weekStart: Day, scales: IScaleConfig[]): GanttScaleData | null;
+export declare function normalizeZoom(zoom: boolean | IZoomConfig, unitFormats: IUnitFormats, scales: IScaleConfig[], cellWidth: number): {
+    zoom: IZoomConfig;
+    scales: IScaleConfig[];
     cellWidth: number;
 };
-export declare function zoomScale(zoom: IZoomConfig, step: number, level: number, nextUnit: any, lengthUnit: string, scales: GanttScale[], cellWidth: number): {
-    scales: GanttScale[];
+export declare function zoomScale(zoom: IZoomConfig, step: number, level: number, nextUnit: any, lengthUnit: TLengthUnit, scales: IScaleConfig[], cellWidth: number): {
+    scales: IScaleConfig[];
     cellWidth: number;
-    lengthUnit: string;
+    lengthUnit: TLengthUnit;
     zoom: IZoomConfig;
 };

package/dist/types/splitTasks.pro.d.ts

@@ -0,0 +1,11 @@
+import { ITask, IData, IParsedTask, IDataHash, Calendar } from "./types";
+type TSegment = Partial<ITask>;
+export declare function calcSplitDates(task: Partial<ITask>, stateOptions: Partial<IData>): void;
+export declare function dragSplitTask(task: IParsedTask, ev: IDataHash): boolean;
+export declare function updateSplitTask(task: IParsedTask, update: Partial<ITask | TSegment>, stateOptions: Partial<IData>, index?: number, diff?: number): Partial<ITask | Partial<ITask>>;
+export declare function splitTask(task: IParsedTask, index: number | undefined, stateOptions: Partial<IData>): Partial<IParsedTask>;
+export declare function isIndivisibleType(task: Partial<ITask>): boolean;
+export declare function isIndivisible(task: IParsedTask, stateOptions: Partial<IData>, index?: number): boolean;
+export declare function getEndAdder(unit: string, calendar: Calendar): (start: number | Date, step: number) => Date;
+export declare function shiftNextSegments(segments: Partial<ITask>[], lengthUnit: string, index: number, calendar: Calendar, dir?: number): void;
+export {};

package/dist/types/tasks.d.ts

@@ -1,5 +1,7 @@
-import type { IGanttTask, GanttScaleData, IParsedTask, GanttDataTree, ITask } from "./types";
-export declare function dragSummaryKids(task: IParsedTask, dx: number): void;
+import { IGanttTask, GanttScaleData, IParsedTask, GanttDataTree, ITask, IData, IDataHash } from "./types";
+export declare function dragSummaryKids(task: IParsedTask, dx: number, _scales: GanttScaleData, cellWidth: number): void;
 export declare function dragSummary(tasks: GanttDataTree, task: IParsedTask, _scales: GanttScaleData, cellWidth: number): void;
-export declare function setSummaryDates(task: IParsedTask, tasks?: Partial<ITask>[]): IParsedTask;
-export declare function updateTask(t: IGanttTask, i: number, cellWidth: number, cellHeight: number, scales: GanttScaleData, baselines: boolean): IGanttTask;
+export declare function setSummaryDates(task: ITask, tasks?: Partial<ITask>[]): ITask;
+export declare function updateTask(t: IGanttTask, i: number, state: Partial<IData>): IGanttTask;
+export declare function isSegmentMoveAllowed(task: IGanttTask, moveOptions: IDataHash): boolean;
+export declare function extendDragOptions(task: ITask, options: IDataHash): void;

package/dist/types/time.d.ts

@@ -1,16 +1,17 @@
-import { format } from "date-fns";
+import { format, Day } from "date-fns";
+import type { GanttScaleUnit, Calendar } from "./types";
 export declare function getSmallerUnitCount(unit: string, lengthUnit: string, date?: Date): number;
 export declare function isCorrectLengthUnit(minUnit: string, lengthUnit: string): boolean;
-export declare function getDiffer(unit: string): {
+export declare function getDiffer(unit: string, calendar?: Calendar, _weekStart?: Day): {
     (start: Date, end: Date, lengthUnit?: string, unitSize?: boolean): number;
 };
-export declare function getAdder(unit: string): {
+export declare function getAdder(unit: string, calendar?: Calendar): {
     (start: number | Date, step: number): Date;
 };
-export declare function getUnitStart(unit: string, date: Date): Date;
-export declare function getUnitEnd(unit: string, date: Date): Date;
-export declare function isSameUnit(unit: string, a: Date, b: Date): boolean;
-export declare function registerScaleUnit(unit: string, config: {
-    [name: string]: any;
-}): void;
+export declare function getUnitStart(unit: string, date: Date, _weekStart?: Day): Date;
+export declare function getUnitEnd(unit: string, date: Date, _weekStart?: Day): Date;
+export declare function isSameUnit(unit: string, a: Date, b: Date, _weekStart?: Day): boolean;
+export declare function registerScaleUnit(unit: string, config: GanttScaleUnit): void;
+export declare function adjustToWorkingDay(start: Date, diff: number, calendar: Calendar): Date;
+export declare function shiftByWorkingDays(calendar: Calendar): (date: Date, diff: number) => Date;
 export { format };