@advt-gpt-chart/package 0.0.23 → 0.0.31

package/dist/Chart/ChartBase/constants.d.ts

@@ -84,7 +84,7 @@ export declare const getCartesianTootipSpec: ({ xField, yField, seriesField, }:
             value: (datum: any) => any;
         };
         content: {
-            key: () => string;
+            key: (datum: any) => string | undefined;
             value: (datum: any) => any;
         } | undefined;
     };
@@ -93,7 +93,7 @@ export declare const getCartesianTootipSpec: ({ xField, yField, seriesField, }:
             value: (datum: any) => any;
         };
         content: {
-            key: () => string;
+            key: (datum: any) => string | undefined;
             value: (datum: any) => any;
         } | undefined;
     };

package/dist/Chart/ChartBase/transformed.d.ts

@@ -1,129 +1,28 @@
-import { DataItem } from '../../types';
-export declare enum DSType {
-    sdsm = "singleDemensionSingleMetric",
-    sdmm = "singleDemensionMultiMetric",
-    mdsm = "multiDemensionSingleMetric",
-    mdmm = "multiDemensionMultiMetric"
-}
-export declare function transform2CartesianData(data: DataItem[], options: {
-    id: string;
+import { Dataset } from '../Dataset/types';
+export interface CartesianParams {
     xField: string;
     yField: string;
     metrics?: string[];
     dimensions?: string[];
-    separator?: string;
-}): {
-    data: DataItem[];
-    transformedData: DataItem[];
-    needFold: boolean;
-    needFoldFields: string[];
-    dsType: DSType;
-    metricsKey?: undefined;
-} | {
-    data: DataItem[];
-    transformedData: DataItem[];
-    metricsKey: string;
-    needFold: boolean;
-    dsType: DSType;
-    needFoldFields?: undefined;
-} | {
-    data: DataItem[];
-    transformedData: any[];
-    needFold: boolean;
-    dsType: DSType;
-    needFoldFields?: undefined;
-    metricsKey?: undefined;
-} | {
-    data: DataItem[];
-    transformedData: DataItem[];
-    needFold: boolean;
-    needFoldFields?: undefined;
-    dsType?: undefined;
-    metricsKey?: undefined;
-};
-export declare function transformCartesianFoldData(data: DataItem[], options: {
-    id: string;
-    xField: string;
+}
+export interface AxesConfig {
+    xField: string | string[];
     yField: string;
-    metricsKey?: string;
-    needFold?: boolean;
-    needFoldFields?: string[];
-}): {
-    foldData: DataItem[];
-    seriesField: string | undefined;
-    foldKey?: undefined;
-    foldValue?: undefined;
-} | {
-    foldData: any;
-    foldKey: string;
-    foldValue: string;
-    seriesField: string;
-};
-export declare function transform2PolarData(data: DataItem[], options: {
-    id: string;
+    seriesField?: string;
+}
+export interface PolarParams {
     nameField: string;
     valField: string;
-    metrics?: string[];
     dimensions?: string[];
-    separator?: string;
-}): {
-    data: DataItem[];
-    transformedData: DataItem[];
-    needFold: boolean;
-    dsType: DSType;
-    needFoldFields?: undefined;
-    metricsKey?: undefined;
-    isOneDemension?: undefined;
-} | {
-    data: DataItem[];
-    transformedData: DataItem[];
-    needFold: boolean;
-    needFoldFields: string[];
-    dsType: DSType;
-    metricsKey?: undefined;
-    isOneDemension?: undefined;
-} | {
-    data: DataItem[];
-    transformedData: {
-        [key: string]: string | number;
-    }[];
-    metricsKey: string;
-    needFold: boolean;
-    dsType: DSType;
-    isOneDemension: boolean;
-    needFoldFields?: undefined;
-} | {
-    data: DataItem[];
-    transformedData: {
-        [key: string]: string | number;
-    }[];
-    metricsKey: string;
-    needFold: boolean;
-    needFoldFields: string[];
-    dsType: DSType;
-    isOneDemension: boolean;
-} | {
-    data: DataItem[];
-    transformedData: DataItem[];
-    needFold: boolean;
-    dsType?: undefined;
-    needFoldFields?: undefined;
-    metricsKey?: undefined;
-    isOneDemension?: undefined;
+}
+export declare function transfrom2CartesianAxes(dataset: Dataset | undefined, { xField, yField, dimensions }: CartesianParams): AxesConfig;
+export declare function transfrom2PolarAxes(dataset: Dataset | undefined, { nameField, valField }: PolarParams): {
+    nameField: string;
+    valField: string;
+    seriesField: string;
 };
-export declare function transformPolarFoldData(data: DataItem[], options: {
-    id: string;
+export declare function transform2Indicator(dataset: Dataset, { nameField, valField }: PolarParams): {
     nameField: string;
     valField: string;
-    metricsKey?: string;
-    needFold?: boolean;
-    needFoldFields?: string[] | null;
-}): {
-    foldData: DataItem[];
-    foldKey?: undefined;
-    foldValue?: undefined;
-} | {
-    foldData: any;
-    foldKey: string;
-    foldValue: string;
+    seriesField: string;
 };

package/dist/Chart/ChartBase/types.d.ts

@@ -1,7 +1,7 @@
 import type { IChartSpec } from '@visactor/vchart';
 import type { ComponentType } from 'react';
 import { BaseChartProps, DataItem } from '../../types';
-import { FieldInfoItem } from '../Dataset/types';
+import { Dataset, FieldInfoItem } from '../Dataset/types';
 import { DataSource } from '../DataSource/types';
 export interface VChartBaseProps extends BaseChartProps {
     VChart: ComponentType<any>;
@@ -14,6 +14,7 @@ export interface BaseVChartConfig<T = DataItem> {
     chartName?: string;
     chartTheme?: string;
     dataSource?: DataSource;
+    dataset?: Dataset;
 }
 export interface BaseVChartProps extends BaseChartProps, BaseVChartConfig {
 }

package/dist/Chart/ChartCodeRender/type.d.ts

@@ -2,6 +2,7 @@ import type React from 'react';
 import type { FC } from 'react';
 import type { Components, ExtraProps } from 'react-markdown';
 import { ChartType, DataItem } from '../../types';
+import { TimeGrainType } from '../../utils';
 import { FieldInfoItem } from '../Dataset/types';
 import { DataSource } from '../DataSource/types';
 export type WithChartCodeOptions = {
@@ -44,6 +45,7 @@ export interface ChartJson {
     metrics?: string[];
     dataSource?: DataSource;
     columns?: FieldInfoItem[];
+    timeGrain?: TimeGrainType;
 }
 /**
  * 图表组件字典

package/dist/Chart/ChartCodeRender/visChart/ChartStoreContext.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { VizChartState } from '../../../GPTVis/hooks/useStore';
+import { VizChartState } from '../../../GPTVis/hooks/useChartStore';
 import { BaseChartProps } from '../../../types';
 import { ChartJson } from '../type';
 interface ChartStoreContextType {

package/dist/Chart/ChartControllers/TimeRange/types.d.ts

@@ -1,4 +1,5 @@
 import { Dayjs } from 'dayjs';
+import { TimeGrainType } from '../../../utils';
 import { FilterItemType } from '../Filter/types';
 export type CustomTimeRange = {
     from?: Dayjs;
@@ -40,7 +41,7 @@ export type QueryData = {
     metrics?: OptionType[];
     dimensions?: OptionType[];
     filters?: FilterItemType[];
-    timeGrain?: string;
+    timeGrain?: TimeGrainType;
 };
 export interface TableData {
     columns: Array<{

package/dist/Chart/ChartControllers/TimeRange/utils.d.ts

@@ -1,3 +1,4 @@
+import { TimeGrainType } from '../../../utils';
 import { DataSource } from '../../DataSource/types';
 import { AdvancedTimeRange, TimeRange } from './types';
 export declare const timeRangeOptions: {
@@ -20,6 +21,11 @@ export declare const timeGrainOptions: {
     label: string;
     value: string;
 }[];
+export declare const DrillTimeGrainOptions: {
+    key: string;
+    label: string;
+    value: string;
+}[];
 export declare const previousBoundaryType: {
     key: string;
     label: string;
@@ -32,11 +38,16 @@ export declare const getRestrictedTimeGrainOptions: (periodUnit?: string) => {
     label: string;
     value: string;
 }[];
+export declare const getDrillDownTimeGrainOptions: (currentGrain: string) => {
+    key: string;
+    label: string;
+    value: string;
+}[];
 export declare const getDateString: (label: string, timeRange: TimeRange | undefined, formatMessage: any) => any;
 export declare const getTimeDimension2TimeGrain: (timeDimension: {
     dimensionName: string;
-    dimensionUnit: string;
-}) => string;
+    dimensionUnit: TimeGrainType;
+}) => TimeGrainType;
 export declare const getMql2TimeRange: (timeRange: TimeRange, dataSource: DataSource) => TimeRange | {
     type: string;
     custom: {

package/dist/Chart/ChartControllers/index.d.ts

@@ -1,3 +1,4 @@
+import { TimeGrainType } from '../../utils/date';
 import { DataSource } from '../DataSource/types';
 import { FilterItemType } from './Filter/types';
 import { OptionType, TimeRange } from './TimeRange/types';
@@ -9,7 +10,7 @@ export interface ChartControllersState {
     timeRange?: TimeRange;
     metrics: OptionType[];
     dimensions: OptionType[];
-    timeGrain?: string;
+    timeGrain?: TimeGrainType;
     filters?: FilterItemType[];
 }
 export declare function ChartControllers({ theme, dataSource }: ChartHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/Chart/ChartEvents/ChartContextMenu/utils.d.ts

@@ -1,5 +1,5 @@
 import { FieldInfoItem } from '../../Dataset/types';
-export declare function getSelectedInfo(selected: any[], fieldInfo: FieldInfoItem[] | undefined, metricTime: {
+export declare function getRightClickInfo(rightClickValue: any[], fieldInfo: FieldInfoItem[] | undefined, metricTime: {
     label: string;
     value: string;
 }): any[];

package/dist/Chart/ChartEvents/DrillBy/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const drillTimeGrain2TimeRange: (parentGrain: string, timestamp: number) => {
+    type: string;
+    custom: {
+        from: string;
+        to: string;
+    };
+};

package/dist/Chart/ChartWrapper/utils.d.ts

@@ -1,11 +1,11 @@
 import VMind from '@visactor/vmind';
 import { ChartType } from '../../types';
 import { ChartJson } from '../ChartCodeRender/type';
+export declare const vmind: VMind;
 export declare function isChartTypeInTabs(chartTabs: {
     [key: string]: any;
 }[], chartType: ChartType): boolean;
 export declare function isChartAdvisor(chartJson: ChartJson): boolean;
-export declare const vmind: VMind;
 export declare function chartAdvisor(chartJson: ChartJson): Promise<{
     type: any;
     data: import("../..").DataItem[];
@@ -19,4 +19,5 @@ export declare function chartAdvisor(chartJson: ChartJson): Promise<{
     metrics?: string[];
     dataSource?: import("../DataSource/types").DataSource;
     columns?: import("../Dataset/types").FieldInfoItem[];
+    timeGrain?: import("../../utils").TimeGrainType;
 }>;

package/dist/Chart/DataSource/useChartDataQuery.d.ts

@@ -9,7 +9,7 @@ type DrillByQueryData = QueryChartData & {
     setDrillError: (error: any) => void;
 };
 export declare const useChartDataQuery: (dataSourceType: DataSourceType) => {
-    queryChartData: (queryData: QueryData, isInit?: Boolean) => Promise<void>;
+    queryChartDataFromDatasource: (queryData: QueryData, isInit?: Boolean) => Promise<void>;
     queryDrillByChartData: ({ queryData, setDrillLoading, setDrillError, }: DrillByQueryData) => Promise<void>;
 };
 export {};

package/dist/Chart/Dataset/types.d.ts

@@ -1,7 +1,23 @@
+export type DatasetType = 'dataSource' | 'static';
+export type Dataset = {
+    type?: DatasetType;
+    data?: any[];
+    transfromData?: {
+        data?: any[];
+        foldData?: any[];
+        isMetricFolded?: boolean;
+        foldKey?: string;
+        foldValue?: string;
+        isColumnMegred?: boolean;
+        megreColumnName?: string;
+    };
+    fieldInfo?: FieldInfoItem[];
+};
 export type FieldDataType = 'BIGINT' | 'TIMESTAMP' | 'STRING';
+export type VFieldDataType = 'date' | 'time' | 'string' | 'region' | 'numerical' | 'ratio' | 'count' | 'float' | 'int';
 export type FieldInfoItem = {
     fieldName?: string;
     name?: string;
-    type?: FieldDataType | string;
+    type?: FieldDataType | VFieldDataType | string;
     role?: string;
 };

package/dist/Chart/Dataset/useDataset.d.ts

@@ -0,0 +1,84 @@
+import { Dayjs } from 'dayjs';
+import { ChartType } from '../../types/chart';
+import { TimeGrainType } from '../../utils/date';
+import { ChartJson } from '../ChartCodeRender/type';
+import { DataSource } from '../DataSource/types';
+import { Dataset, DatasetType, FieldInfoItem } from './types';
+type Params = {
+    columns?: Record<string, any>[];
+    metrics?: string[];
+    dimensions?: string[];
+    dataSource?: DataSource;
+    fieldInfo?: FieldInfoItem[];
+    timeGrain?: TimeGrainType;
+};
+export declare const SEPARATOR = ",";
+export declare const FOLD_KEY_NAME = "fold-key";
+export declare const MERGE_COLUMN_KEY_NAME = "megre-column-name";
+export declare const getKeys: () => {
+    keyId: string;
+    FOLD_KEY: string;
+    MERGE_COLUMN_NAME: string;
+};
+export declare const transform2Dataset: (chartJson: ChartJson) => {
+    fieldInfo?: undefined;
+    type?: undefined;
+    transfromData?: undefined;
+    data?: undefined;
+} | {
+    fieldInfo: FieldInfoItem[];
+    type: DatasetType;
+    transfromData: {
+        data: {
+            [x: string]: any;
+        }[];
+        foldData: Record<string, any>[];
+        isMetricFolded: boolean;
+        foldKey: string;
+        foldValue: string;
+        isColumnMegred: boolean;
+        megreColumnName: string | undefined;
+    };
+    data: import("../..").DataItem[];
+};
+export declare const getFileldInfo: (data: Record<string, any>[], { columns, metrics, dimensions }: Params) => FieldInfoItem[];
+export declare const filterDataByFieldInfo: (data: Record<string, any>[], { metrics, dimensions }: {
+    metrics?: string[];
+    dimensions?: string[];
+}) => Record<string, any>[];
+export declare const transform2FoldData: (data: Record<string, any>[], dimensions?: string[], metrics?: string[]) => {
+    foldData: Record<string, any>[];
+    foldKey: string;
+    foldValue: string;
+    isMetricFolded: boolean;
+};
+export declare const transform2FillAndMegreData: (data: any[] | undefined, fieldInfo: FieldInfoItem[] | undefined, chartJson: ChartJson) => {
+    data: {
+        [x: string]: any;
+    }[];
+    isColumnMegred: boolean;
+    megreColumnName: string | undefined;
+};
+export declare const mergeDataByDimensions: (data: Record<string, any>[], fieldInfo: FieldInfoItem[], type: ChartType, dimensions?: string[]) => {
+    data: {
+        [x: string]: any;
+    }[];
+    isColumnMegred: boolean;
+    megreColumnName: string;
+} | {
+    data: {
+        [x: string]: any;
+    }[];
+    isColumnMegred?: undefined;
+    megreColumnName?: undefined;
+};
+export declare const transform2FillData: (data: Record<string, any>[], { fieldInfo, dimensions, metrics, timeGrain }: Params) => Record<string, any>[];
+export declare const generateTimeSeries: (startTime: any, endTime: any, timeGrain: any) => string[];
+export declare const filledDataByTimeSeries: (sortedData: Record<string, any>[] | undefined, timeSeries: string[], timeGrain: TimeGrainType, timeField: string, metrics?: string[]) => Record<string, any>[];
+export declare const getTimeGrainInterval: (timeGrain: string, sortedData: any[], timeField: string) => number;
+export declare function formatTime2TimeGrain(timeGrain: TimeGrainType, value: Dayjs | number): string;
+export declare const uptateDataSet: (preJson: ChartJson, newJson: ChartJson, dataset: Dataset) => {
+    dataset: Dataset;
+    isChanged: boolean;
+};
+export {};

package/dist/GPTVis/hooks/{useStore.d.ts → useChartStore.d.ts}

@@ -1,12 +1,14 @@
 import { ChartJson } from '../../Chart/ChartCodeRender/type';
 import { ChartControllersState } from '../../Chart/ChartControllers';
+import { Dataset } from '../../Chart/Dataset/types';
 import { DataSourceQueryInfo } from '../../Chart/DataSource/types';
 import { BaseChartProps } from '../../types';
 export interface ContextMenu {
     visible: boolean;
     clientX?: number;
     clientY?: number;
-    selected?: any;
+    rightClickValue?: any;
+    containsMergeKey?: boolean;
 }
 export interface DrillBy {
     visible: boolean;
@@ -25,6 +27,7 @@ export interface VizChartState {
     theme: string;
     chartLoading?: boolean;
     chartJson: ChartJson;
+    dataset: Dataset;
     controllerConfig: ChartControllersState;
     contextMenu: ContextMenu;
     drillBy: DrillBy;
@@ -33,6 +36,7 @@ export interface VizChartState {
     setTheme: (theme: string) => void;
     setLoading: (loading: boolean) => void;
     setChartJson: (chartJson: ChartJson) => void;
+    setDataset: (dataset: Dataset) => void;
     setControllerConfig: (controller: ChartControllersState) => void;
     setContextMenu: (contextMenu: ContextMenu) => void;
     setChartDrillBy: (drillBy: DrillBy) => void;