@svar-ui/gantt-store 2.7.2 → 2.8.0

package/dist/types/DataStore.d.ts

@@ -1,31 +1,47 @@
 import { Store, EventBus } from "@svar-ui/lib-state";
 import type { TDataConfig, TWritableCreator, TID } from "@svar-ui/lib-state";
-import { HistoryManager } from "./pro/HistoryManager";
-import { GroupManager } from "./pro/GroupManager";
-import type { IData, IDataConfig, ITask, TMethodsConfig, IGanttColumn, IResourceColumn, ILink, IResource, IVisibleArea, IParsedTask, IExportConfig, TFilterHandler, TScrollMode, IAssignment, IGroupByConfig, TDataName, TResourceAssignment, ICalendar, TDisplayMode } from "./types";
+import type { IData, IDataConfig, ITask, TMethodsConfig, IGanttColumn, IResourceColumn, ILink, IResource, IVisibleArea, IParsedTask, IExportConfig, TFilterHandler, TScrollMode, IAssignment, IGroupByConfig, TDataName, TResourceAssignment, ICalendar, TDisplayModeConfig, IConflict, InvalidLinkReason, TLinkValidator, IHistoryManager, IGroupManager, TDisplayPanel, TColumnSection } from "./types";
 export default class DataStore extends Store<IData> {
     in: EventBus<TMethodsConfig, keyof TMethodsConfig>;
     private _router;
     private _modules;
-    private _prevScaleMinUnit?;
     private _prevConfig;
+    private _pendingGeometry;
+    private _resizeStart;
+    private _placeholderRow;
     constructor(w: TWritableCreator);
-    init(state: Partial<IDataConfig>): void;
+    init(config: Partial<IDataConfig>): void;
+    private isHistorySource;
+    private isRemote;
+    private resetDatasetState;
     private changed;
+    private prepareLayoutConfig;
+    private resyncLayout;
+    private syncLayout;
     private enableModule;
     private disableModule;
     setState(state: Partial<IData>, ctx?: TDataConfig): {
         [key: string]: () => void;
     };
     setStateAsync(state: Partial<IData>): void;
+    private editedRows;
+    private markGeometry;
     getTask(id: TID): IParsedTask;
+    getLinkValidator(): TLinkValidator;
     getResource(id: TID): import("./types").IParsedResource;
-    getHistory(): HistoryManager;
+    getHistory(): IHistoryManager;
     getCalendar(id?: TID): ICalendar | undefined;
+    private buildHighlightTime;
     getTaskCalendar(task: Partial<ITask>): ICalendar | undefined;
+    private resolveTaskCalendar;
+    private indexAssignments;
+    private resolveCalendars;
     getResourceCalendar(resource: Partial<IResource>): ICalendar | undefined;
+    private getAssignedCalendar;
+    private alignAssignedTask;
+    private alignToCalendar;
     private getLoadHours;
-    getGrouping(): GroupManager;
+    getGrouping(): IGroupManager;
     serialize(config?: {
         data: TDataName;
     }): any[];
@@ -35,7 +51,11 @@ export default class DataStore extends Store<IData> {
     private shouldExpandScale;
     private isScheduled;
     private resetSummaryDates;
+    private deriveSummary;
+    private applyInactiveDown;
+    private releaseManualSummaries;
     private moveSummaryKids;
+    getPlaceholderRow(): IParsedTask;
     getNextRow(id: TID): IParsedTask;
     getPrevRow(id: TID): IParsedTask;
     scrollToTask(id: TID, mode: TScrollMode): void;
@@ -49,6 +69,7 @@ export type IDataMethodsConfig = CombineTypes<{
         task: Partial<ITask>;
         target?: TID;
         mode?: "before" | "after" | "child";
+        index?: number;
         show?: TScrollMode;
         select?: boolean;
         eventSource?: string;
@@ -75,7 +96,7 @@ export type IDataMethodsConfig = CombineTypes<{
         toggle?: boolean;
         range?: boolean;
         show?: TScrollMode;
-        focus?: "grid" | "chart";
+        focus?: TDisplayPanel;
         eventSource?: string;
     };
     ["drag-task"]: {
@@ -92,6 +113,7 @@ export type IDataMethodsConfig = CombineTypes<{
         mode?: "before" | "after" | "child";
         source?: TID;
         lazy?: boolean;
+        index?: number;
         eventSource?: string;
         skipUndo?: boolean;
     };
@@ -101,6 +123,8 @@ export type IDataMethodsConfig = CombineTypes<{
         mode: "before" | "after" | "up" | "down" | "child";
         inProgress?: boolean;
         source?: TID;
+        eventSource?: string;
+        skipUndo?: boolean;
     };
     ["indent-task"]: {
         id: TID;
@@ -109,6 +133,9 @@ export type IDataMethodsConfig = CombineTypes<{
     ["show-editor"]: {
         id: TID;
     };
+    ["show-conflicts"]: {
+        mode?: boolean;
+    };
     ["add-link"]: {
         id?: TID;
         link: Partial<ILink>;
@@ -120,6 +147,7 @@ export type IDataMethodsConfig = CombineTypes<{
     };
     ["delete-link"]: {
         id: TID;
+        reason?: InvalidLinkReason;
     };
     ["scroll-chart"]: {
         left?: number;
@@ -164,6 +192,7 @@ export type IDataMethodsConfig = CombineTypes<{
         width: number;
         height: number;
         scrollSize: number;
+        ganttWidth?: number;
     };
     ["schedule-tasks"]: {
         id?: TID;
@@ -189,19 +218,23 @@ export type IDataMethodsConfig = CombineTypes<{
     };
     ["delete-assignment"]: {
         id: TID;
+        eventSource?: string;
     };
     ["update-assignment"]: {
         id: TID;
         assignment: Partial<IAssignment>;
+        eventSource?: string;
     };
     ["resize-grid"]: {
         width: number;
+        section?: TColumnSection;
+        inProgress?: boolean;
     };
     ["set-columns"]: {
         columns: IGanttColumn[];
     };
     ["set-display-mode"]: {
-        mode: TDisplayMode;
+        mode: TDisplayModeConfig;
     };
     ["open-resource-row"]: {
         id: TID;
@@ -213,9 +246,13 @@ export type IDataMethodsConfig = CombineTypes<{
         add?: boolean;
         _columns: IResourceColumn[];
     };
+    ["set-conflicts"]: {
+        conflicts: IConflict[];
+    };
 }, {
     skipProvider?: boolean;
     skipUndo?: boolean;
+    joinUndo?: boolean;
     [key: string]: any;
 }>;
 export {};

package/dist/types/GanttDataTree.d.ts

@@ -7,6 +7,8 @@ export default class GanttDataTree extends DataTree<IParsedTask> {
     getBranch(id: TID): IParsedTask[];
     contains(id: TID, target: TID): boolean;
     getIndexById(id: TID): number;
+    update<Data>(id: TID, values: Data): void;
+    private _indexOf;
     add(task: Partial<ITask>, index: number): IParsedTask;
     copy(taskObj: ITask, parent: TID, ind: number): TID[][];
     remove(id: TID): void;
@@ -15,7 +17,6 @@ export default class GanttDataTree extends DataTree<IParsedTask> {
     getSummaryId(id: TID, all: boolean): TID[] | null;
     sort(conf: TSort[], columns: IGanttColumn[]): void;
     sortBranch(conf: TSort[], parent: TID, columns: IGanttColumn[]): void;
-    serialize(): Partial<ITask>[];
     clear(): void;
     filterTree(filter?: TFilterHandler, open?: boolean): void;
     toArray(all?: boolean): IParsedTask[];

package/dist/types/columns.d.ts

@@ -1,9 +1,14 @@
-import type { IDataConfig, IGanttColumn, IResourceColumn } from "./types";
+import type { IData, IDataConfig, IGanttColumn, IResourceColumn, TCalendarGetter, TColumnSection } from "./types";
+export declare function getColumnsBySection(columns: IGanttColumn[], section?: TColumnSection): IGanttColumn[];
 export declare const ADD_TASK_COLUMN_WIDTH = 37;
-export declare function normalizeColumns(columns: IGanttColumn[]): IGanttColumn[];
+export declare const DEFAULT_COLUMN_WIDTH = 120;
+export declare function getDateEditorButtons(columnId: string, unscheduledTasks?: boolean): ("Unschedule" | "today")[];
+export declare function dropColumnCells(columns: IGanttColumn[]): IGanttColumn[];
+export declare function getHeaderLength(columns: Pick<IGanttColumn, "header" | "hidden">[]): number;
+export declare function normalizeColumns(columns: IGanttColumn[], stateGetter: () => Partial<IData>, calendarGetter?: TCalendarGetter): IGanttColumn[];
 export declare function ensureVisibleFlex(columns: IGanttColumn[]): void;
 export declare const defaultColumns: IGanttColumn[];
 export declare function getDefaultColumns(config?: Partial<IDataConfig>): IGanttColumn[];
-export declare function getDefaultGridWidth(columns: IGanttColumn[]): number;
+export declare function getDefaultGridWidth(columns: IGanttColumn[], section?: TColumnSection): number;
 export declare function getResourceColumns(): IResourceColumn[];
 export declare function normalizeResourceColumns(columns: IResourceColumn[]): IResourceColumn[];

package/dist/types/constraintTypes.d.ts

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

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

@@ -0,0 +1,4 @@
+import type { IDataHash } from "../types";
+export declare function dropUndefined(target: IDataHash, payload: IDataHash): void;
+export declare function clamp<T extends number | Date>(value: T, lower: T, upper: T): T;
+export declare function roundResourceMetric(value: number): number;

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

@@ -29,10 +29,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "radio";
-    options: {
-        id: import("@svar-ui/lib-state").TID;
-        label: string;
-    }[];
+    options: import("../types").IOption[];
 } | {
     [x: string]: any;
     id?: import("@svar-ui/lib-state").TID;
@@ -43,10 +40,7 @@ export declare function getEditorItems(config?: IDataConfig): ({
     isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "combo" | "select" | "multiselect";
-    options?: {
-        id: any;
-        label: string;
-    }[];
+    options?: import("../types").IOption<any>[];
 } | {
     [x: string]: any;
     id?: import("@svar-ui/lib-state").TID;
@@ -128,6 +122,16 @@ export declare function getEditorItems(config?: IDataConfig): ({
     isHidden?: (task: Partial<ITask>, state: IData) => boolean;
     isDisabled?: (task: Partial<ITask>, state: IData) => boolean;
     comp: "segments";
+} | {
+    [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: "constraint";
 })[];
 export declare const defaultEditorItems: TEditorItem[];
 export declare function filterEditorButtons(items: IDataHash[], handler?: (item: IDataHash) => boolean): IDataHash[];

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

@@ -0,0 +1,3 @@
+import { IParsedTask } from "../types";
+export declare function getSegmentProgress(task: IParsedTask, segmentIndex: number): number;
+export declare function getProgressX(task: IParsedTask, splitTasks?: boolean, statusX?: number): number;

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

@@ -0,0 +1,2 @@
+import { IData, IParsedTask, IProgressLineData } from "../types";
+export declare function getProgressLinePoints(visibleTasks: IParsedTask[], progressLine: IProgressLineData, areaFrom: number, state?: Partial<IData>): string;

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

@@ -0,0 +1,2 @@
+import { IApi, ISCurveTooltip } from "../types";
+export declare function resolveSCurvePoint(api: IApi, target: EventTarget | null): ISCurveTooltip | null;

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

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

package/dist/types/inclusiveEnd.d.ts

@@ -0,0 +1,4 @@
+import type { ICalendar, IDataConfig, IGanttColumn, ITask, TCalendarGetter } from "./types";
+export declare function toInclusiveTask(task: Partial<ITask>, calendar?: ICalendar): Partial<ITask>;
+export declare function fromInclusiveTask(values: Partial<ITask>, key: string, stored: Partial<ITask>): Partial<ITask>;
+export declare function setInclusiveEndColumn(column: IGanttColumn, stateGetter: () => Pick<IDataConfig, "inclusiveEnd">, calendarGetter?: TCalendarGetter): IGanttColumn;

package/dist/types/index.d.ts

@@ -2,16 +2,23 @@ export { default as DataStore } from "./DataStore";
 export { grid } from "./dom/scales";
 export { placeLink, normalizeLinks } from "./links";
 export { getDiffer, getAdder, getUnitStart, format, formatDay, registerScaleUnit, } from "./time";
+export { toInclusiveTask, fromInclusiveTask } from "./inclusiveEnd";
 export { handleAction, isHandledAction } from "./helpers/actionHandlers";
 export { calculateArea } from "./helpers/area";
+export { PLACEHOLDER_ROW_ID, isPlaceholder, getPlaceholderTask, } from "./placeholder";
 export { defaultToolbarButtons, getToolbarButtons, } from "./helpers/toolbarButtons";
 export { defaultMenuOptions, getMenuOptions } from "./helpers/menuOptions";
 export { defaultEditorItems, getEditorItems, getEditorButtons, filterEditorButtons, } from "./helpers/editorItems";
-export { defaultColumns, getDefaultColumns, getDefaultGridWidth, getResourceColumns, normalizeResourceColumns, } from "./columns";
+export { getSegmentProgress } from "./helpers/progress";
+export { resolveSCurvePoint } from "./helpers/sCurve";
+export { defaultColumns, getDefaultColumns, getDefaultGridWidth, getHeaderLength, getResourceColumns, getDateEditorButtons, normalizeResourceColumns, } from "./columns";
+export { toggleGridChart, toggleChartSubGrid } from "./layout/displayMode";
 export { defaultTaskTypes } from "./taskTypes";
-export { prepareEditTask, parseTaskDates } from "./normalizeDates";
-export { normalizeZoom } from "./scales";
-export { isSegmentMoveAllowed, extendDragOptions } from "./tasks";
-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";
+export { defaultConstraintTypes } from "./constraintTypes";
+export { prepareEditTask } from "./normalizeDates";
+export { normalizeZoom, calcScaleCellDate } from "./scales";
+export { isSegmentMoveAllowed, extendDragOptions, setTaskResources, } from "./tasks";
+export { getHistogramBars, getHistogramCapacityPath, getResourceLoadColumns, getResourceHistogramColumns, resolveResourceHistogramBar, } from "./resourceLoad";
+export type { TID, IApi, ITask, ILink, IResource, IAssignment, IDataAssignment, IComputedResource, IResourceLoad, IResourceColumn, IHistogramBar, IHistogramColumn, IHistogramColumnPosition, IResourceHistogramConfig, IResourceHistogramTooltip, IConfig, IZoomConfig, IGanttColumn, TMethodsConfig, IGanttTask, IMarker, IScheduleConfig, ICriticalPathConfig, IScaleConfig, ICalendar, ICalendarRule, CalendarConfig, Constraint, IConflict, InvalidLinkReason, TLinkDraft, TLinkValidator, ITaskCalendar, IHistoryManager, TDurationUnit, TSCurveType, TSCurveMetric, TSCurveLine, TSCurveConfig, ISCurveTooltip, ISCurveTooltipLine, } from "./types";
 import { CalendarConfig } from "./types";
 export declare function createCalendar(config?: CalendarConfig): any;

package/dist/types/layout/displayMode.d.ts

@@ -0,0 +1,6 @@
+import type { IGanttColumn, TDisplayModeConfig, TDisplayPanel } from "../types";
+export declare function hasSubGridColumns(columns?: IGanttColumn[]): boolean;
+export declare function normalizeDisplayMode(mode: TDisplayModeConfig | undefined, hasSubGrid: boolean): TDisplayPanel[];
+export declare function toCompactPanels(mode: TDisplayPanel[], current?: TDisplayPanel[] | null): TDisplayPanel[];
+export declare function toggleGridChart(panels: TDisplayPanel[], side: "start" | "end", compact?: boolean): TDisplayPanel[];
+export declare function toggleChartSubGrid(panels: TDisplayPanel[], side: "start" | "end", compact?: boolean): TDisplayPanel[];

package/dist/types/layout/panels.d.ts

@@ -0,0 +1,51 @@
+import type { IData, TDisplayPanel } from "../types";
+export declare const DEFAULT_MIN_CHART_WIDTH = 100;
+export declare const DEFAULT_MIN_CHART_WITH_SUBGRID = 360;
+export declare const DEFAULT_MIN_SUBGRID_WIDTH = 37;
+export declare const DEFAULT_COMPACT_WIDTH = 650;
+export declare function getResizerWidth(hasSubGrid: boolean, panels?: TDisplayPanel[]): number;
+export type TResolveLayoutState = Pick<IData, "displayMode" | "_displayPanels" | "_compactMode" | "gridWidth" | "subGridWidth" | "_containerWidth" | "columns" | "_scrollSize" | "_gridCollapseThreshold">;
+export type TResolveLayoutResult = {
+    compactMode: boolean;
+    gridWidth: number;
+    subGridWidth?: number;
+    displayPanels?: TDisplayPanel[];
+};
+type TPanelMeasure = {
+    ganttWidth: number;
+    gridWidth: number;
+    subGridWidth: number;
+    hasSubGrid: boolean;
+    scrollSize?: number;
+};
+export type TPanelFitMeasure = TPanelMeasure & {
+    collapseThreshold: number;
+    preferredGridWidth?: number;
+    preferredSubGridWidth?: number;
+};
+export declare function samePanels(a: TDisplayPanel[], b: TDisplayPanel[]): boolean;
+export declare function getCollapseThreshold(state: Pick<IData, "_gridCollapseThreshold">): number;
+export declare function getPanelFitMeasure(state: TResolveLayoutState, width: number, scrollSize?: number): TPanelFitMeasure;
+export declare function resolveLayout(state: TResolveLayoutState, measure: {
+    width: number | null | undefined;
+    scrollSize?: number;
+}): TResolveLayoutResult;
+export declare function resolveGridDrag(panels: TDisplayPanel[], measure: TPanelFitMeasure): {
+    gridWidth: number;
+    subGridWidth: number;
+    panels: TDisplayPanel[];
+};
+export declare function resolveSubGridDrag(panels: TDisplayPanel[], measure: TPanelFitMeasure): {
+    subGridWidth: number;
+    panels: TDisplayPanel[];
+};
+export declare function previewGridDrag(panels: TDisplayPanel[], measure: TPanelFitMeasure): {
+    gridWidth: number;
+    panels: TDisplayPanel[];
+};
+export declare function previewSubGridDrag(panels: TDisplayPanel[], measure: TPanelFitMeasure): {
+    subGridWidth: number;
+    panels: TDisplayPanel[];
+};
+export declare function resolvePanelChange(prev: TDisplayPanel[], next: TDisplayPanel[], measure: TPanelFitMeasure): TDisplayPanel[];
+export {};

package/dist/types/links.d.ts

@@ -18,8 +18,8 @@ export declare function placeLink(box: {
 };
 export declare function normalizeLinks(links: ILink[]): {
     id: import("@svar-ui/lib-state").TID;
+    lag: number;
     type: import("./types").TLinkType;
     source: import("@svar-ui/lib-state").TID;
     target: import("@svar-ui/lib-state").TID;
-    lag?: number;
 }[];

package/dist/types/normalizeDates.d.ts

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

package/dist/types/placeholder.d.ts

@@ -0,0 +1,6 @@
+import { IParsedTask, ITask, TID, IData, ICalendar } from "./types";
+export declare const PLACEHOLDER_ROW_ID = "wx_placeholder_row";
+export declare function isPlaceholder(id: TID): boolean;
+export declare function getPlaceholderTask(row: Partial<ITask>, defaultText?: string): Partial<ITask>;
+export declare function createPlaceholderRow(): IParsedTask;
+export declare function applyPlaceholderDates(row: IParsedTask, state: Partial<IData>, calendar?: ICalendar): void;

package/dist/types/resourceLoad.d.ts

@@ -0,0 +1,24 @@
+import type { GanttScaleData, IApi, IComputedResource, IHistogramBar, IHistogramColumn, IHistogramColumnPosition, IResourceHistogramConfig, IResourceHistogramTooltip, IResourceLoad } from "./types";
+interface IResourceLoadColumn {
+    id: string;
+    width: number;
+    date: Date;
+    unit: string;
+    getter: (row: IComputedResource) => IResourceLoad | null;
+    template: (value: IResourceLoad | null) => string;
+    cell: any;
+}
+interface IResourceHistogramColumn extends IHistogramColumn {
+    unit: string;
+    cell: any;
+    getter: (row: IComputedResource) => {
+        hours: number;
+        capacity: number;
+    };
+}
+export declare function getHistogramBars(resource: IComputedResource, column: IHistogramColumn): IHistogramBar[];
+export declare function getHistogramCapacityPath(resource: IComputedResource, columns: IHistogramColumnPosition[], cellHeight: number): string;
+export declare function getResourceLoadColumns(scales: GanttScaleData | null | undefined, LoadCell: any, template?: (value: IResourceLoad) => string): IResourceLoadColumn[];
+export declare function getResourceHistogramColumns(scales: GanttScaleData | null | undefined, HistogramCell: any, config?: IResourceHistogramConfig): IResourceHistogramColumn[];
+export declare function resolveResourceHistogramBar(api: IApi, target: EventTarget | null): IResourceHistogramTooltip | null;
+export {};

package/dist/types/scales.d.ts

@@ -3,7 +3,17 @@ 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, markers?: IMarker[], projectStart?: Date, projectEnd?: Date, baselines?: boolean): {
+interface IScaleBounds {
+    markers?: IMarker[];
+    projectStart?: Date;
+    projectEnd?: Date;
+    baselines?: boolean;
+    unscheduledTasks?: boolean;
+    progressLine?: Date;
+    deadlines?: boolean;
+    constraints?: boolean;
+}
+export declare function calcScales(prevStart?: Date, prevEnd?: Date, autoScale?: boolean, minUnit?: string, tasks?: GanttDataTree, config?: IScaleBounds): {
     _start: Date;
     _end: Date;
 };
@@ -21,3 +31,5 @@ export declare function zoomScale(zoom: IZoomConfig, step: number, level: number
 };
 export declare function expandScale(minWidth: number, state: Partial<IData>): Partial<IData>;
 export declare function calcScaleDate(x: number, state: Partial<IData>): Date;
+export declare function calcScaleCellDate(x: number, state: Partial<IData>): Date;
+export {};

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

@@ -2,4 +2,7 @@ export type TaskSlackInfo = any;
 export type ICalendarRule = any;
 export type CalendarConfig = any;
 export type ICalendar = any;
+export type Constraint = any;
+export type Conflict = any;
+export type InvalidLinkReason = any;
 export declare const Calendar: any;

package/dist/types/tasks.d.ts

@@ -1,8 +1,25 @@
-import { IGanttTask, IParsedTask, GanttDataTree, ITask, IDataHash, IData } from "./types";
+import { IGanttTask, IParsedTask, GanttDataTree, ITask, IDataHash, IData, ICalendar, TID, TMethodsConfig } from "./types";
+import { EventBus } from "@svar-ui/lib-state";
 export declare const heightAdjustment = 7;
-export declare function dragSummaryKids(task: IParsedTask, dx: number, rollups: boolean): void;
-export declare function dragSummary(tasks: GanttDataTree, task: IParsedTask): void;
-export declare function setSummaryDates(task: ITask, tasks?: Partial<ITask>[]): ITask;
+export declare function isManualSummary(task: Partial<ITask>, state?: Partial<IData>): boolean;
+export declare function dragSummaryKids(task: IParsedTask, dx: number, rollups: boolean, holdManual?: boolean): void;
+export declare function dragSummary(tasks: GanttDataTree, task: IParsedTask, inactiveTasks?: boolean, autoSchedule?: boolean): void;
+export declare function setSummaryDates(task: ITask, unscheduledTasks?: boolean, inactiveTasks?: boolean, excludeInactive?: boolean): ITask;
 export declare function updateTask(t: IGanttTask, i: number | null, state: Partial<IData>): IGanttTask;
 export declare function isSegmentMoveAllowed(task: IGanttTask, moveOptions: IDataHash): boolean;
 export declare function extendDragOptions(task: ITask, options: IDataHash): void;
+type TResourceHistory = {
+    startBatch(): void;
+    endBatch(): void;
+    isBatching(): boolean;
+} | null;
+export declare function setTaskResources(taskId: TID, resourceIds: TID[], ctx: {
+    exec: EventBus<TMethodsConfig, keyof TMethodsConfig>["exec"];
+    getState: () => Partial<IData>;
+    getHistory: () => TResourceHistory | null;
+    eventSource?: string;
+    skipUndo?: boolean;
+    joinUndo?: boolean;
+}): void;
+export declare function getDefaultTaskStart(state: Partial<IData>, calendar?: ICalendar): Date;
+export {};

package/dist/types/time.d.ts

@@ -13,6 +13,7 @@ export declare function getUnitEnd(unit: string, date: Date, _weekStart?: Day):
 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: ICalendar): Date;
+export declare function adjustEndToWorkingDay(end: 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 };