@svar-ui/gantt-store 2.6.2 → 2.7.0

package/dist/types/DataStore.d.ts

@@ -1,13 +1,17 @@
 import { Store, EventBus } from "@svar-ui/lib-state";
 import type { TDataConfig, TWritableCreator, TID } from "@svar-ui/lib-state";
 import { HistoryManager } from "./pro/HistoryManager";
-import type { IData, IDataConfig, ITask, TMethodsConfig, ILink, IVisibleArea, IParsedTask, IExportConfig, TFilterHandler, TScrollMode } from "./types";
+import { GroupManager } from "./pro/GroupManager";
+import type { IData, IDataConfig, ITask, TMethodsConfig, IResourceColumn, ILink, IResource, IVisibleArea, IParsedTask, IExportConfig, TFilterHandler, TScrollMode, IAssignment, IGroupByConfig, TDataName, TResourceAssignment, ICalendar, TDisplayMode } from "./types";
 export default class DataStore extends Store<IData> {
     in: EventBus<TMethodsConfig, keyof TMethodsConfig>;
     private _router;
     private _modules;
+    private _prevScaleMinUnit?;
+    private _prevConfig;
     constructor(w: TWritableCreator);
     init(state: Partial<IDataConfig>): void;
+    private changed;
     private enableModule;
     private disableModule;
     setState(state: Partial<IData>, ctx?: TDataConfig): {
@@ -15,16 +19,26 @@ export default class DataStore extends Store<IData> {
     };
     setStateAsync(state: Partial<IData>): void;
     getTask(id: TID): IParsedTask;
+    getResource(id: TID): import("./types").IParsedResource;
     getHistory(): HistoryManager;
-    serialize(): Partial<ITask>[];
+    getCalendar(id?: TID): ICalendar | undefined;
+    getTaskCalendar(task: Partial<ITask>): ICalendar | undefined;
+    getResourceCalendar(resource: Partial<IResource>): ICalendar | undefined;
+    private getLoadHours;
+    getGrouping(): GroupManager;
+    serialize(config?: {
+        data: TDataName;
+    }): any[];
+    getTaskResources(id: TID): Array<TResourceAssignment>;
+    getResourceTasks(id: TID): IParsedTask[];
     private changeScale;
+    private shouldExpandScale;
     private isScheduled;
     private resetSummaryDates;
     private moveSummaryKids;
-    private calcScaleDate;
     getNextRow(id: TID): IParsedTask;
     getPrevRow(id: TID): IParsedTask;
-    scrollToTask(id: TID, mode: TScrollMode, eventSource?: keyof IDataMethodsConfig): void;
+    scrollToTask(id: TID, mode: TScrollMode): void;
 }
 type CombineTypes<T, N> = {
     [P in keyof T]: T[P] & N;
@@ -60,9 +74,9 @@ export type IDataMethodsConfig = CombineTypes<{
         id: TID;
         toggle?: boolean;
         range?: boolean;
-        column?: string | boolean;
         show?: TScrollMode;
         focus?: "grid" | "chart";
+        eventSource?: string;
     };
     ["drag-task"]: {
         id: TID;
@@ -99,7 +113,6 @@ export type IDataMethodsConfig = CombineTypes<{
         id?: TID;
         link: Partial<ILink>;
         eventSource?: string;
-        skipUndo: boolean;
     };
     ["update-link"]: {
         id: TID;
@@ -112,7 +125,6 @@ export type IDataMethodsConfig = CombineTypes<{
         left?: number;
         top?: number;
         date?: Date;
-        eventSource?: string;
     };
     ["render-data"]: IVisibleArea;
     ["request-data"]: {
@@ -123,6 +135,7 @@ export type IDataMethodsConfig = CombineTypes<{
         data: {
             tasks?: Array<ITask>;
             links?: Array<ILink>;
+            assignments?: Array<IAssignment>;
         };
     };
     ["zoom-scale"]: {
@@ -141,6 +154,7 @@ export type IDataMethodsConfig = CombineTypes<{
         value?: any;
         open?: boolean;
     };
+    ["group-tasks"]: IGroupByConfig;
     ["hotkey"]: {
         key: string;
         event: any;
@@ -154,6 +168,7 @@ export type IDataMethodsConfig = CombineTypes<{
     ["schedule-tasks"]: {
         id?: TID;
         task?: Partial<ITask>;
+        link?: TID;
     };
     ["undo"]: void;
     ["redo"]: void;
@@ -166,9 +181,36 @@ export type IDataMethodsConfig = CombineTypes<{
         data: string;
         format?: "mspx";
     };
+    ["add-assignment"]: {
+        id?: TID;
+        assignment: Partial<IAssignment>;
+    };
+    ["delete-assignment"]: {
+        id: TID;
+    };
+    ["update-assignment"]: {
+        id: TID;
+        assignment: Partial<IAssignment>;
+    };
+    ["resize-grid"]: {
+        width: number;
+    };
+    ["set-display-mode"]: {
+        mode: TDisplayMode;
+    };
+    ["open-resource-row"]: {
+        id: TID;
+        mode: boolean;
+    };
+    ["sort-resources"]: {
+        key: string;
+        order: "asc" | "desc";
+        add?: boolean;
+        _columns: IResourceColumn[];
+    };
 }, {
     skipProvider?: boolean;
-    spipUndo?: boolean;
+    skipUndo?: boolean;
     [key: string]: any;
 }>;
 export {};

package/dist/types/columns.d.ts

@@ -1,3 +1,6 @@
-import type { IGanttColumn } from "./types";
+import type { IDataConfig, IGanttColumn, IResourceColumn } from "./types";
+export declare const ADD_TASK_COLUMN_WIDTH = 37;
 export declare function normalizeColumns(columns: IGanttColumn[]): IGanttColumn[];
 export declare const defaultColumns: IGanttColumn[];
+export declare function getDefaultColumns(config?: Partial<IDataConfig>): IGanttColumn[];
+export declare function getResourceColumns(): IResourceColumn[];

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

@@ -0,0 +1,4 @@
+import { IVisibleArea } from "../types";
+export declare function calculateArea(scrollPos: number, viewportSize: number, cells: {
+    width: number;
+}[], extra?: number): IVisibleArea;

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

@@ -1,4 +1,4 @@
-import type { TEditorItem, ITask, IData, IDataConfig } from "../types";
+import type { TEditorItem, ITask, IData, IDataConfig, IDataHash } from "../types";
 export declare function getEditorItems(config?: IDataConfig): ({
     [x: string]: any;
     id?: import("@svar-ui/lib-state").TID;
@@ -6,7 +6,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "text" | "textarea";
 } | {
@@ -16,7 +16,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "counter";
 } | {
@@ -26,7 +26,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "radio";
     options: {
@@ -40,7 +40,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "combo" | "select" | "multiselect";
     options?: {
@@ -54,7 +54,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "checkbox";
 } | {
@@ -64,7 +64,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "slider";
 } | {
@@ -74,7 +74,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "date";
     time?: boolean;
@@ -85,7 +85,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "links";
 } | {
@@ -95,8 +95,42 @@ export declare function getEditorItems(config?: IDataConfig): ({
     label?: string;
     labelTemplate?: (value: any) => string;
     config?: Record<string, any>;
-    isHidden?: (task: Partial<ITask>) => boolean;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "twostate";
+} | {
+    [x: string]: any;
+    id?: import("@svar-ui/lib-state").TID;
+    key: string;
+    label?: string;
+    labelTemplate?: (value: any) => string;
+    config?: Record<string, any>;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
+    isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
+    comp: "resources";
+} | {
+    [x: string]: any;
+    id?: import("@svar-ui/lib-state").TID;
+    key: string;
+    label?: string;
+    labelTemplate?: (value: any) => string;
+    config?: Record<string, any>;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
+    isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
+    comp: "tabs";
+} | {
+    [x: string]: any;
+    id?: import("@svar-ui/lib-state").TID;
+    key: string;
+    label?: string;
+    labelTemplate?: (value: any) => string;
+    config?: Record<string, any>;
+    isHidden?: (task: Partial<ITask>, state: IData) => boolean;
+    isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
+    comp: "segments";
 })[];
 export declare const defaultEditorItems: TEditorItem[];
+export declare function filterEditorButtons(items: IDataHash[], handler?: (item: IDataHash) => boolean): IDataHash[];
+export declare function getEditorButtons(config?: IDataConfig & {
+    autoSave: boolean;
+}): IDataHash[];

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

@@ -1,3 +1,4 @@
 import { IParsedTask, TFilterHandler, TID } from "../types";
 export declare function filterTask(task: IParsedTask, filter: TFilterHandler, ids: Set<TID>, open?: boolean): boolean;
 export declare function deleteFromFiltered(ids: Set<string | number>, id: TID, branch?: IParsedTask[]): void;
+export declare function resetEmptyState(task: IParsedTask): void;

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

@@ -1,14 +1,27 @@
 import type { TID } from "@svar-ui/lib-state";
-import type { IParsedTask, IHistory, IData, IDataConfig, IDataHash } from "../types";
-export declare function getMenuOptions(config?: IDataConfig): IOptionConfig[];
+import type { IParsedTask, IHistory, IData, IDataConfig, IDataHash, ICalendar } from "../types";
+export declare function getMenuOptions(config?: IDataConfig & {
+    group?: boolean;
+}): {
+    id?: TID;
+    separator?: boolean;
+    text?: string;
+    icon?: string;
+    data?: IOptionConfig[];
+    comp?: string;
+    isDisabled?: ((task: IParsedTask, state?: IData, calendar?: ICalendar, target?: TID | IDataHash) => boolean) | ((history: IHistory) => boolean);
+    dataFactory?: (obj: any) => IOptionConfig;
+    subtext?: string;
+    isHidden?: (task: IParsedTask, state: IData, target?: TID | IDataHash) => boolean;
+}[];
 export interface IOptionConfig {
     id?: TID;
     separator?: boolean;
     text?: string;
     icon?: string;
     data?: IOptionConfig[];
-    type?: string;
-    isDisabled?: ((task: IParsedTask, state: IData, target?: TID | IDataHash) => boolean) | ((history: IHistory) => boolean);
+    comp?: string;
+    isDisabled?: ((task: IParsedTask, state?: IData, calendar?: ICalendar, target?: TID | IDataHash) => boolean) | ((history: IHistory) => boolean);
     dataFactory?: (obj: any) => IOptionConfig;
     subtext?: string;
     isHidden?: (task: IParsedTask, state: IData, target?: TID | IDataHash) => boolean;

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

@@ -1,2 +1,2 @@
-import type { IGanttColumn, IParsedTask, TSort } from "../types";
+import { IGanttColumn, IParsedTask, TSort } from "../types";
 export declare function sort(data: IParsedTask[], conf: TSort[], columns: IGanttColumn[]): IParsedTask[];

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

@@ -1,6 +1,8 @@
 import type { IData, IDataHash, IParsedTask, IHistory, IDataConfig } from "../types";
 import type { TID } from "@svar-ui/lib-state";
-export declare function getToolbarButtons(config?: IDataConfig): IButtonConfig[];
+export declare function getToolbarButtons(config?: IDataConfig & {
+    group?: boolean;
+}): IButtonConfig[];
 export interface IButtonConfig {
     id?: string;
     comp: string;

package/dist/types/index.d.ts

@@ -1,15 +1,17 @@
 export { default as DataStore } from "./DataStore";
 export { grid } from "./dom/scales";
 export { placeLink, normalizeLinks } from "./links";
-export { getDiffer, getAdder, getUnitStart, format, registerScaleUnit, } from "./time";
+export { getDiffer, getAdder, getUnitStart, format, formatDay, registerScaleUnit, } from "./time";
 export { handleAction, isHandledAction } from "./helpers/actionHandlers";
+export { calculateArea } from "./helpers/area";
 export { defaultToolbarButtons, getToolbarButtons, } from "./helpers/toolbarButtons";
 export { defaultMenuOptions, getMenuOptions } from "./helpers/menuOptions";
-export { defaultEditorItems, getEditorItems } from "./helpers/editorItems";
-export { defaultColumns } from "./columns";
+export { defaultEditorItems, getEditorItems, getEditorButtons, filterEditorButtons, } from "./helpers/editorItems";
+export { defaultColumns, getDefaultColumns, getResourceColumns, } from "./columns";
 export { defaultTaskTypes } from "./taskTypes";
 export { prepareEditTask, parseTaskDates } from "./normalizeDates";
 export { normalizeZoom } from "./scales";
 export { isSegmentMoveAllowed, extendDragOptions } from "./tasks";
-export declare const Calendar: any;
-export type { TID, IApi, ITask, ILink, IConfig, IZoomConfig, IGanttColumn, TMethodsConfig, IGanttTask, IMarker, IScheduleConfig, ICriticalPathConfig, IScaleConfig, } from "./types";
+export type { TID, IApi, ITask, ILink, IResource, IAssignment, IDataAssignment, IComputedResource, IResourceLoad, IResourceColumn, IConfig, IZoomConfig, IGanttColumn, TMethodsConfig, IGanttTask, IMarker, IScheduleConfig, ICriticalPathConfig, IScaleConfig, ICalendarRule, CalendarConfig, } from "./types";
+import { CalendarConfig } from "./types";
+export declare function createCalendar(config?: CalendarConfig): any;

package/dist/types/normalizeDates.d.ts

@@ -1,6 +1,6 @@
-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;
+import type { ITask, IData, ICalendar, TCalendarGetter } from "./types";
+export declare function parseTaskDates(tasks: ITask[], state: Partial<IData>, calendarGetter: TCalendarGetter): void;
+export declare function normalizeDates(task: Partial<ITask>, state: Partial<IData>, calendar: ICalendar | undefined): void;
+export declare function calcDates(task: Partial<ITask>, state: Partial<IData>, calendar: ICalendar | undefined, isBaseline?: boolean): void;
 export declare function getFields(isBaseline: boolean): string[];
-export declare function prepareEditTask(task: Partial<ITask>, state: Partial<IData>, key: string): void;
+export declare function prepareEditTask(task: Partial<ITask>, state: Partial<IData>, calendar: ICalendar, key: string): void;

package/dist/types/scales.d.ts

@@ -20,3 +20,4 @@ export declare function zoomScale(zoom: IZoomConfig, step: number, level: number
     zoom: IZoomConfig;
 };
 export declare function expandScale(minWidth: number, state: Partial<IData>): Partial<IData>;
+export declare function calcScaleDate(x: number, state: Partial<IData>): Date;

package/dist/types/schedule-types.d.ts

@@ -0,0 +1,5 @@
+export type TaskSlackInfo = any;
+export type ICalendarRule = any;
+export type CalendarConfig = any;
+export type ICalendar = any;
+export declare const Calendar: any;

package/dist/types/time.d.ts

@@ -1,17 +1,18 @@
 import { format, Day } from "date-fns";
-import type { GanttScaleUnit, Calendar } from "./types";
+import type { GanttScaleUnit, ICalendar } 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, calendar?: Calendar, _weekStart?: Day): {
+export declare function getDiffer(unit: string, calendar?: ICalendar, _weekStart?: Day): {
     (start: Date, end: Date, lengthUnit?: string, unitSize?: boolean): number;
 };
-export declare function getAdder(unit: string, calendar?: Calendar): {
+export declare function getAdder(unit: string, calendar?: ICalendar): {
     (start: number | Date, step: number): Date;
 };
 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 declare function adjustToWorkingDay(start: Date, diff: number, calendar: ICalendar): Date;
+export declare function shiftByWorkingDays(calendar: ICalendar): (date: Date, diff: number) => Date;
+export declare function formatDay(date: Date): string;
 export { format };