@advt-gpt-chart/package 0.0.11 → 0.0.23

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

@@ -0,0 +1,101 @@
+import { ICartesianAxisSpec, InterpolateType } from '@visactor/vchart';
+import { AxesType } from './utils';
+type CartesianOptions = {
+    xField: string;
+    yField: string;
+};
+type CartesianTooltipOptions = CartesianOptions & {
+    seriesField?: string;
+};
+type PolarTooltipOptions = {
+    categoryField: string;
+    valueField: string;
+    seriesField?: string;
+    showPercent?: boolean;
+    categoryFieldType?: AxesType;
+};
+export declare const getPolarLegendSpec: (seriesField: string | boolean | undefined, categoryField: string) => {
+    visible: boolean;
+    item: {
+        label: {
+            formatMethod: (val: any) => any;
+        };
+    };
+};
+export declare const getCartesianLegend: (xField?: string, seriesField?: string | boolean) => any;
+export declare const getPolarTooltipSpec: ({ categoryField, valueField, seriesField, showPercent, }: PolarTooltipOptions) => {
+    mark: {
+        title: {
+            value: (datum: any) => any;
+        };
+        content: {
+            key: () => string;
+            value: (datum: any) => any;
+        } | undefined;
+    };
+    dimension: {
+        title: {
+            value: (datum: any) => any;
+        };
+        content: {
+            key: () => string;
+            value: (datum: any) => any;
+        } | undefined;
+    };
+};
+export declare const getDefaultTooltip: (seriesField: string | boolean | undefined) => {
+    mark: {
+        title: {
+            visible: boolean;
+        };
+    };
+    dimension: {
+        title: {
+            visible: boolean;
+        };
+    };
+};
+export declare const getLineStyle: () => {
+    line: {
+        style: {
+            lineWidth: number;
+            curveType: InterpolateType;
+        };
+    };
+    point: {
+        style: {
+            fillOpacity: number;
+            strokeOpacity: number;
+            size: number;
+        };
+        state: {
+            dimension_hover: {
+                size: number;
+                fillOpacity: number;
+                strokeOpacity: number;
+            };
+        };
+    };
+};
+export declare const getCartesianAxesSpec: (options: CartesianOptions) => ICartesianAxisSpec[];
+export declare const getCartesianTootipSpec: ({ xField, yField, seriesField, }: CartesianTooltipOptions) => {
+    mark: {
+        title: {
+            value: (datum: any) => any;
+        };
+        content: {
+            key: () => string;
+            value: (datum: any) => any;
+        } | undefined;
+    };
+    dimension: {
+        title: {
+            value: (datum: any) => any;
+        };
+        content: {
+            key: () => string;
+            value: (datum: any) => any;
+        } | undefined;
+    };
+};
+export {};

package/dist/{VChartBase → Chart/ChartBase}/transformed.d.ts

@@ -1,4 +1,4 @@
-import { DataItem } from '../types';
+import { DataItem } from '../../types';
 export declare enum DSType {
     sdsm = "singleDemensionSingleMetric",
     sdmm = "singleDemensionMultiMetric",

package/dist/{VChartBase → Chart/ChartBase}/types.d.ts

@@ -1,15 +1,19 @@
 import type { IChartSpec } from '@visactor/vchart';
 import type { ComponentType } from 'react';
-import { BaseChartProps, DataItem } from '../types';
+import { BaseChartProps, DataItem } from '../../types';
+import { FieldInfoItem } from '../Dataset/types';
+import { DataSource } from '../DataSource/types';
 export interface VChartBaseProps extends BaseChartProps {
     VChart: ComponentType<any>;
     spec?: Partial<IChartSpec>;
 }
 export interface BaseVChartConfig<T = DataItem> {
     data: T[];
+    columns?: FieldInfoItem[];
     spec?: Partial<IChartSpec>;
     chartName?: string;
     chartTheme?: string;
+    dataSource?: DataSource;
 }
 export interface BaseVChartProps extends BaseChartProps, BaseVChartConfig {
 }

package/dist/{ChartCodeRender → Chart/ChartCodeRender}/index.d.ts

@@ -6,3 +6,4 @@ export declare const withChartCode: (options: WithChartCodeOptions) => CodeBlock
  * @returns
  */
 export declare const withDefaultChartCode: (options?: Partial<WithChartCodeOptions>) => CodeBlockComponent;
+export declare const withDefaultChartJsonCode: (options?: Partial<WithChartCodeOptions>) => any;

package/dist/{ChartCodeRender → Chart/ChartCodeRender}/type.d.ts

@@ -1,6 +1,9 @@
 import type React from 'react';
 import type { FC } from 'react';
 import type { Components, ExtraProps } from 'react-markdown';
+import { ChartType, DataItem } from '../../types';
+import { FieldInfoItem } from '../Dataset/types';
+import { DataSource } from '../DataSource/types';
 export type WithChartCodeOptions = {
     /**
      * 要额外加载的图表组件
@@ -26,13 +29,21 @@ export type WithChartCodeOptions = {
      * 图表样式，配置容器样式
      */
     style?: React.CSSProperties;
+    renderMode?: 'json' | 'md';
 };
-/**
- * 图表渲染数据接口，后续拓展，这里只是写个示例
- */
 export interface ChartJson {
-    type: string;
-    data: any;
+    type: ChartType;
+    data: DataItem[];
+    chartId?: string;
+    chartName?: string;
+    xField?: string;
+    yField?: string;
+    nameField?: string;
+    valField?: string;
+    dimensions?: string[];
+    metrics?: string[];
+    dataSource?: DataSource;
+    columns?: FieldInfoItem[];
 }
 /**
  * 图表组件字典

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import { VizChartState } from '../../../GPTVis/hooks/useStore';
+import { BaseChartProps } from '../../../types';
+import { ChartJson } from '../type';
+interface ChartStoreContextType {
+    store: VizChartState;
+    chartId: string;
+}
+export declare const ChartStoreContext: React.Context<ChartStoreContextType | null>;
+export declare const useChartContext: () => ChartStoreContextType;
+export declare const getChartId: () => string;
+export declare const getChartStore: () => VizChartState;
+interface ChartStoreProviderProps {
+    chartProps: BaseChartProps & ChartJson;
+    children: React.ReactNode;
+}
+export declare const ChartStoreProvider: React.FC<ChartStoreProviderProps>;
+export {};

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

@@ -0,0 +1,3 @@
+import React from 'react';
+import { RenderVisChartProps } from './types';
+export declare const RenderVisChart: React.FC<RenderVisChartProps>;

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

@@ -0,0 +1,2 @@
+export declare const StyledGPTVis: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const GlobalStyles: import("react").NamedExoticComponent<import("styled-components").ExecutionProps & object>;

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { ChartComponents } from '../type';
+export type RenderVisChartProps = {
+    content: string;
+    components: ChartComponents;
+    debug?: boolean;
+    loadingTimeout?: number;
+    style?: React.CSSProperties;
+};
+export type RenderErrorProps = {
+    debug?: boolean;
+    loadingTimeout?: number;
+    loading?: boolean;
+    style?: React.CSSProperties;
+    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+};

package/dist/Chart/ChartControllers/Filter/FilterController.d.ts

@@ -0,0 +1,9 @@
+import { FilterItemType } from './types';
+interface FilterItemProps {
+    filter: FilterItemType;
+    filterKey?: string;
+    onFilterChange: (filter: FilterItemType) => void;
+    deleteFilter?: () => void;
+}
+export declare const FilterController: ({ filter, filterKey, onFilterChange, deleteFilter, }: FilterItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Chart/ChartControllers/Filter/FilterModal.d.ts

@@ -0,0 +1,8 @@
+import { FilterItemType } from './types';
+interface Props {
+    filter: FilterItemType;
+    onCancel: () => void;
+    onApply: (filter: any) => void;
+}
+export declare const FilterModal: ({ filter, onCancel, onApply }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Chart/ChartControllers/Filter/FiltersController.d.ts

@@ -0,0 +1,7 @@
+import { FilterItemType } from './types';
+interface Props {
+    filters?: FilterItemType[];
+    onChange: (filters: FilterItemType[]) => void;
+}
+export declare const FiltersController: ({ filters, onChange }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Chart/ChartControllers/Filter/styles.d.ts

@@ -0,0 +1,6 @@
+export declare const StyleFiltersConainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme?: string;
+}>> & string;
+export declare const StyleFilterModal: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme?: string;
+}>> & string;

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

@@ -0,0 +1,16 @@
+export type FilterItem = {
+    conjunction: string;
+    subFilter: FilterItemType;
+};
+export type FilterItemType = {
+    type: string;
+    basic?: {
+        dimensionId: string;
+        condition: string;
+        value: any;
+    };
+    sql?: {
+        conditionType: string;
+        filterCondition: string;
+    };
+};

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

@@ -0,0 +1,33 @@
+import { FilterItem } from './types';
+export declare const menuOptions: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const conditionOptions: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const conditionTypeOptions: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare function findBasicFilterDataset(dimension: any, dimensions?: any[]): {
+    datasetName: any;
+    dimensionColumn: any;
+    dimensionId: any;
+} | null;
+export declare const getFilters: (filters?: FilterItem[]) => {
+    type: string;
+    basic?: {
+        dimensionId: string;
+        condition: string;
+        value: any;
+    };
+    sql?: {
+        conditionType: string;
+        filterCondition: string;
+    };
+}[];

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

@@ -0,0 +1,7 @@
+import { AdvancedTimeRange } from './types';
+interface Props {
+    advancedTimeRange: AdvancedTimeRange;
+    onChange: (value: AdvancedTimeRange) => void;
+}
+export declare const AdvancedContent: ({ advancedTimeRange, onChange }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import { CustomTimeRange } from './types';
+interface Props {
+    customTimeRange: CustomTimeRange;
+    onChange: (timeRange: CustomTimeRange) => void;
+}
+export declare const CustomContent: ({ customTimeRange, onChange }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { TimeRange } from './types';
+interface Props {
+    type: string;
+    setClose: (isBack?: boolean) => void;
+    setApply: (val: any) => void;
+    timeRange?: TimeRange;
+}
+export declare const TimeRangePopover: ({ type, setClose, setApply, timeRange }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import { TimeRange } from './types';
+interface Props {
+    timeRange?: TimeRange;
+    onChange: (val: TimeRange) => void;
+}
+export declare const TimeRangeSelect: ({ timeRange, onChange }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+export declare const StyleTimeRange: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme?: string;
+}>> & string;
+export declare const StylePopoverContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme?: string;
+}>> & string;
+export declare const StyleCustom: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme?: string;
+}>> & string;
+export declare const StyleAdvanced: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme?: string;
+}>> & string;

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

@@ -0,0 +1,55 @@
+import { Dayjs } from 'dayjs';
+import { FilterItemType } from '../Filter/types';
+export type CustomTimeRange = {
+    from?: Dayjs;
+    to?: Dayjs;
+};
+export type AdvancedTimeRange = {
+    type: string;
+    lastPeriod?: {
+        range: number;
+        unit: string;
+    };
+    periodAgo?: {
+        range: number;
+        unit: string;
+    };
+    periodBoundary?: {
+        boundaryType: string;
+        periodRange?: number;
+        boundaryUnit: string;
+        periodType: string;
+        periodUnit: string;
+    };
+};
+export type TimeRange = {
+    type: string;
+    basic?: string;
+    custom?: {
+        from: string;
+        to: string;
+    };
+    advanced?: AdvancedTimeRange;
+};
+export type OptionType = {
+    label: string;
+    value: string;
+};
+export type QueryData = {
+    timeRange?: TimeRange;
+    metrics?: OptionType[];
+    dimensions?: OptionType[];
+    filters?: FilterItemType[];
+    timeGrain?: string;
+};
+export interface TableData {
+    columns: Array<{
+        name: string;
+        type: string;
+    }>;
+    rows: Array<{
+        row: Array<{
+            v: any;
+        }>;
+    }>;
+}

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

@@ -0,0 +1,77 @@
+import { DataSource } from '../../DataSource/types';
+import { AdvancedTimeRange, TimeRange } from './types';
+export declare const timeRangeOptions: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const advancedMenuOptions: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const previousConfiguration: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const timeGrainOptions: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const previousBoundaryType: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const defaultTimeRange: TimeRange;
+export declare const defaultAdvancedTimeRange: AdvancedTimeRange;
+export declare const getRestrictedTimeGrainOptions: (periodUnit?: 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;
+export declare const getMql2TimeRange: (timeRange: TimeRange, dataSource: DataSource) => TimeRange | {
+    type: string;
+    custom: {
+        from: any;
+        to: any;
+    };
+};
+export declare const emptyTimeRange: {
+    type: string;
+    basic: string;
+    advanced: {
+        type: string;
+        lastPeriod: {
+            range: null;
+            unit: string;
+        };
+        periodAgo: {
+            range: null;
+            unit: string;
+        };
+        periodBoundary: {
+            periodType: string;
+            periodRange: null;
+            periodUnit: string;
+            boundaryType: string;
+            boundaryRange: null;
+            boundaryUnit: string;
+        };
+        custom: {
+            from: string;
+            to: string;
+        };
+    };
+    custom: {
+        from: string;
+        to: string;
+    };
+};

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

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

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

@@ -0,0 +1,3 @@
+export declare const StyleChartControllers: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme: string;
+}>> & string;

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

@@ -0,0 +1,12 @@
+import { ChartJson } from '../ChartCodeRender/type';
+export declare function handleMetricInfo(metricInfo: any, chartJson: ChartJson, metricTime: {
+    label: string;
+    value: string;
+}): {
+    metrics: {
+        value: any;
+        label: any;
+    }[];
+    matchedDimensions: any;
+    dimOptions: any;
+} | null;

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

@@ -0,0 +1,10 @@
+import React from 'react';
+interface ContextMenuProps {
+    visible?: boolean;
+    clientX?: number;
+    clientY?: number;
+    onClose?: () => void;
+    onAction?: (action: string) => void;
+}
+declare const ChartContextMenu: React.FC<ContextMenuProps>;
+export default ChartContextMenu;

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

@@ -0,0 +1 @@
+export declare const ContextMenuWrapperStyle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

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

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

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import { DataSource } from '../../DataSource/types';
+interface DrillByChartProps {
+    dataSource: DataSource;
+}
+declare const DrillByChart: React.FC<DrillByChartProps>;
+export default DrillByChart;

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

@@ -0,0 +1 @@
+export declare const DrillByChartWrapperStyle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

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

@@ -0,0 +1,5 @@
+export interface ChartHeaderProps {
+    theme?: string;
+}
+declare function ChartHeader({ theme }: ChartHeaderProps): import("react/jsx-runtime").JSX.Element;
+export { ChartHeader };

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ChartComponents } from '../ChartCodeRender/type';
+export interface ChartContainerProps {
+    components?: ChartComponents;
+    className?: string;
+    chartStyle?: React.CSSProperties;
+}
+declare const _default: React.MemoExoticComponent<({ className, chartStyle, components, }: ChartContainerProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare const StyleChartContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme: string;
+    style?: React.CSSProperties;
+}>> & string;
+export declare const StyleChartHeader: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    theme?: string;
+}>> & string;
+export declare const GlobalDropdownStyle: React.NamedExoticComponent<import("styled-components").ExecutionProps & object>;

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

@@ -0,0 +1,22 @@
+import VMind from '@visactor/vmind';
+import { ChartType } from '../../types';
+import { ChartJson } from '../ChartCodeRender/type';
+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[];
+    chartId?: string;
+    chartName?: string;
+    xField?: string;
+    yField?: string;
+    nameField?: string;
+    valField?: string;
+    dimensions?: string[];
+    metrics?: string[];
+    dataSource?: import("../DataSource/types").DataSource;
+    columns?: import("../Dataset/types").FieldInfoItem[];
+}>;

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

@@ -0,0 +1,9 @@
+import { DataSourceType } from './types';
+export interface DataSourceMethods {
+    query2Params: (params: any) => Promise<any>;
+    queryChartData: (params: any) => Promise<any>;
+    queryMetric: (params: any) => Promise<any>;
+    queryDimensions: (params: any) => Promise<any>;
+    transformData: (params: any) => any;
+}
+export declare const useQueryDataSource: (dataSourceType: DataSourceType) => DataSourceMethods;

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

@@ -0,0 +1,10 @@
+import { QueryData, TableData } from '../ChartControllers/TimeRange/types';
+export declare const queryMetric: (id: string) => Promise<any>;
+export declare const queryDimensions: (orgId?: string) => Promise<any>;
+export declare const query2Params: (mql: any) => Promise<any>;
+export declare const queryChartData: ({ timeRange, metrics, dimensions, timeGrain, filters, }: QueryData) => Promise<any>;
+export declare const transformData: (params: {
+    data: TableData;
+}) => {
+    [key: string]: any;
+}[];