@timelinekit/core 1.0.0

package/dist/resourcescheduler/resourcescheduler-engine.d.ts

@@ -0,0 +1,211 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { ChartTimeline } from "../ganttchart/chart/chart-time-axis";
+import { TimelineKitLocale } from "../ganttchart/locale";
+import { WorkingCalendar } from "../ganttchart/model/working-calendar";
+import { GanttChartTheme } from "../ganttchart/themes/theme";
+import { DateRange } from "../ganttchart/ganttchart-engine";
+import { Cursor, Rect } from "../common/common";
+import type { Marker } from "../ganttchart/model/marker";
+import { SchedulerData, SchedulerResourceFilterFn } from "./model/scheduler-data";
+import { SchedulerDataAdapter } from "./model/scheduler-data-adapter";
+import { TableContext } from "../table/table-context";
+import type { SchedulerCsvExportOptions, SchedulerExcelExportOptions } from "./export/scheduler-data-exporter";
+import type { SchedulerPdfExportOptions } from "./export/scheduler-pdf-exporter";
+import { SchedulerResource, SchedulerResourceEventArgs } from "./model/scheduler-resource";
+import { SchedulerEvent, SchedulerEventEventArgs } from "./model/scheduler-event";
+export interface SchedulerEventRenderArgs {
+    event: SchedulerEvent;
+    resource: SchedulerResource;
+    rect: Rect;
+    ctx: CanvasRenderingContext2D;
+    isSelected: boolean;
+    colorIndex: number;
+}
+export type SchedulerEventRenderFn = (args: SchedulerEventRenderArgs) => boolean;
+export interface SchedulerEventTooltipArgs {
+    event: SchedulerEvent;
+    resource: SchedulerResource;
+}
+export interface SchedulerEventTooltipContent {
+    title: string;
+    lines: {
+        name: string;
+        value: string;
+    }[];
+}
+export type SchedulerEventTooltipFn = (args: SchedulerEventTooltipArgs) => SchedulerEventTooltipContent | null;
+import { SchedulerSheet } from "./sheet/scheduler-sheet";
+import type { SchedulerEventsPastedEventArgs } from "./clipboard";
+export declare class ResourceSchedulerContext {
+    data: SchedulerData;
+    dataAdapter: SchedulerDataAdapter;
+    table: TableContext<SchedulerResource>;
+    timeline: ChartTimeline;
+    locale$: BehaviorSubject<TimelineKitLocale>;
+    calendar$: BehaviorSubject<WorkingCalendar>;
+    theme$: BehaviorSubject<GanttChartTheme>;
+    projectTimeline$: BehaviorSubject<DateRange>;
+    settings: ResourceSchedulerSettings;
+    get scrollTop$(): BehaviorSubject<number>;
+    autoScrolling: boolean;
+    selectedResources$: BehaviorSubject<SchedulerResource[]>;
+    canEdit$: BehaviorSubject<boolean>;
+    get canEdit(): boolean;
+    showGridLines$: BehaviorSubject<boolean>;
+    showTodayLine$: BehaviorSubject<boolean>;
+    markers$: BehaviorSubject<Marker[]>;
+    defaultSheetWidth: number;
+    dividerPositionChanged$: Subject<void>;
+    dividerResizing$: BehaviorSubject<boolean>;
+    chartMouseWheel$: Subject<any>;
+    chartRedrawn$: Subject<void>;
+    chartBackgroundRedrawn$: Subject<void>;
+    chartCursor$: Subject<Cursor>;
+    chartEventHover$: BehaviorSubject<SchedulerEvent | null>;
+    selectedEvents$: BehaviorSubject<SchedulerEvent[]>;
+    sheetRowMouseOver$: BehaviorSubject<SchedulerResourceEventArgs | null>;
+    eventMoving$: Subject<SchedulerEventMovingArgs>;
+    eventResizing$: Subject<SchedulerEventResizingArgs>;
+    eventCreating$: Subject<SchedulerEventCreatingArgs>;
+    eventDeleting$: Subject<SchedulerEventDeletingArgs>;
+    eventRendering$: BehaviorSubject<SchedulerEventRenderFn | null>;
+    eventTooltip$: BehaviorSubject<SchedulerEventTooltipFn | null>;
+    constructor();
+    get calendar(): WorkingCalendar;
+    getRowHeight(resource: SchedulerResource): number;
+    getEventY(resource: SchedulerResource, event: SchedulerEvent): number;
+    getRowY(resource: SchedulerResource): number;
+    getTotalContentHeight(): number;
+    get frozenSectionBottom(): number;
+}
+export declare class ResourceSchedulerEngine {
+    #private;
+    get data(): SchedulerData;
+    get sheet(): SchedulerSheet;
+    get calendar$(): BehaviorSubject<WorkingCalendar>;
+    set calendar$(value: WorkingCalendar);
+    get events(): ResourceSchedulerEvents;
+    get selectedResources(): SchedulerResource[];
+    get selectedEvents(): SchedulerEvent[];
+    set selectedEvents(value: SchedulerEvent[]);
+    get selectedEvent(): SchedulerEvent | null;
+    set selectedEvent(value: SchedulerEvent | null);
+    get canEdit(): boolean;
+    set canEdit(value: boolean);
+    get canUndo$(): BehaviorSubject<boolean>;
+    get canRedo$(): BehaviorSubject<boolean>;
+    undo(): void;
+    redo(): void;
+    get showGridLines(): boolean;
+    set showGridLines(value: boolean);
+    get showTodayLine(): boolean;
+    set showTodayLine(value: boolean);
+    get markers(): Marker[];
+    set markers(value: Marker[]);
+    addMarker(marker: Marker): void;
+    removeMarker(marker: Marker): void;
+    clearMarkers(): void;
+    get eventRendering(): SchedulerEventRenderFn | null;
+    set eventRendering(value: SchedulerEventRenderFn | null);
+    get eventTooltip(): SchedulerEventTooltipFn | null;
+    set eventTooltip(value: SchedulerEventTooltipFn | null);
+    get filter(): SchedulerResourceFilterFn | null;
+    set filter(value: SchedulerResourceFilterFn | null);
+    clearFilter(): void;
+    get projectTimeline(): DateRange;
+    set projectTimeline(value: DateRange);
+    get settings(): ResourceSchedulerSettings;
+    constructor(hostElement: any);
+    destroy(): void;
+    copy(): Promise<void>;
+    cut(): Promise<void>;
+    paste(): Promise<SchedulerEventsPastedEventArgs | null>;
+    zoomIn(): boolean;
+    zoomOut(): boolean;
+    scrollToDate(date: Date): void;
+    scrollToResource(resource: SchedulerResource): void;
+    goToProjectStart(): void;
+    zoomToFit(events?: SchedulerEvent[]): void;
+    exportToImage(): Promise<Blob>;
+    exportToCsv(options?: SchedulerCsvExportOptions): string;
+    exportToExcel(options?: SchedulerExcelExportOptions): Promise<Blob>;
+    exportToPdf(options?: SchedulerPdfExportOptions): Promise<Blob>;
+    freezeResource(resource: SchedulerResource): void;
+    unfreezeResource(resource: SchedulerResource): void;
+    isResourceFrozen(resource: SchedulerResource): boolean;
+    save(): string;
+    load(text: string): void;
+}
+export declare class ResourceSchedulerEvents {
+    resourceAdded$: Subject<SchedulerResourceEventArgs>;
+    resourceChanged$: Subject<SchedulerResourceEventArgs>;
+    resourceRemoved$: Subject<SchedulerResourceEventArgs>;
+    eventAdded$: Subject<SchedulerEventEventArgs>;
+    eventChanged$: Subject<SchedulerEventEventArgs>;
+    eventRemoved$: Subject<SchedulerEventEventArgs>;
+    eventSelected$: Subject<SchedulerEventEventArgs | null>;
+    eventDblClick$: Subject<SchedulerEventEventArgs>;
+    eventDeleting$: Subject<SchedulerEventDeletingArgs>;
+    eventsPasted$: Subject<SchedulerEventsPastedEventArgs>;
+    chartContextMenu$: Subject<SchedulerChartContextMenuArgs>;
+    eventMoving$: Subject<SchedulerEventMovingArgs>;
+    eventResizing$: Subject<SchedulerEventResizingArgs>;
+    eventCreating$: Subject<SchedulerEventCreatingArgs>;
+    sheetRowContextMenu$: Subject<SchedulerRowContextMenuEventArgs>;
+    sheetCellEditing$: Subject<boolean>;
+    projectTimeline$: Subject<DateRange>;
+    undone$: Subject<void>;
+    redone$: Subject<void>;
+    constructor(ctx: ResourceSchedulerContext, sheet: SchedulerSheet);
+    /** Called by engine to wire chart handler events */
+    _bindChartHandlers(chart: import("./chart/scheduler-chart").SchedulerChart): void;
+}
+export interface SchedulerRowContextMenuEventArgs {
+    selectedResources: SchedulerResource[];
+    mouseEvent: any;
+}
+export interface SchedulerChartContextMenuArgs {
+    date: Date;
+    resource: SchedulerResource;
+    event: SchedulerEvent | null;
+    mouseEvent: any;
+}
+export interface SchedulerEventMovingArgs {
+    event: SchedulerEvent;
+    newStartTime: Date;
+    newEndTime: Date;
+    newResource: SchedulerResource;
+    cancel: boolean;
+    adjustedStartTime?: Date;
+    adjustedEndTime?: Date;
+}
+export interface SchedulerEventResizingArgs {
+    event: SchedulerEvent;
+    edge: 'left' | 'right';
+    newStartTime: Date;
+    newEndTime: Date;
+    cancel: boolean;
+    adjustedStartTime?: Date;
+    adjustedEndTime?: Date;
+}
+export interface SchedulerEventDeletingArgs {
+    event: SchedulerEvent;
+    cancel: boolean;
+}
+export interface SchedulerEventCreatingArgs {
+    resource: SchedulerResource;
+    startTime: Date;
+    endTime: Date;
+    cancel: boolean;
+    adjustedStartTime?: Date;
+    adjustedEndTime?: Date;
+}
+export declare class ResourceSchedulerSettings {
+    #private;
+    get locale(): TimelineKitLocale;
+    set locale(value: TimelineKitLocale);
+    get theme(): GanttChartTheme;
+    set theme(value: GanttChartTheme);
+    changed$: Subject<void>;
+    constructor(ctx: ResourceSchedulerContext);
+}

package/dist/resourcescheduler/sheet/renderers/scheduler-icon-cell-renderer.d.ts

@@ -0,0 +1,6 @@
+import { TableCellValueFormatter } from "../../../table/table-column";
+import { TableCellRenderer } from "../../../table/renderers/table-cell-renderer";
+import { SchedulerResource } from "../../model/scheduler-resource";
+export declare class SchedulerIconCellRenderer extends TableCellRenderer<SchedulerResource> {
+    redraw(cell: any, valueFormatter: TableCellValueFormatter<SchedulerResource>, item: SchedulerResource): void;
+}

package/dist/resourcescheduler/sheet/scheduler-sheet.d.ts

@@ -0,0 +1,21 @@
+import { Subject } from "rxjs";
+import { Table } from "../../table/table";
+import { TableColumn } from "../../table/table-column";
+import { SchedulerResource } from "../model/scheduler-resource";
+import { ResourceSchedulerContext, SchedulerRowContextMenuEventArgs } from "../resourcescheduler-engine";
+import { SchedulerResourceEventArgs } from "../model/scheduler-resource";
+export declare class SchedulerSheet extends Table<SchedulerResource> {
+    #private;
+    rowContextMenu$: Subject<SchedulerRowContextMenuEventArgs>;
+    rowMouseOver$: Subject<SchedulerResourceEventArgs | null>;
+    constructor(ctx: ResourceSchedulerContext, sheetElement: any);
+    protected getItemRowHeight(resource: SchedulerResource): number;
+    protected redrawItemRow(resource: SchedulerResource): void;
+    protected onComplexOperationFinished(): void;
+    addCustomStringColumn(code: string, displayName: string): TableColumn<SchedulerResource>;
+    addCustomIntegerColumn(code: string, displayName: string): TableColumn<SchedulerResource>;
+    addCustomDecimalColumn(code: string, displayName: string): TableColumn<SchedulerResource>;
+    getDefaultColumns(): TableColumn<SchedulerResource>[];
+    getCustomColumns(): TableColumn<SchedulerResource>[];
+    clearSelection(): void;
+}

package/dist/styles/gc.css

@@ -0,0 +1 @@
+.gc-host{display:block;height:100%;overflow:hidden}.gc-wrapper{width:100%;height:100%;display:flex;gap:0px;color:var(--gc-sheet-text-color, #000000)}.gc-divider{width:0px;height:100%;position:relative}.gc-divider .resizer{top:0px;bottom:0px;position:absolute;right:-10px;z-index:30;width:20px;cursor:ew-resize}.gc-sheet{height:100%;display:inline-block}.gc-sheet .row-header{width:30px}.gc-sheet .header{position:sticky;top:0;z-index:8;height:50px;border-top:1px solid var(--gc-sheet-header-cell-border-color, #a0a0a0);border-bottom:1px solid var(--gc-sheet-header-cell-border-color, #a0a0a0);border-left:1px solid var(--gc-sheet-header-cell-border-color, #a0a0a0);display:flex;align-items:center;gap:0px;background-color:var(--gc-sheet-header-bg-color, #f8f8f8)}.gc-sheet .header .row-header{z-index:9;background-color:var(--gc-sheet-header-bg-color, #f8f8f8)}.gc-sheet .header .cell{display:flex;align-items:center;border-right:1px solid var(--gc-sheet-header-cell-divider-color, #a0a0a0);height:50px;padding-left:8px;padding-right:8px;position:relative;user-select:none}.gc-sheet .header .cell .resizer{height:100%;position:absolute;right:-10px;z-index:10;width:20px;cursor:ew-resize}.gc-sheet .header .cell.dotted{text-decoration:underline dotted !important}.gc-sheet .header .cell.hidden{display:none !important}.gc-sheet .content{overflow-x:auto;overflow-y:auto;height:100%;outline:none}.gc-sheet .content .row{height:30px;border-bottom:1px solid var(--gc-sheet-grid-line-color, #e0e0e0);display:flex;align-items:center;gap:0px;background-color:var(--gc-sheet-bg-color, #ffffff)}.gc-sheet .content .row.hidden{display:none}.gc-sheet .content .row .row-header{background-color:var(--gc-sheet-header-bg-color, #f8f8f8);border-top:1px solid var(--gc-sheet-header-cell-border-color, #a0a0a0);border-bottom:1px solid var(--gc-sheet-header-cell-border-color, #a0a0a0);border-left:1px solid var(--gc-sheet-header-cell-border-color, #a0a0a0);border-right:1px solid var(--gc-sheet-header-cell-border-color, #a0a0a0) !important;justify-content:center;cursor:default !important;user-select:none}.gc-sheet .content .row .cell{display:flex;align-items:center;border-right:1px solid var(--gc-sheet-grid-line-color, #e0e0e0);height:30px;padding-left:8px;padding-right:8px;overflow-x:hidden;white-space:nowrap;user-select:none;position:relative}.gc-sheet .content .row .cell.row-header{position:sticky;left:0;z-index:2}.gc-sheet .content .row .cell .editor{height:28px;width:100%;padding-left:0px;padding-right:0px;border:none;background-color:var(--gc-editor-bg-color, #ffffff);color:var(--gc-editor-text-color, #000000)}.gc-sheet .content .row .cell input.editor{line-height:26px}.gc-sheet .content .row .cell input.editor:focus{outline:none}.gc-sheet .content .row .cell.focused{outline:2px solid var(--gc-sheet-focus-border-color, #4a7cf6);outline-offset:-2px}.gc-sheet .content .row .cell .highlight{border:1px solid var(--gc-sheet-highlight-border-color, #647ee8);position:absolute;z-index:10;left:0px;top:0px;right:0px;bottom:0px}.gc-sheet .content .row .cell.hidden{display:none !important}.gc-sheet .content .row .tree-with-name{flex-wrap:nowrap}.gc-sheet .content .row .tree-with-name .tree{margin-left:3px;display:flex;flex:0 0 auto;justify-content:end;align-items:center}.gc-sheet .content .row .tree-with-name .name{display:flex;align-items:center;padding-left:5px;overflow-x:visible;white-space:nowrap;user-select:none}.gc-sheet .content .row .resources{gap:7px}.gc-sheet .content .row .resources .wrapper{display:flex;align-items:center;gap:3px}.gc-sheet .content .row .resources .wrapper .avatar{width:26px;height:26px;display:flex;align-items:center;justify-content:center;border-radius:50%;color:#fff;font-size:10pt}.gc-sheet .content .row .resources .wrapper .capacity{font-size:11pt}.gc-sheet .content .row .task-summary{font-weight:bold}.gc-sheet .content .row.hover{background-color:var(--gc-sheet-hover-bg-color, #f8f8f8)}.gc-sheet .content .row.hover .cell{background-color:var(--gc-sheet-hover-bg-color, #f8f8f8)}.gc-sheet .content .row:hover{background-color:var(--gc-sheet-hover-bg-color, #f8f8f8)}.gc-sheet .content .row:hover .cell{background-color:var(--gc-sheet-hover-bg-color, #f8f8f8)}.gc-sheet .content .row.selected{background-color:var(--gc-sheet-selected-bg-color, #f8f8f8)}.gc-sheet .content .row.selected .cell{background-color:var(--gc-sheet-selected-bg-color, #f8f8f8)}.gc-sheet .content .row.selected .row-header{background-color:var(--gc-sheet-selected-row-header-color, #e8e8e8)}.gc-chart{flex:1;height:100%;display:inline-block;overflow-x:scroll;overflow-y:hidden;z-index:16}.gc-chart .inner{width:1000px;height:1px}.gc-chart .canvas{height:100%;width:100%;position:absolute;z-index:15}.gc-chart.no-pointer-events{pointer-events:none}.gc-chart.cursor-pointer{cursor:pointer !important}.gc-chart.cursor-all-scroll{cursor:all-scroll !important}.gc-chart.cursor-ew-resize{cursor:ew-resize !important}.gc-chart.cursor-ns-resize{cursor:ns-resize !important}.gc-chart.cursor-nwse-resize{cursor:nwse-resize !important}.gc-chart.cursor-nesw-resize{cursor:nesw-resize !important}.gc-chart.cursor-crosshair{cursor:crosshair !important}.gc-tree-icon{display:flex;align-items:center;cursor:pointer;padding:5px 5px 5px 5px}.gc-tree-icon .tree-icon{width:6px;height:6px;display:inline-block;transform:rotate(0deg);transition:transform .3s ease;border-style:solid;border-width:2px 2px 0 0;border-color:var(--gc-tree-icon-color, #606060)}.gc-tree-icon.collapsed .tree-icon{transform:rotate(45deg);margin-bottom:3px}.gc-tree-icon.expanded .tree-icon{transform:rotate(-225deg);margin-bottom:6px}.gc-wrapper[data-color-scheme=light] .gc-sheet .content,.gc-wrapper[data-color-scheme=light] .gc-chart{scrollbar-color:#ccc #f5f5f5}.gc-wrapper[data-color-scheme=light] .gc-sheet .content::-webkit-scrollbar,.gc-wrapper[data-color-scheme=light] .gc-chart::-webkit-scrollbar{width:12px;height:12px}.gc-wrapper[data-color-scheme=light] .gc-sheet .content::-webkit-scrollbar-track,.gc-wrapper[data-color-scheme=light] .gc-chart::-webkit-scrollbar-track{background:#f5f5f5}.gc-wrapper[data-color-scheme=light] .gc-sheet .content::-webkit-scrollbar-thumb,.gc-wrapper[data-color-scheme=light] .gc-chart::-webkit-scrollbar-thumb{background:#ccc;border-radius:6px}.gc-wrapper[data-color-scheme=light] .gc-sheet .content::-webkit-scrollbar-thumb:hover,.gc-wrapper[data-color-scheme=light] .gc-chart::-webkit-scrollbar-thumb:hover{background:#d8d8d8}.gc-wrapper[data-color-scheme=dark] .gc-sheet .content,.gc-wrapper[data-color-scheme=dark] .gc-chart{scrollbar-color:#555 #1e1e1e}.gc-wrapper[data-color-scheme=dark] .gc-sheet .content::-webkit-scrollbar,.gc-wrapper[data-color-scheme=dark] .gc-chart::-webkit-scrollbar{width:12px;height:12px}.gc-wrapper[data-color-scheme=dark] .gc-sheet .content::-webkit-scrollbar-track,.gc-wrapper[data-color-scheme=dark] .gc-chart::-webkit-scrollbar-track{background:#1e1e1e}.gc-wrapper[data-color-scheme=dark] .gc-sheet .content::-webkit-scrollbar-thumb,.gc-wrapper[data-color-scheme=dark] .gc-chart::-webkit-scrollbar-thumb{background:#555;border-radius:6px}

package/dist/table/editors/cell-editor.d.ts

@@ -0,0 +1,23 @@
+import { Subject } from "rxjs";
+import { TableColumn } from "../table-column";
+import { TableContext } from "../table-context";
+import { TableItem } from "../table-data-source";
+export type CellEditEndDirection = 'none' | 'down' | 'up' | 'right' | 'left';
+export type CellEditorValueGetter<TItem> = (item: TItem) => any;
+export type CellEditorValueSetter<TItem> = (item: TItem, newValue: any) => void;
+export declare abstract class TableCellEditor<TItem extends TableItem> {
+    #private;
+    protected context: TableContext<TItem> | null;
+    invalidValue$: Subject<void>;
+    editEnded$: Subject<CellEditEndDirection>;
+    protected cell: any;
+    protected item: TItem | null;
+    get columnCode(): string | null;
+    constructor(getter: CellEditorValueGetter<TItem>, setter: CellEditorValueSetter<TItem>);
+    init(context: TableContext<TItem>): void;
+    beginEdit(column: TableColumn<TItem>, cell: any, item: TItem): void;
+    protected abstract beginEditInternal(cell: any, item: TItem, value: any): void;
+    endEdit(newParsedValue: any, direction?: CellEditEndDirection): void;
+    cancelEdit(): void;
+    abstract endEditIfModifiedElseCancel(): void;
+}

package/dist/table/editors/currency-editor.d.ts

@@ -0,0 +1,7 @@
+import { TableItem } from "../table-data-source";
+import { TableInputCellEditor } from "./input-editor";
+export declare class CurrencyCellEditor<TItem extends TableItem> extends TableInputCellEditor<TItem> {
+    protected onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/table/editors/date-editor.d.ts

@@ -0,0 +1,9 @@
+import { TableItem } from "../table-data-source";
+import { TableInputCellEditor } from "./input-editor";
+export declare class DateCellEditor<TItem extends TableItem> extends TableInputCellEditor<TItem> {
+    onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    protected getDefaultDate(): Date;
+    protected getLocale(): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/table/editors/decimal-editor.d.ts

@@ -0,0 +1,7 @@
+import { TableItem } from "../table-data-source";
+import { TableInputCellEditor } from "./input-editor";
+export declare class DecimalCellEditor<TItem extends TableItem> extends TableInputCellEditor<TItem> {
+    protected onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/table/editors/dialog-editor.d.ts

@@ -0,0 +1,17 @@
+import { Subject } from "rxjs";
+import { TableItem } from "../table-data-source";
+import { TableCellEditor } from "./cell-editor";
+export declare class DialogCellEditor<TItem extends TableItem> extends TableCellEditor<TItem> {
+    beginEdit$: Subject<DialogEditorArgs<TItem>>;
+    cancelEdit$: Subject<void>;
+    endEdit$: Subject<void>;
+    constructor();
+    protected beginEditInternal(cell: any, item: TItem, value: any): void;
+    endEditIfModifiedElseCancel(): void;
+}
+export interface DialogEditorArgs<TItem extends TableItem> {
+    item: TItem;
+    columnCode: string;
+    cancelEdit$: Subject<void>;
+    endEdit$: Subject<void>;
+}

package/dist/table/editors/input-editor.d.ts

@@ -0,0 +1,19 @@
+import { Subject } from "rxjs";
+import { TableColumn } from "../table-column";
+import { TableItem } from "../table-data-source";
+import { TableCellEditor } from "./cell-editor";
+export declare abstract class TableInputCellEditor<TItem extends TableItem> extends TableCellEditor<TItem> {
+    #private;
+    beginEdit$: Subject<InputEditorArgs<TItem>>;
+    beginEdit(column: TableColumn<TItem>, cell: any, item: TItem): void;
+    beginEditInternal(cell: any, item: TItem, value: any): void;
+    protected onInputCreated(input: any): void;
+    abstract tryParseValue(value: any): any | null;
+    abstract formatValue(value: any): string;
+    endEditIfModifiedElseCancel(): void;
+}
+export interface InputEditorArgs<TItem extends TableItem> {
+    input: any;
+    columnCode: string;
+    editor: TableInputCellEditor<TItem>;
+}

package/dist/table/editors/integer-editor.d.ts

@@ -0,0 +1,7 @@
+import { TableItem } from "../table-data-source";
+import { TableInputCellEditor } from "./input-editor";
+export declare class IntegerCellEditor<TItem extends TableItem> extends TableInputCellEditor<TItem> {
+    protected onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/table/editors/percent-editor.d.ts

@@ -0,0 +1,7 @@
+import { TableItem } from "../table-data-source";
+import { TableInputCellEditor } from "./input-editor";
+export declare class PercentCellEditor<TItem extends TableItem> extends TableInputCellEditor<TItem> {
+    protected onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/table/editors/text-editor.d.ts

@@ -0,0 +1,6 @@
+import { TableItem } from "../table-data-source";
+import { TableInputCellEditor } from "./input-editor";
+export declare class TextCellEditor<TItem extends TableItem> extends TableInputCellEditor<TItem> {
+    formatValue(value: any): string;
+    tryParseValue(value: any): any;
+}

package/dist/table/renderers/table-cell-renderer.d.ts

@@ -0,0 +1,8 @@
+import { TableCellValueFormatter } from "../table-column";
+import { TableItem } from "../table-data-source";
+export declare abstract class TableCellRenderer<TItem extends TableItem> {
+    abstract redraw(cell: any, valueFormatter: TableCellValueFormatter<TItem>, item: TItem): void;
+}
+export declare class DefaultTableCellRenderer<TItem extends TableItem> extends TableCellRenderer<TItem> {
+    redraw(cell: any, valueFormatter: TableCellValueFormatter<TItem>, item: TItem): void;
+}

package/dist/table/table-column.d.ts

@@ -0,0 +1,32 @@
+import { Subject } from "rxjs";
+import { TableCellEditor } from "./editors/cell-editor";
+import { TableCellRenderer } from "./renderers/table-cell-renderer";
+import { TableItem } from "./table-data-source";
+export declare class TableColumn<TItem extends TableItem> {
+    #private;
+    get code(): string;
+    get name(): string;
+    set name(value: string);
+    get width(): number;
+    set width(value: number);
+    get minWidth(): number;
+    set minWidth(value: number);
+    get valueFormatter(): TableCellValueFormatter<TItem>;
+    get renderer(): TableCellRenderer<TItem>;
+    get align(): TextAlign | null;
+    get editor(): TableCellEditor<TItem> | null;
+    get isEditable(): TableCellIsEditable<TItem>;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    get tooltip(): string | null;
+    set tooltip(value: string | null);
+    get headerHtml(): string | null;
+    set headerHtml(value: string | null);
+    get isCustom(): boolean;
+    set isCustom(value: boolean);
+    changed$: Subject<TableColumn<TItem>>;
+    constructor(code: string, name: string, valueFormatter: TableCellValueFormatter<TItem>, renderer: TableCellRenderer<TItem>, editor: TableCellEditor<TItem> | null, isEditable: TableCellIsEditable<TItem>, width?: number, minWidth?: number, align?: TextAlign, tooltip?: string);
+}
+export type TableCellValueFormatter<TItem> = (item: TItem) => string;
+export type TextAlign = 'Left' | 'Center' | 'Right';
+export type TableCellIsEditable<TItem> = (item: TItem) => boolean;

package/dist/table/table-context.d.ts

@@ -0,0 +1,49 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { TableCellEditor } from "./editors/cell-editor";
+import { DialogEditorArgs } from "./editors/dialog-editor";
+import { InputEditorArgs } from "./editors/input-editor";
+import { TableColumn } from "./table-column";
+import { TableDataSource, TableItem, TableItemEventArgs } from "./table-data-source";
+export interface TableFocusedCell<TItem extends TableItem> {
+    item: TItem;
+    columnIndex: number;
+}
+export interface TableCellEditing<TItem extends TableItem> {
+    cell: any;
+    editor: TableCellEditor<TItem>;
+}
+export interface TableRowEventArgs<TItem extends TableItem> {
+    item: TItem;
+    row: any;
+}
+export interface TableRowContextMenuEventArgs<TItem extends TableItem> {
+    selectedItems: TItem[];
+    mouseEvent: any;
+}
+export interface TableColumnHeaderEventArgs<TItem extends TableItem> {
+    column: TableColumn<TItem>;
+    mouseEvent: any;
+}
+export interface TableColumnEventArgs<TItem extends TableItem> {
+    column: TableColumn<TItem>;
+}
+export declare class TableContext<TItem extends TableItem> {
+    dataSource: TableDataSource<TItem>;
+    rowHeight: number;
+    canEdit$: BehaviorSubject<boolean>;
+    get canEdit(): boolean;
+    scrollTop$: BehaviorSubject<number>;
+    rowAdded$: Subject<TableRowEventArgs<TItem>>;
+    selectedItems$: BehaviorSubject<TItem[]>;
+    focusedCell$: BehaviorSubject<TableFocusedCell<TItem> | null>;
+    cellEditing$: BehaviorSubject<TableCellEditing<TItem> | null>;
+    cellInvalidValue$: Subject<void>;
+    cellDialogEdit$: Subject<DialogEditorArgs<TItem>>;
+    cellInputEdit$: Subject<InputEditorArgs<TItem>>;
+    columnHeaderContextMenu$: Subject<TableColumnHeaderEventArgs<TItem>>;
+    columnResized$: Subject<TableColumnEventArgs<TItem>>;
+    columnReordered$: Subject<TableColumnEventArgs<TItem>>;
+    rowContextMenu$: Subject<TableRowContextMenuEventArgs<TItem>>;
+    rowMouseOver$: BehaviorSubject<TableItemEventArgs<TItem> | null>;
+    constructor(dataSource: TableDataSource<TItem>, rowHeight?: number);
+}

package/dist/table/table-data-source.d.ts

@@ -0,0 +1,30 @@
+import { Subject } from "rxjs";
+export interface TableItem {
+    readonly id: string;
+}
+export interface TableItemEventArgs<TItem> {
+    item: TItem;
+}
+export interface TableDataSource<TItem extends TableItem> {
+    readonly length: number;
+    getItem(index: number): TItem;
+    getItemById(id: string): TItem | null;
+    indexOf(item: TItem): number;
+    addEmptyItem(): TItem;
+    insertEmptyItem(index: number): TItem;
+    removeItems(items: TItem[]): void;
+    getItemLabel(item: TItem): string;
+    getNextVisible(item: TItem): TItem | null;
+    getPreviousVisible(item: TItem): TItem | null;
+    itemChanged$: Subject<TableItemEventArgs<TItem>>;
+    itemRemoved$: Subject<TableItemEventArgs<TItem>>;
+    complexOperationFinished$: Subject<void>;
+}
+export interface TreeTableDataSource<TItem extends TableItem> extends TableDataSource<TItem> {
+    isItemHidden(item: TItem): boolean;
+    indent(items: TItem[]): void;
+    outdent(items: TItem[]): void;
+    moveUp(items: TItem[]): void;
+    moveDown(items: TItem[]): void;
+    itemCollapsedChanged$: Subject<TableItemEventArgs<TItem>>;
+}

package/dist/table/table-keyboard-navigation.d.ts

@@ -0,0 +1,25 @@
+import { TableColumn } from "./table-column";
+import { TableContext, TableFocusedCell } from "./table-context";
+import { TableItem } from "./table-data-source";
+export interface TableNavigationHost<TItem extends TableItem> {
+    getColumns(): TableColumn<TItem>[];
+    getItemRow(item: TItem): any;
+    beginEdit(initialChar?: string): void;
+    deleteSelectedItems(): void;
+    insertItemAfterFocused(): void;
+}
+export declare class TableKeyboardNavigation<TItem extends TableItem> {
+    #private;
+    protected context: TableContext<TItem>;
+    protected content: any;
+    protected host: TableNavigationHost<TItem>;
+    constructor(context: TableContext<TItem>, content: any, host: TableNavigationHost<TItem>);
+    get focusedCell(): TableFocusedCell<TItem> | null;
+    onCellMousedown(cell: any, column: TableColumn<TItem>, item: TItem): void;
+    onCellDblClick(): void;
+    onEditEnded(direction: string): void;
+    onKeyDown(event: any): void;
+    protected handleCustomKeyDown(event: any, focused: TableFocusedCell<TItem>): boolean;
+    setFocus(item: TItem, columnIndex: number): void;
+    clearFocus(): void;
+}

package/dist/table/table-rows-selection.d.ts

@@ -0,0 +1,13 @@
+import { Subject } from "rxjs";
+import { TableContext, TableRowContextMenuEventArgs } from "./table-context";
+import { TableItem } from "./table-data-source";
+export declare class TableRowsSelection<TItem extends TableItem> {
+    #private;
+    get items(): TItem[];
+    changed$: Subject<void>;
+    rowContextMenu$: Subject<TableRowContextMenuEventArgs<TItem>>;
+    constructor(context: TableContext<TItem>, content: any);
+    cancelRangeSelection(): void;
+    clear(): void;
+    updateWithCurrentSelection(): void;
+}

package/dist/table/table.d.ts

@@ -0,0 +1,51 @@
+import { TableColumn } from "./table-column";
+import { TableContext } from "./table-context";
+import { TableItem } from "./table-data-source";
+import { TableKeyboardNavigation, TableNavigationHost } from "./table-keyboard-navigation";
+import { TableRowsSelection } from "./table-rows-selection";
+import { ClassWithListeners } from "../common/class-with-listeners";
+export declare class Table<TItem extends TableItem> extends ClassWithListeners implements TableNavigationHost<TItem> {
+    #private;
+    protected get tableContext(): TableContext<TItem>;
+    protected get contentElement(): any;
+    protected get headerElement(): any;
+    protected get navigation(): TableKeyboardNavigation<TItem>;
+    protected get selection(): TableRowsSelection<TItem>;
+    protected get rowsContainer(): any;
+    constructor(context: TableContext<TItem>, tableElement: any);
+    protected createKeyboardNavigation(): TableKeyboardNavigation<TItem>;
+    getColumns(): TableColumn<TItem>[];
+    getItemRow(item: TItem): any;
+    beginEdit(initialChar?: string): void;
+    deleteSelectedItems(): void;
+    insertItemAfterFocused(): void;
+    addColumn(column: TableColumn<TItem>): void;
+    get columnsLength(): number;
+    getColumn(index: number): TableColumn<TItem>;
+    getColumnByCode(code: string): TableColumn<TItem> | null;
+    protected updateColumnVisibility(column: TableColumn<TItem>): void;
+    protected getItemRowHeight(item: TItem): number;
+    protected onItemChanged(item: TItem): void;
+    protected onItemRemoved(item: TItem): void;
+    protected onComplexOperationFinished(): void;
+    protected redrawItemRow(item: TItem): void;
+    protected redrawAll(): void;
+    protected updateColumnHeaders(): void;
+    scrollContentVertically(deltaY: number): void;
+    setScrollTop(value: number): void;
+    setHoverItem(item: TItem | null): void;
+    hideColumn(code: string): void;
+    removeColumn(code: string): void;
+    getColumnsContentWidth(): number;
+    getDefaultColumns(): TableColumn<TItem>[];
+    getCustomColumns(): TableColumn<TItem>[];
+    saveColumns(): ColumnState[];
+    loadColumns(states: ColumnState[]): void;
+    scrollToItem(item: TItem): void;
+    clearSelection(): void;
+}
+export interface ColumnState {
+    code: string;
+    width: number;
+    isVisible: boolean;
+}

package/dist/table/tree-table-keyboard-navigation.d.ts

@@ -0,0 +1,16 @@
+import { TableContext, TableFocusedCell } from "./table-context";
+import { TableItem } from "./table-data-source";
+import { TableKeyboardNavigation, TableNavigationHost } from "./table-keyboard-navigation";
+export interface TreeTableNavigationHost<TItem extends TableItem> extends TableNavigationHost<TItem> {
+    indentSelectedItems(): void;
+    outdentSelectedItems(): void;
+    moveUpSelectedItems(): void;
+    moveDownSelectedItems(): void;
+    toggleCollapsed(item: TItem): void;
+    canToggleCollapsed(item: TItem): boolean;
+}
+export declare class TreeTableKeyboardNavigation<TItem extends TableItem> extends TableKeyboardNavigation<TItem> {
+    #private;
+    constructor(context: TableContext<TItem>, content: any, host: TreeTableNavigationHost<TItem>);
+    protected handleCustomKeyDown(event: any, focused: TableFocusedCell<TItem>): boolean;
+}

package/dist/table/tree-table.d.ts

@@ -0,0 +1,17 @@
+import { TableContext } from "./table-context";
+import { TableItem, TreeTableDataSource } from "./table-data-source";
+import { TableKeyboardNavigation } from "./table-keyboard-navigation";
+import { Table } from "./table";
+import { TreeTableNavigationHost } from "./tree-table-keyboard-navigation";
+export declare class TreeTable<TItem extends TableItem> extends Table<TItem> implements TreeTableNavigationHost<TItem> {
+    get treeDataSource(): TreeTableDataSource<TItem>;
+    constructor(context: TableContext<TItem>, tableElement: any);
+    protected createKeyboardNavigation(): TableKeyboardNavigation<TItem>;
+    protected redrawItemRow(item: TItem): void;
+    indentSelectedItems(): void;
+    outdentSelectedItems(): void;
+    moveUpSelectedItems(): void;
+    moveDownSelectedItems(): void;
+    toggleCollapsed(item: TItem): void;
+    canToggleCollapsed(item: TItem): boolean;
+}