gantt-source_management 3.37.5

package/cypress/support/commands.ts

@@ -0,0 +1,175 @@
+// ***********************************************
+// This example commands.js shows you how to
+// create various custom commands and overwrite
+// existing commands.
+//
+// For more comprehensive examples of custom
+// commands please read more here:
+// https://on.cypress.io/custom-commands
+// ***********************************************
+//
+//
+// -- This is a parent command --
+// Cypress.Commands.add('login', (email, password) => { ... })
+//
+//
+// -- This is a child command --
+// Cypress.Commands.add('drag', { prevSubject: 'element'}, (subject, options) => { ... })
+//
+//
+// -- This is a dual command --
+// Cypress.Commands.add('dismiss', { prevSubject: 'optional'}, (subject, options) => { ... })
+//
+//
+// -- This will overwrite an existing command --
+// Cypress.Commands.overwrite('visit', (originalFn, url, options) => { ... })
+
+const horizontalScrollBarSelector = '.gstc__scroll-bar-inner--horizontal';
+const verticalScrollBarSelector = '.gstc__scroll-bar-inner--vertical';
+
+Cypress.Commands.add('load', (url: string) => {
+  let loaded = false;
+  function next(_cy) {
+    return loaded
+      ? _cy.wait(1)
+      : _cy.wait(100).then(() => {
+          return next(_cy);
+        });
+  }
+  function waitForElement(win) {
+    let parent = win.document.getElementById('gstc');
+    if (!parent) parent = win.document.getElementById('app');
+    if (!parent) {
+      return setTimeout(() => {
+        waitForElement(win);
+      }, 10);
+    }
+    parent.addEventListener('gstc-loaded', (ev) => {
+      loaded = true;
+    });
+    setTimeout(() => {
+      if (!loaded) {
+        loaded = true;
+      }
+    }, 2000);
+  }
+  return cy
+    .visit(url, {
+      onBeforeLoad: (win) => {
+        waitForElement(win);
+      },
+    })
+    .wait(10)
+    .then(() => {
+      return loaded ? cy : next(cy);
+    });
+});
+
+Cypress.Commands.add('scrollH', (movementX) => {
+  const coordinates = { screenX: 0, screenY: 0 };
+  return cy
+    .get(horizontalScrollBarSelector)
+    .then(($el) => {
+      const offset = $el.offset();
+      const width = $el.width();
+      const height = $el.height();
+      coordinates.screenX += Math.floor(offset.left + width / 2);
+      coordinates.screenY += Math.floor(offset.top + height / 2);
+    })
+    .get(horizontalScrollBarSelector)
+    .trigger('pointerdown', coordinates)
+    .then(() => {
+      coordinates.screenX += +movementX;
+    })
+    .trigger('pointermove', coordinates)
+    .trigger('pointerup', coordinates)
+    .wait(Cypress.env('wait'))
+    .then(() => {
+      cy.log('scrollH finished');
+    });
+});
+
+Cypress.Commands.add('scrollV', (movementY) => {
+  const coordinates = {
+    screenX: 10,
+    screenY: 10,
+  };
+  return cy
+    .get(verticalScrollBarSelector)
+    .then(($el) => {
+      const offset = $el.offset();
+      const width = $el.width();
+      const height = $el.height();
+      coordinates.screenX += Math.floor(offset.left + width / 2);
+      coordinates.screenY += Math.floor(offset.top + height / 2);
+    })
+    .get(verticalScrollBarSelector)
+    .trigger('pointerdown', coordinates)
+    .then(() => {
+      coordinates.screenY += movementY;
+    })
+    .trigger('pointermove', coordinates)
+    .trigger('pointerup', coordinates)
+    .wait(Cypress.env('wait'))
+    .then(() => {
+      cy.log('scrollH finished');
+    });
+});
+
+Cypress.Commands.add('move', (selector, movementX, movementY) => {
+  const coordinates = {
+    x: 0,
+    y: 0,
+  };
+  return cy
+    .get(selector)
+    .then(($el) => {
+      const offset = $el.offset();
+      const width = $el.width();
+      const height = $el.height();
+      coordinates.x += Math.floor(offset.left + width / 2);
+      coordinates.y += Math.floor(offset.top + height / 2);
+    })
+    .get(selector)
+    .get('body')
+    .trigger('pointerdown', coordinates)
+    .trigger('pointermove', coordinates)
+    .then(() => {
+      coordinates.x += movementX;
+      coordinates.y += movementY;
+    })
+    .trigger('pointermove', coordinates)
+    .trigger('pointerup', coordinates)
+    .wait(Cypress.env('wait'))
+    .then(() => {
+      cy.log('move finished');
+    });
+});
+
+Cypress.Commands.add('moveDirect', (selector, movementX, movementY) => {
+  const coordinates = {
+    x: 0,
+    y: 0,
+  };
+  return cy
+    .get(selector)
+    .then(($el) => {
+      const width = $el.width();
+      const height = $el.height();
+      coordinates.x += Math.floor(width / 2);
+      coordinates.y += Math.floor(height / 2);
+    })
+    .get(selector)
+    .trigger('pointerdown', coordinates)
+    .trigger('pointermove', coordinates)
+    .then(() => {
+      coordinates.x += movementX;
+      coordinates.y += movementY;
+    })
+    .trigger('pointermove', coordinates)
+    .trigger('pointerup', coordinates)
+    .wait(Cypress.env('wait'))
+    .then(() => {
+      cy.log('move finished');
+    });
+});

package/cypress/support/e2e.ts

@@ -0,0 +1,31 @@
+// ***********************************************************
+// This example support/index.js is processed and
+// loaded automatically before your test files.
+//
+// This is a great place to put global configuration and
+// behavior that modifies Cypress.
+//
+// You can change the location of this file or turn off
+// automatically serving support files with the
+// 'supportFile' configuration option.
+//
+// You can read more here:
+// https://on.cypress.io/configuration
+// ***********************************************************
+
+// Import commands.js using ES2015 syntax:
+import './commands';
+// Alternatively you can use CommonJS syntax:
+// require('./commands')
+
+declare global {
+  namespace Cypress {
+    interface Chainable<Subject> {
+      load(url: string): Chainable<any>;
+      scrollH(movementX: number): Chainable<any>;
+      scrollV(movementY: number): Chainable<any>;
+      move(selector: string, movementX: number, movementY: number): Chainable<any>;
+      moveDirect(selector: string, movementX: number, movementY: number): Chainable<any>;
+    }
+  }
+}

package/cypress.config.js

@@ -0,0 +1,24 @@
+import { defineConfig } from 'cypress';
+
+export default defineConfig({
+  viewportWidth: 1600,
+  viewportHeight: 1040,
+  video: true,
+  videoUploadOnPasses: false,
+  projectId: 'qdqmtw',
+  env: {
+    wait: 1,
+    wait_load: 1,
+  },
+  e2e: {
+    // We've imported your old cypress plugins here.
+    // You may want to clean this up later by importing these.
+    // async setupNodeEvents(on, config) {
+    //   return import('./cypress/plugins/index.js').then((fn) => {
+    //     fn.default(on, config);
+    //   });
+    // },
+    baseUrl: 'http://localhost:8080',
+    specPattern: 'cypress/e2e/**/*.{js,jsx,ts,tsx}',
+  },
+});

package/dist/api/api.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Api functions
+ *
+ * @header  --gstc--header--
+ */
+import { Time } from './time';
+import type DeepState from 'deep-state-observer';
+import type { DataChartTime, Row, Item, Vido, Items, Rows, GridCell, GridRows, GridRow, GridCells, DataItems, ItemData, ItemDataUpdate, ColumnData, RowData, RowsData, ItemDataPosition, DataChartTimeLevels, DataScrollVertical, DataScrollHorizontal, ItemRowMap, ChartTimeDates } from '../gstc';
+import { generateSlots } from './slots';
+import { getClass, getId } from './helpers';
+export interface WheelResult {
+    x: number;
+    y: number;
+    z: number;
+    event: WheelEvent;
+}
+export interface IconsCache {
+    [key: string]: string;
+}
+export interface rowsPositionsMapNode {
+    id: string;
+    dataIndex: number;
+    keys: number[];
+    [height: number]: rowsPositionsMapNode;
+}
+export type Unsubscribes = (() => void)[];
+export interface Cache {
+    rowsWithParentsExpanded: Row[];
+    rowsDataWithParentsExpanded: RowData[];
+    rowsIdsWithParentsExpanded: string[];
+    allRowsIds: string[];
+    allRowsAsArray: Row[];
+    rowsWithParentsExpandedAsMap: Map<string, Row>;
+    rowsPositionsMap: rowsPositionsMapNode;
+    rowsWithParentsExpandedDataIndexMap: Map<string, number>;
+    itemsAsArray: Item[];
+    itemsDataAsArray: ItemData[];
+}
+export declare class Api {
+    apiId: number;
+    name: string;
+    debug: string | boolean;
+    state: DeepState;
+    time: Time;
+    vido: Vido;
+    plugins: any;
+    iconsCache: IconsCache;
+    unsubscribes: Unsubscribes;
+    private mutedMethods;
+    mergeDeep: any;
+    generateSlots: typeof generateSlots;
+    getClass: typeof getClass;
+    getId: typeof getId;
+    GSTCID: (originalId: string) => string;
+    isGSTCID: (id: string) => boolean;
+    sourceID: (id: string) => string;
+    allActions: any[];
+    main: any;
+    constructor(state: DeepState);
+    render(): Promise<unknown>;
+    getListenerPosition(callback: any): string | number;
+    setVido(Vido: Vido): void;
+    clone(object: object): any;
+    setMergeDeep(mergeDeep: any): void;
+    log(...args: any[]): void;
+    getInitializedPlugins(): Set<string>;
+    pluginInitialized(pluginName: string): void;
+    pluginDestroyed(pluginName: string): void;
+    clearPluginsPositions(): void;
+    isPluginInitialized(pluginName: string): boolean;
+    getPluginPosition(pluginName?: string): number;
+    getPluginsPositions(): {};
+    isPluginInitializedBefore(pluginName: string, beforePluginName: string): boolean;
+    getActions(name: string): any;
+    isItemInViewport(item: Item, leftGlobal?: number, rightGlobal?: number): boolean;
+    private getChildrenLinkedItemsIds;
+    collectAllLinkedItems(items: Items, itemsData: DataItems): void;
+    getChildrenDependantItemsIds(item: Item, items: Items, allDependant?: string[]): string[];
+    calculateItemVerticalPosition(itemId: string, itemData?: ItemData, rowData?: RowData, item?: Item): ItemDataPosition;
+    setItemDataOutOfView(itemData: ItemData, time?: DataChartTime): ItemData;
+    calculateItemHorizontalPosition(itemId: string, itemData?: ItemData, rowData?: RowData, time?: DataChartTime, item?: Item): ItemDataPosition;
+    calculateItemPosition(itemId: string, itemData?: ItemData, rowData?: RowData, time?: DataChartTime, item?: Item): ItemDataPosition;
+    getItemPosition(itemId: string, itemData?: ItemData, rowData?: RowData, time?: DataChartTime, item?: Item): ItemDataPosition;
+    getRow(rowId: string): Row;
+    getRows(rowsId: string[]): Row[];
+    getAllRows(): Rows;
+    getVisibleRowsId(): string[];
+    getRowsData(): RowsData;
+    setRowsData(data: RowsData): void;
+    getRowData(rowId: string): RowData;
+    setRowData(rowId: string, data: RowData): void;
+    getItem(itemId: string): Item;
+    getItems(itemsId?: string[]): Item[];
+    getAllItemsAsArray(): Item[];
+    getAllItemsDataAsArray(): ItemData[];
+    getAllItems(): Items;
+    getItemData(itemId: string): ItemData;
+    getItemsData(): DataItems;
+    setItemData(itemId: string, data: ItemDataUpdate): void;
+    setItemsData(data: DataItems): void;
+    prepareDependantItems(item: Item, items: Items): string[];
+    prepareItem(item: Item, defaultItemHeight?: number, itemsData?: DataItems, items?: Items, rows?: Rows): void;
+    prepareItems(items: Items): Items;
+    sortRowsByChildren(rowsIds: string[], sortedRows?: {}, rows?: Rows, rowsData?: RowsData): Rows;
+    private getSortableValue;
+    sortRowsByColumn(column: ColumnData, asc?: boolean): Rows;
+    fillEmptyRowValues(rows: Rows): Rows;
+    itemsOnTheSameLevel(item1: Item, item2: Item): boolean;
+    itemsTimeOverlaps(item1: Item, item2: Item): boolean;
+    itemOverlapsWithOthers(item: Item, items: Item[]): Item;
+    fixOverlappedItems(rowItems: Item[]): void;
+    private makeChildren;
+    private keysToKeep;
+    private clearNested;
+    private fastTree;
+    updateItemRowMapForItem(itemId: string, newRowId: string, itemRowMap?: ItemRowMap, rowsData?: RowsData): void;
+    sortRowItemsInAddOrder(itemsId: string[], rowData: RowData): void;
+    sortRowItemsByTime(rowData: RowData): void;
+    makeTreeMap(rowsData: RowsData, items: Items, onlyItems?: boolean): RowsData;
+    private _updateRowsWithParentsExpandedCache;
+    generateRowsWithParentsExpanded(rows: Rows): any[];
+    getRowInfoFromTop(wantedAbsolutePosition: number): {
+        dataIndex: number;
+        row: Row;
+        rowData: RowData;
+    };
+    getRowViewTop(rowId: string, rowsData?: RowsData, scrollVertical?: DataScrollVertical): number;
+    parentsExpanded(rowId: string): boolean;
+    setAllRowsIdsCache(rowsIds: string[]): void;
+    recalculateRowHeight(row: Row, rowData: RowData): number;
+    calculateVisibleRowsHeights(): void;
+    getRealChartHeight(withScrollBar?: boolean): number;
+    getLastRowId(rowsWithParentsExpanded?: string[], verticalScroll?: DataScrollVertical): string;
+    getLastRowIndex(rowsWithParentsExpanded?: string[], verticalScroll?: DataScrollVertical): number;
+    private generateRowsPositionsMap;
+    getRowPositionMapNode(topPosition: number, node?: rowsPositionsMapNode): rowsPositionsMapNode;
+    measureRows(): number | any[];
+    isRowVisible(rowId: string, rows?: Rows, rowsData?: RowsData): boolean;
+    getVisibleRows(): string[];
+    normalizeMouseWheelEvent(event: WheelEvent): WheelResult;
+    resetHorizontalScroll(horizontalScroll?: DataScrollHorizontal): DataScrollHorizontal;
+    resetVerticalScroll(verticalScroll?: DataScrollVertical): DataScrollVertical;
+    limitHorizontalScrollToView(time?: DataChartTime): void;
+    private calculateHorizontalScrollPosPxFromDates;
+    setScrollLeftByPixels(offsetLeft: number): number;
+    setScrollLeft(dataIndexOrDateId: number | string | undefined, offset?: number, time?: DataChartTime): number;
+    scrollToTime(toTime: number, centered?: boolean): number;
+    getScrollLeft(): DataScrollHorizontal;
+    getScrollSize(type: 'horizontal' | 'vertical'): number;
+    getLastPageDatesWidth(chartWidth: number, allDates: ChartTimeDates): {
+        lastPageSize: number;
+        lastPageCount: number;
+    };
+    calculateInitialChartWidth(withoutScrollBar?: boolean): number;
+    getChartWidth(withoutScrollBar?: boolean): any;
+    private isHorizontalScrollVisible;
+    calculateHorizontalScrollSizeAndPosFromDates(totalViewDurationPx: number, time?: DataChartTime, scrollHorizontal?: DataScrollHorizontal, shouldUpdate?: boolean): DataScrollHorizontal;
+    getLastPageRowsHeight(height: number, rowsWithParentsExpanded: string[]): {
+        lastPageSize: number;
+        lastPageCount: number;
+    };
+    calculateVerticalScrollSize(): void;
+    setScrollTopByPixels(offsetTop: number): number;
+    setScrollTop(dataIndexOrRowId?: string | number, offset?: number): number;
+    getScrollTop(): DataScrollVertical;
+    getCurrentCalendarLevels(): DataChartTimeLevels;
+    getGridCells(cellIds?: string[]): GridCell[];
+    getAllGridCells(): GridCells;
+    getGridRows(rowIds?: string[]): GridRow[];
+    getAllGridRows(): GridRows;
+    getGridCell(cellId: string): GridCell;
+    getGridRow(rowId: string): GridRow;
+    muteMethod(methodName: string): void;
+    unmuteMethod(methodName: string): void;
+    isMutedMethod(methodName: string): boolean;
+    getSVGIconSrc(svg: any): string;
+    /**
+     * Destroy things to release memory
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=api.d.ts.map

package/dist/api/helpers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gantt-Schedule-Timeline-Calendar helpers
+ *
+ * @header  --gstc--header--
+ */
+export declare const lib = "gstc";
+export declare function getClass(name: string, appendix?: string): string;
+export declare function getId(name: string, id: string): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/api/id.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gantt-Schedule-Timeline-Calendar IDApi
+ *
+ * @header  --gstc--header--
+ */
+declare class IDApi {
+    constructor();
+    GSTCID(originalId: string): string;
+    isGSTCID(id: string): boolean;
+    sourceID(id: string): string;
+}
+declare const _default: IDApi;
+export default _default;
+//# sourceMappingURL=id.d.ts.map

package/dist/api/locale.d.ts

@@ -0,0 +1,3 @@
+export type localeName = 'af' | 'ar' | 'ar-dz' | 'ar-kw' | 'ar-ly' | 'ar-ma' | 'ar-sa' | 'ar-tn' | 'az' | 'be' | 'bg' | 'bm' | 'bn' | 'bo' | 'br' | 'bs' | 'ca' | 'cs' | 'cv' | 'cy' | 'da' | 'de' | 'de-at' | 'de-ch' | 'dv' | 'el' | 'en' | 'en-au' | 'en-ca' | 'en-gb' | 'en-ie' | 'en-il' | 'en-nz' | 'en-SG' | 'eo' | 'es' | 'es-do' | 'es-us' | 'et' | 'eu' | 'fa' | 'fi' | 'fo' | 'fr' | 'fr-ca' | 'fr-ch' | 'fy' | 'ga' | 'gd' | 'gl' | 'gom-latn' | 'gu' | 'he' | 'hi' | 'hr' | 'hu' | 'hy-am' | 'id' | 'is' | 'it' | 'it-ch' | 'ja' | 'jv' | 'ka' | 'kk' | 'km' | 'kn' | 'ko' | 'ku' | 'ky' | 'lb' | 'lo' | 'lt' | 'lv' | 'me' | 'mi' | 'mk' | 'ml' | 'mn' | 'mr' | 'ms' | 'ms-my' | 'mt' | 'my' | 'nb' | 'ne' | 'nl' | 'nl-be' | 'nn' | 'oc-lnc' | 'pa-in' | 'pl' | 'pt' | 'pt-br' | 'ro' | 'ru' | 'sd' | 'se' | 'si' | 'sk' | 'sl' | 'sq' | 'sr' | 'sr-cyrl' | 'ss' | 'sv' | 'sw' | 'ta' | 'te' | 'tet' | 'tg' | 'th' | 'tl-ph' | 'tlh' | 'tr' | 'tzl' | 'tzm' | 'tzm-latn' | 'ug-cn' | 'uk' | 'ur' | 'uz' | 'uz-latn' | 'vi' | 'x-pseudo' | 'yo' | 'zh-cn' | 'zh-hk' | 'zh-tw';
+export declare const locales: string[];
+//# sourceMappingURL=locale.d.ts.map

package/dist/api/main.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Main api
+ *
+ * @header  --gstc--header--
+ */
+import { Dayjs } from 'dayjs';
+import { DataChartTime, DataChartTimeLevel, DataChartTimeLevelDate, ChartCalendarLevel, ChartTimeDate, ChartTimeDates, ChartCalendarLevelFormat, Vido, Reason, Items, DataScrollHorizontal } from '../gstc';
+export default function main(vido: Vido, mergeDeep: any): {
+    className: string;
+    styleMap: import("@neuronet.io/vido").StyleMap;
+    initializePlugins(): void;
+    heightChange(): void;
+    resizerActiveChange(active: boolean): void;
+    generateTreeFromVisibleRows(): void;
+    generateTree(fullReload?: boolean): void;
+    prepareExpanded(): void;
+    generateVisibleRowsAndItems(): void;
+    updateItemsVerticalPositions(): void;
+    getMutedListeners(): any[];
+    triggerLoadedEvent(): void;
+    getLastPageDatesWidth(chartWidth: number, allDates: DataChartTimeLevelDate[]): number;
+    formatDate(formatting: ChartCalendarLevelFormat, date: DataChartTimeLevelDate, localeName: string): import("../gstc").htmlResult;
+    generatePeriodDates(formatting: ChartCalendarLevelFormat, time: DataChartTime, level: ChartCalendarLevel, levelIndex: number): DataChartTimeLevel;
+    limitGlobal(time: DataChartTime): DataChartTime;
+    setCenter(time: DataChartTime): void;
+    guessPeriod(time: DataChartTime, levels: ChartCalendarLevel[]): DataChartTime;
+    getFormatAndLevelIndexForZoom(zoom: number, levels?: ChartCalendarLevel[]): {
+        levelIndex: number;
+        format: ChartCalendarLevelFormat;
+    };
+    generateAllDates(time: DataChartTime, levels: ChartCalendarLevel[]): ChartTimeDates[];
+    getPeriodDatesAndCalculateViewOffsetFromAllDates(allLevelDates: ChartTimeDates, time: DataChartTime): ChartTimeDate[];
+    updateLevels(time: DataChartTime, levels: ChartCalendarLevel[]): void;
+    updateLocale(): void;
+    calculateTotalViewDurationFromDates(time: DataChartTime): void;
+    calculateRightGlobal(leftGlobalDate: Dayjs, chartWidth: number, allMainDates: DataChartTimeLevelDate[], offsetPx: any, offsetMs: any): number;
+    allItemsOnTheLeftOrRight(items?: Items, time?: DataChartTime): boolean;
+    updateVisibleItems(time?: DataChartTime, multi?: import("deep-state-observer").Multi): import("deep-state-observer").Multi;
+    calculateLeftAndRightGlobalNormally(time: DataChartTime, horizontalScroll: DataScrollHorizontal): void;
+    calculateLeftAndRightGlobalFromCenter(time: DataChartTime, oldDataTime: DataChartTime, horizontalScroll: DataScrollHorizontal): void | DataChartTime;
+    updateFromToBasedOnDates(time: DataChartTime): void;
+    recalculateTimes(reasons: Reason[]): void;
+    minimalReload(eventInfo: any): void;
+    partialReload(fullReload: boolean, eventInfo: any): void;
+    fullReload(eventInfo: any): void;
+};
+//# sourceMappingURL=main.d.ts.map

package/dist/api/public.d.ts

@@ -0,0 +1,32 @@
+import DeepState from 'deep-state-observer';
+import dayjs from 'dayjs';
+import type { Config, Locale, Period } from '../gstc';
+import { lithtml } from '@neuronet.io/vido';
+import * as vido from '@neuronet.io/vido';
+export declare const mergeDeep: typeof import("@neuronet.io/vido/types/helpers").mergeDeep;
+export declare function prepareState(userConfig: Config): {
+    config: unknown;
+};
+export declare function stateFromConfig(userConfig: Config): DeepState;
+export declare function wasmStateFromConfig(userConfig: Config, wasmFile?: string): Promise<any>;
+declare function clone(object: object): unknown;
+export declare const publicApi: {
+    name: string;
+    GSTCID: (originalId: string) => string;
+    isGSTCID: (id: string) => boolean;
+    sourceID: (id: string) => string;
+    fromArray(array: any): Record<string, any>;
+    stateFromConfig: typeof stateFromConfig;
+    wasmStateFromConfig: typeof wasmStateFromConfig;
+    merge: typeof import("@neuronet.io/vido/types/helpers").mergeDeep;
+    mergeDeep: typeof import("@neuronet.io/vido/types/helpers").mergeDeep;
+    clone: typeof clone;
+    lithtml: typeof lithtml;
+    html: typeof lithtml;
+    vido: typeof vido;
+    date(time?: any, utcMode?: boolean, localeConfig?: Locale): dayjs.Dayjs;
+    setPeriod(period: Period): number;
+    dayjs: typeof dayjs;
+};
+export {};
+//# sourceMappingURL=public.d.ts.map

package/dist/api/slots.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Gantt-Schedule-Timeline-Calendar Slots
+ *
+ * @header  --gstc--header--
+ */
+import { Vido } from '../gstc';
+import { Slots as VidoSlots, ComponentInstance, Component } from '@neuronet.io/vido';
+export type SlotInstances = {
+    [key: string]: ComponentInstance[];
+};
+export interface SlotStorage {
+    [key: string]: Component[];
+}
+export declare class Slots extends VidoSlots {
+    private name;
+    private subs;
+    constructor(name: string, vido: Vido, props: unknown);
+    destroy(): void;
+    getName(): string;
+}
+export declare function generateSlots(name: string, vido: Vido, props: unknown): Slots;
+//# sourceMappingURL=slots.d.ts.map

package/dist/api/time.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Gantt-Schedule-Timeline-Calendar Time api
+ *
+ * @header  --gstc--header--
+ */
+import dayjs from 'dayjs';
+import type { Dayjs } from 'dayjs';
+import type { DataChartTime, DataChartTimeLevelDate, ChartTimeDate, Period, ChartCalendarLevel, ChartCalendarLevelFormat } from '../gstc';
+import type DeepState from 'deep-state-observer';
+import type { Api } from './api';
+export interface CurrentDate {
+    timestamp: number;
+    second: Dayjs;
+    minute: Dayjs;
+    hour: Dayjs;
+    day: Dayjs;
+    week: Dayjs;
+    month: Dayjs;
+    year: Dayjs;
+}
+export declare class Time {
+    private locale;
+    private utcMode;
+    private state;
+    private api;
+    dayjs: any;
+    unsubs: (() => void)[];
+    constructor(state: DeepState, api: Api);
+    destroy(): void;
+    date(time?: number | string | Date | undefined): dayjs.Dayjs;
+    recalculateTime(): void;
+    recalculateFromTo(time: DataChartTime, force?: boolean): DataChartTime;
+    getCenter(time: DataChartTime): number;
+    isInCurrentView(date: Dayjs, time?: DataChartTime): boolean;
+    recalculateDatesWidths(dates: DataChartTimeLevelDate[], time?: DataChartTime): DataChartTimeLevelDate[];
+    recalculateDatesPositions(dates: DataChartTimeLevelDate[], time?: DataChartTime, relativeToTime?: boolean, cloneDates?: boolean): DataChartTimeLevelDate[];
+    setDatesCacheLevel(levelIndex: number, dates: DataChartTimeLevelDate[], time?: DataChartTime): void;
+    addDatesToCacheLevel(levelIndex: number, dates: DataChartTimeLevelDate[], time?: DataChartTime): DataChartTimeLevelDate[];
+    isLevelDateInCache(levelIndex: number, dateTime: number, time?: DataChartTime): boolean;
+    getLevelDatesFromCache(levelIndex: number, leftTime: number, rightTime: number, time?: DataChartTime): any[] | {
+        [Symbol.iterator](): {
+            next(): {
+                value: DataChartTimeLevelDate;
+                done: boolean;
+            } | {
+                done: boolean;
+                value?: undefined;
+            };
+        };
+        length: number;
+    };
+    getLevelDateFromCache(levelIndex: number, dateTime: number, time?: DataChartTime): DataChartTimeLevelDate;
+    getAllLevelDatesFromCache(levelIndex: number, time?: DataChartTime): DataChartTimeLevelDate[];
+    /**
+     * Find or create new main date in cache if not found
+     * @param dateTime number
+     * @param time DataChartTime
+     * @returns DataChartTimeLevelDate | null
+     */
+    findOrCreateMainDateAtTime(dateTime: number, time?: DataChartTime): any;
+    addMissingDates(dates: DataChartTimeLevelDate[], date: Dayjs, time?: DataChartTime, cloneDates?: boolean): DataChartTimeLevelDate[];
+    /**
+     * returns offset in pixels relative to time.from which is the first date in whole timeline
+     */
+    getGlobalOffsetPxFromDates(date: Dayjs, addMissingDates?: boolean, time?: DataChartTime, dates?: DataChartTimeLevelDate[]): number;
+    /**
+     * returns offset in pixels relative to time.leftGlobal which is left edge of what we see
+     */
+    getViewOffsetPxFromDates(date: Dayjs, limitToView?: boolean, time?: DataChartTime, dates?: DataChartTimeLevelDate[], addMissingDates?: boolean): number;
+    limitOffsetPxToView(x: number, time?: DataChartTime): number;
+    findDateAtViewOffsetPx(offsetPx: number, allPeriodDates: ChartTimeDate[]): ChartTimeDate | undefined;
+    findDateIndex(time: number, dates: DataChartTimeLevelDate[]): number;
+    findDateAtTime(milliseconds: number, allPeriodDates?: ChartTimeDate[]): ChartTimeDate | undefined;
+    getMainDateFromRelativePosition(fromDate: ChartTimeDate, relativePosPx: number): ChartTimeDate | undefined;
+    getTimeFromOffsetPx(offsetPx: number, isViewOffset?: boolean, time?: DataChartTime, dates?: DataChartTimeLevelDate[]): number;
+    getCurrentFormatForLevel(level: ChartCalendarLevel, time: DataChartTime): ChartCalendarLevelFormat;
+    alignLevelToMain(levelIndex: number, currentLevelDates: DataChartTimeLevelDate[], time?: DataChartTime): DataChartTimeLevelDate[];
+    private currentDateLastCheck;
+    private checkCurrentDateTimeoutId;
+    stopCheckingCurrentDates(): void;
+    checkCurrentDates(runSetTimeout?: boolean, time?: DataChartTime): void;
+    getDSTDiffForLevel(levelIndex: number, fromTime: number, toTime: number, time?: DataChartTime): number;
+    private setDatesDST;
+    private _generatePeriodDates;
+    generatePeriodDates({ leftDate, rightDate, period, level, levelIndex, time, callOnDate, callOnLevelDates, expandIfMissing, }: {
+        leftDate: Dayjs;
+        rightDate: Dayjs;
+        period: Period;
+        level: ChartCalendarLevel;
+        levelIndex: number;
+        time: DataChartTime;
+        callOnDate: boolean;
+        callOnLevelDates: boolean;
+        expandIfMissing?: boolean;
+    }): DataChartTimeLevelDate[];
+    getDatesDiffPx(fromTime: Dayjs, toTime: Dayjs, time: DataChartTime, accurate?: boolean, dates?: DataChartTimeLevelDate[]): number;
+    getDatesDiffMs(fromTime: Dayjs, toTime: Dayjs, time: DataChartTime, accurate?: boolean, dates?: DataChartTimeLevelDate[]): number;
+    addTimeFromDates(baseTime: number, addTime: number, time?: DataChartTime): number;
+    getLeftViewDate(time?: DataChartTime): ChartTimeDate | null;
+    getRightViewDate(time?: DataChartTime): ChartTimeDate | null;
+    getLowerPeriod(period: Period): Period;
+    getHigherPeriod(period: Period): Period;
+}
+//# sourceMappingURL=time.d.ts.map