@svar-ui/gantt-store 2.3.0 → 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,8 +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/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, IApi, ITask, ILink, IConfig, IZoomConfig, IGanttColumn, TMethodsConfig, IGanttTask, } 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, TDurationUnit } from "./types";
-export declare function prepareTask(currentTask: Partial<ITask>, task: Partial<ITask>, unit: TDurationUnit): void;
-export declare function normalizeDates(task: Partial<ITask>, unit: TDurationUnit, 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,14 +1,15 @@
-import type { IScaleConfig, GanttScaleData, IZoomConfig, TLengthUnit } from "./types";
+import type { IScaleConfig, GanttScaleData, IUnitFormats, IZoomConfig, TLengthUnit } from "./types";
 import type GanttDataTree from "./GanttDataTree";
+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: TLengthUnit, width: number, height: number, scales: IScaleConfig[]): GanttScaleData | null;
-export declare function normalizeZoom(zoom: boolean | IZoomConfig, scales: IScaleConfig[], cellWidth: number): {
-    _zoom: IZoomConfig;
+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;
 };

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,15 +1,17 @@
-import { format } from "date-fns";
-import type { GanttScaleUnit } from "./types";
+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 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 };

package/dist/types/types.d.ts

@@ -1,6 +1,7 @@
 import type { IDataMethodsConfig } from "./DataStore";
 import type { DataArray, TID, IEventBus, IPublicWritable, IEventConfig } from "@wx/lib-state";
 import type GanttDataTree from "./GanttDataTree";
+import { Day } from "date-fns";
 import type DataStore from "./DataStore";
 import type { IApi as ITableApi, IColumn } from "@wx/grid-store";
 export type TMethodsConfig = IDataMethodsConfig;
@@ -18,10 +19,13 @@ export interface ILink {
     type: TLinkType;
     source: TID;
     target: TID;
+    lag?: number;
 }
 export interface IGanttLink extends ILink {
     id: TID;
     $p: string;
+    $pl: number;
+    $critical?: boolean;
 }
 export interface ITask {
     start?: Date;
@@ -39,6 +43,7 @@ export interface ITask {
     type?: TTaskType;
     parent?: TID;
     unscheduled?: boolean;
+    segments?: Partial<ITask>[];
     [key: string]: any;
 }
 export interface IParsedTask extends ITask {
@@ -55,6 +60,7 @@ export interface IGanttTask extends IParsedTask {
     $x_base?: number;
     $w_base?: number;
     $reorder?: boolean;
+    $critical?: boolean;
 }
 export type TDispatch = <A extends keyof TMethodsConfig>(action: A, data: TMethodsConfig[A]) => void;
 export interface IMethodsHash {
@@ -87,12 +93,58 @@ export interface IMarker {
     css?: string;
     left?: number;
 }
+export interface IHistory {
+    undo: number;
+    redo: number;
+}
+export interface ICriticalPathConfig {
+    type: "strict" | "flexible";
+}
+export interface ICriticalTasks {
+    [key: TID]: boolean;
+}
+type UnitFormatter = (date: Date) => string;
+export interface IUnitFormats {
+    [unit: string]: UnitFormatter | string;
+}
+export interface IScheduleConfig {
+    type?: "forward";
+    auto?: boolean;
+}
+export interface ICalendarConfig {
+    name?: string;
+    weekHours?: {
+        sunday?: number;
+        monday?: number;
+        tuesday?: number;
+        wednesday?: number;
+        thursday?: number;
+        friday?: number;
+        saturday?: number;
+    };
+}
+export interface Calendar {
+    isWorkingDay(date: Date): boolean;
+    addRule(rule: (date: Date) => number): void;
+    clone(config?: ICalendarConfig): Calendar;
+    addWorkingDays(start: Date, days: number, excludeEndDate?: boolean): Date | null;
+    addWorkingHours(start: Date, hours: number): Date | null;
+    getNextWorkingDay(date: Date): Date | null;
+    getPreviousWorkingDay(date: Date): Date | null;
+    getWorkingDays(start: Date, end: Date, excludeEndDate?: boolean): number;
+    getWorkingHours(start: Date, end?: Date, excludeEndDate?: boolean): number;
+    setDayHours(date: Date, hours: number): void;
+    setRangeHours(start: Date, end: Date, hours: number): void;
+}
 export interface IConfig {
     tasks?: ITask[];
     links?: any[];
     taskTypes?: ITaskType[];
     selected?: TID[];
-    activeTask?: TID;
+    activeTask?: TID | {
+        id: TID;
+        segmentIndex: number;
+    };
     scales?: IScaleConfig[];
     columns?: IGanttColumn[];
     start?: Date;
@@ -104,19 +156,26 @@ export interface IConfig {
     scaleHeight?: number;
     zoom?: boolean | IZoomConfig;
     autoScale?: boolean;
-}
-export interface IProConfig extends IConfig {
+    schedule?: IScheduleConfig;
+    undo?: boolean;
     unscheduledTasks?: boolean;
     baselines?: boolean;
     markers?: IMarker[];
+    criticalPath?: ICriticalPathConfig;
+    projectStart?: Date;
+    projectEnd?: Date;
+    calendar?: Calendar;
+    splitTasks?: boolean;
 }
-export interface IDataConfig extends IProConfig {
+export interface IDataConfig extends IConfig {
     scrollLeft: number;
     scrollTop: number;
     area: IVisibleArea;
+    history?: IHistory;
     _cellWidth?: number;
     _sort?: TSort[];
     _scrollTask?: TScrollTask;
+    _weekStart?: Day;
 }
 export interface IData extends Omit<IDataConfig, "tasks" | "links"> {
     zoom?: IZoomConfig;
@@ -129,12 +188,14 @@ export interface IData extends Omit<IDataConfig, "tasks" | "links"> {
     _start?: Date;
     _end?: Date;
     _scales?: GanttScaleData;
-    _markers?: IMarker[];
     _scaleDate?: Date;
     _zoomOffset?: number;
+    _weekStart?: Day;
+    _scrollTask?: TScrollTask;
+    _markers?: IMarker[];
 }
-export interface DataHash {
-    [key: string]: any;
+export interface IDataHash<T = any> {
+    [key: string]: T;
 }
 export type IScaleConfig = {
     unit: TLengthUnit;
@@ -190,6 +251,7 @@ export type IGanttColumn = {
     header?: IColumn["header"];
     id?: string;
     template?: IColumn["template"];
+    _template?: IColumn["template"];
     sort?: boolean;
     cell?: any;
     editor?: IColumn["editor"];
@@ -202,6 +264,8 @@ export type TCommonShape = {
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
     [key: string]: any;
+    isHidden?: (task: Partial<ITask>) => boolean;
+    isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
 };
 export type TTextFieldShape = TCommonShape & {
     comp: "text" | "textarea";
@@ -236,7 +300,7 @@ export type ILinksShape = TCommonShape & {
 export type ITwoStateShape = TCommonShape & {
     comp: "twostate";
 };
-export type TEditorShape = TTextFieldShape | TCounterShape | TComboFieldShape | TSliderShape | TDateFieldShape | TRadioShape | ILinksShape | ITwoStateShape;
+export type TEditorItem = TTextFieldShape | TCounterShape | TComboFieldShape | TSliderShape | TDateFieldShape | TRadioShape | ILinksShape | ITwoStateShape;
 export type ITaskType = {
     id: TID;
     label: string;

package/license.txt

@@ -1,21 +1,9 @@
 MIT License
 
-Copyright (c) 2025 XB Software Sp. z o.o.
+Copyright (c) 2025 XB Software Sp. z o.o
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -1,24 +1,26 @@
 {
-	"name": "@svar-ui/gantt-store",
-	"version": "2.3.0",
-	"type": "module",
-	"main": "dist/index.js",
-	"module": "dist/index.js",
-	"types": "dist/types/index.d.ts",
-	"license": "MIT",
-	"scripts": {
-		"build": "vite build",
-		"watch": "vite build --mode development -w",
-		"lint": "yarn eslint ./src",
-		"test": "vitest --run",
-		"coverage": "vitest --run --coverage"
-	},
-	"files": [
-		"dist",
-		"license.txt"
-	],
-	"dependencies": {
-		"@svar-ui/lib-state": "1.9.6",
-		"date-fns": "3.6.0"
-	}
+  "name": "@svar-ui/gantt-store",
+  "version": "2.4.0",
+  "description": "Internal state management used by SVAR Gantt component",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "vite build",
+    "watch": "vite build --mode development -w",
+    "lint": "yarn eslint ./src",
+    "test": "vitest --run",
+    "coverage": "vitest --run --coverage"
+  },
+  "files": [
+    "dist",
+    "licenses",
+    "license.txt"
+  ],
+  "dependencies": {
+    "date-fns": "3.6.0",
+    "@svar-ui/lib-state": "1.9.6"
+  }
 }

package/readme.md

@@ -0,0 +1,5 @@
+# SVAR Gantt Store
+
+This package is part of the **SVAR Gantt (Open-Source Edition)** functionality and is distributed under the MIT license.
+
+The **gantt-store** package handles the internal state management used by the Gantt component.

package/dist/types/editorItems.d.ts

@@ -1,2 +0,0 @@
-import type { TEditorShape } from "./types";
-export declare const defaultEditorItems: TEditorShape[];