@orbcharts/core 3.0.7 → 4.0.0-pre-alpha.0

package/dist/src/chart/createTreeData.d.ts

@@ -0,0 +1,3 @@
+import { RawData, Encoding, ModelDataTree, Theme } from '../types';
+
+export declare const createTreeData: (rawData: RawData, encoding: Encoding, theme: Theme) => ModelDataTree[];

package/dist/src/chart/defaults.d.ts

@@ -0,0 +1,5 @@
+import { Encoding, Theme, SizeConfig } from '../types';
+
+export declare const DEFAULT_SIZE_CONFIG: SizeConfig;
+export declare const DEFAULT_DATA_ENCODING: Encoding;
+export declare const DEFAULT_THEME: Theme;

package/dist/src/defineCanvasLayer.d.ts

@@ -0,0 +1,16 @@
+import { DefineLayerConfig, ExtendableContext, LayerEnableProps } from './types';
+
+export declare const defineCanvasLayer: <ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>, LayerParams extends Record<string, any>>(config: DefineLayerConfig<"canvas", ExtendContext, PluginParams, LayerParams>) => {
+    new (): {
+        _name: string;
+        _defaultParams: LayerParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: LayerEnableProps<"canvas", ExtendContext, PluginParams, LayerParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<LayerParams>) => void;
+        _forceReplaceParams: (params: LayerParams) => void;
+        _getParams: () => Readonly<LayerParams>;
+        _destroy: () => void;
+    };
+};

package/dist/src/defineCanvasPlugin.d.ts

@@ -0,0 +1,22 @@
+import { DeepPartial, DefinePluginConfig, ChartContext, ExtendableContext } from './types';
+
+export declare const defineCanvasPlugin: <ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>, AllLayerParams extends Record<string, any>>(config: DefinePluginConfig<ExtendContext, PluginParams, AllLayerParams>) => {
+    new (params?: DeepPartial<PluginParams | AllLayerParams>): {
+        _name: string;
+        _elementType: "canvas";
+        _getId: () => string;
+        _setId: (id: string) => void;
+        _injectContext: (context: ChartContext<{}>) => void;
+        show: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        showOnly: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        showAll: () => void;
+        hide: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        hideAll: () => void;
+        toggle: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        getShownLayerNames: () => (keyof AllLayerParams)[];
+        updateParams: (patch: DeepPartial<PluginParams | AllLayerParams>) => void;
+        forceReplaceParams: (full: PluginParams | AllLayerParams) => void;
+        getParams: () => Readonly<PluginParams | AllLayerParams>;
+        destroy: () => void;
+    };
+};

package/dist/src/defineSVGLayer.d.ts

@@ -0,0 +1,16 @@
+import { DefineLayerConfig, ExtendableContext, LayerEnableProps } from './types';
+
+export declare const defineSVGLayer: <ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>, LayerParams extends Record<string, any>>(config: DefineLayerConfig<"svg", ExtendContext, PluginParams, LayerParams>) => {
+    new (): {
+        _name: string;
+        _defaultParams: LayerParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: LayerEnableProps<"svg", ExtendContext, PluginParams, LayerParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<LayerParams>) => void;
+        _forceReplaceParams: (params: LayerParams) => void;
+        _getParams: () => Readonly<LayerParams>;
+        _destroy: () => void;
+    };
+};

package/dist/src/defineSVGPlugin.d.ts

@@ -0,0 +1,22 @@
+import { DeepPartial, DefinePluginConfig, ChartContext, ExtendableContext } from './types';
+
+export declare const defineSVGPlugin: <ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>, AllLayerParams extends Record<string, any>>(config: DefinePluginConfig<ExtendContext, PluginParams, AllLayerParams>) => {
+    new (params?: DeepPartial<PluginParams | AllLayerParams>): {
+        _name: string;
+        _elementType: "svg";
+        _getId: () => string;
+        _setId: (id: string) => void;
+        _injectContext: (context: ChartContext<{}>) => void;
+        show: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        showOnly: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        showAll: () => void;
+        hide: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        hideAll: () => void;
+        toggle: (names: (keyof AllLayerParams) | (keyof AllLayerParams)[]) => void;
+        getShownLayerNames: () => (keyof AllLayerParams)[];
+        updateParams: (patch: DeepPartial<PluginParams | AllLayerParams>) => void;
+        forceReplaceParams: (full: PluginParams | AllLayerParams) => void;
+        getParams: () => Readonly<PluginParams | AllLayerParams>;
+        destroy: () => void;
+    };
+};

package/dist/src/index.d.ts

@@ -1,15 +1,7 @@
-export { SeriesChart } from './SeriesChart';
-export { GridChart } from './GridChart';
-export { MultiGridChart } from './MultiGridChart';
-export { MultiValueChart } from './MultiValueChart';
-export { RelationshipChart } from './RelationshipChart';
-export { TreeChart } from './TreeChart';
-export { defineSeriesPlugin } from './defineSeriesPlugin';
-export { defineGridPlugin } from './defineGridPlugin';
-export { defineMultiGridPlugin } from './defineMultiGridPlugin';
-export { defineMultiValuePlugin } from './defineMultiValuePlugin';
-export { defineNoneDataPlugin } from './defineNoneDataPlugin';
-export { defineRelationshipPlugin } from './defineRelationshipPlugin';
-export { defineTreePlugin } from './defineTreePlugin';
+export { OrbCharts } from './OrbCharts';
+export { defineSVGPlugin } from './defineSVGPlugin';
+export { defineSVGLayer } from './defineSVGLayer';
+export { defineCanvasPlugin } from './defineCanvasPlugin';
+export { defineCanvasLayer } from './defineCanvasLayer';
+export * from './types';
 export * from './utils';
-export * from './defaults';

package/dist/src/layer/createLayer.d.ts

@@ -0,0 +1,3 @@
+import { DefineLayerConfig, LayerEntity, ExtendableContext } from '../types';
+
+export declare const createLayer: <ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>, LayerParams extends Record<string, any>>(elementType: "canvas" | "svg", config: DefineLayerConfig<"svg" | "canvas", ExtendContext, PluginParams, LayerParams>) => LayerEntity<ExtendContext, PluginParams, LayerParams>;

package/dist/src/plugin/createPlugin.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, DefinePluginConfig, ExtendableContext, PluginEntity } from '../types';
+
+export declare const createPlugin: <ElementType extends "svg" | "canvas", ExtendContext extends ExtendableContext, PluginParams, AllLayerParams>(elementType: ElementType, config: DefinePluginConfig<ExtendContext, PluginParams, AllLayerParams>, initPluginParams?: DeepPartial<PluginParams | AllLayerParams>) => PluginEntity<ElementType, PluginParams, AllLayerParams>;

package/dist/src/test/createGraphData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/test/createTreeData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/test/simple-graph-test.d.ts

@@ -0,0 +1,74 @@
+declare const testRawData: ({
+    id: string;
+    name: string;
+    dataset: string;
+    series: string;
+    category: string;
+    value: number;
+    source?: undefined;
+    target?: undefined;
+} | {
+    id: string;
+    name: string;
+    source: string;
+    target: string;
+    dataset: string;
+    series: string;
+    category: string;
+    value: number;
+})[];
+declare namespace testEncoding {
+    namespace dataset {
+        let from: string;
+        let sort: string;
+    }
+    namespace series {
+        let from_1: string;
+        export { from_1 as from };
+        let sort_1: string;
+        export { sort_1 as sort };
+    }
+    namespace category {
+        let from_2: string;
+        export { from_2 as from };
+        let sort_2: string;
+        export { sort_2 as sort };
+    }
+    namespace value {
+        let from_3: string;
+        export { from_3 as from };
+        let sort_3: string;
+        export { sort_3 as sort };
+        export let aggregate: string;
+    }
+    let multivariate: any[];
+    namespace color {
+        let from_4: string;
+        export { from_4 as from };
+    }
+}
+declare namespace testTheme {
+    let colorScheme: string;
+    namespace colors {
+        namespace light {
+            let data: string[];
+            let primary: string;
+            let secondary: string;
+            let dataContrast: string[];
+            let background: string;
+        }
+        namespace dark {
+            let data_1: string[];
+            export { data_1 as data };
+            let primary_1: string;
+            export { primary_1 as primary };
+            let secondary_1: string;
+            export { secondary_1 as secondary };
+            let dataContrast_1: string[];
+            export { dataContrast_1 as dataContrast };
+            let background_1: string;
+            export { background_1 as background };
+        }
+    }
+    let fontSize: number;
+}

package/dist/src/test/simple-tree-test.d.ts

@@ -0,0 +1,13 @@
+declare function printTree(node: any, depth?: number): void;
+declare const testRawData: {
+    id: string;
+    name: string;
+    parent: string;
+    dataset: string;
+    series: string;
+    category: string;
+    value: number;
+}[];
+declare const nodeMap: Map<any, any>;
+declare const rootNodes: any[];
+declare const childrenMap: Map<any, any>;

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

@@ -0,0 +1,39 @@
+import { DeepPartial, ChartContext, Encoding, PluginEntity, RawData, Theme } from './index';
+
+export interface SizeConfig {
+    width: number | 'auto';
+    height: number | 'auto';
+    resizeDebounce: number;
+}
+export interface ChartOptions {
+    size: SizeConfig;
+    theme: Theme;
+    data: RawData;
+    encoding: Encoding;
+    plugins: PluginEntity<any, any, any>[];
+}
+export interface PartialChartOptions {
+    size?: Partial<SizeConfig>;
+    theme?: DeepPartial<Theme>;
+    data?: RawData;
+    encoding?: DeepPartial<Encoding>;
+    plugins?: PluginEntity<any, any, any>[];
+}
+export interface CreateChart {
+    (element: HTMLElement | Element, options?: PartialChartOptions): ChartEntity;
+}
+export interface ChartEntity {
+    resize(sizeConfig: SizeConfig): void;
+    setData(data: RawData): void;
+    updateEncoding(patch: DeepPartial<Encoding>): void;
+    forceReplaceEncoding(full: Encoding): void;
+    getEncoding(): Readonly<Encoding>;
+    setPlugins(plugins: PluginEntity<any, any, any>[]): void;
+    addPlugin(plugin: PluginEntity<any, any, any>): void;
+    removePlugin(id: string): void;
+    updateTheme(patch: DeepPartial<Theme>): void;
+    forceReplaceTheme(full: Theme): void;
+    getTheme(): Readonly<Theme>;
+    destroy(): void;
+    context: ChartContext<{}>;
+}

package/dist/src/types/ChartContext.d.ts

@@ -0,0 +1,27 @@
+import { Observable, Subject } from 'rxjs';
+import { Encoding, ModelData, PluginInfo, Theme, EventData, LayerInfo } from './index';
+
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface ExtendableContext {
+    [key: string]: Observable<any> | Subject<any> | Function | any;
+}
+export type ChartContext<ExtendContext extends ExtendableContext> = {
+    root: HTMLElement | Element;
+    svg: SVGElement | null;
+    canvas: HTMLCanvasElement | null;
+    encoding$: Observable<Encoding>;
+    seriesData$: Observable<ModelData<'series'>[]>;
+    gridData$: Observable<ModelData<'grid'>[]>;
+    multivariateData$: Observable<ModelData<'multivariate'>[]>;
+    graphData$: Observable<ModelData<'graph'>[]>;
+    treeData$: Observable<ModelData<'tree'>[]>;
+    plugins$: Observable<readonly PluginInfo[]>;
+    theme$: Observable<Theme>;
+    event$: Observable<EventData>;
+    eventTrigger$: Subject<EventData>;
+    size$: Observable<Size>;
+    _updateLayerElements: <ElementType extends "svg" | "canvas">(elementType: ElementType, fromPluginName: string, fetchLayerInfo: LayerInfo[]) => Record<string, ElementType extends "svg" ? SVGGElement : HTMLCanvasElement>;
+} & ExtendContext;

package/dist/src/types/Common.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = Partial<{
+    [P in keyof T]: DeepPartial<T[P]>;
+}>;

package/dist/src/types/Encoding.d.ts

@@ -0,0 +1,33 @@
+export interface EncodingDataset {
+    from: string;
+    sort: 'original' | 'alphabetical' | string[];
+}
+export interface EncodingSeries {
+    from: string;
+    sort: 'original' | 'alphabetical' | string[];
+}
+export interface EncodingCategory {
+    from: string;
+    sort: 'original' | 'alphabetical' | string[];
+}
+export interface EncodingValue {
+    from: string;
+    sort: 'original' | 'asc' | 'desc';
+    aggregate: 'sum' | 'mean' | 'median' | 'min' | 'max' | 'count' | 'none';
+}
+export interface EncodingMultivariateItem {
+    from: string;
+    name: string;
+}
+export type EncodingMultivariate = EncodingMultivariateItem[];
+export interface EncodingColor {
+    from: 'index' | 'series' | 'category' | 'dataset';
+}
+export interface Encoding {
+    dataset: EncodingDataset;
+    series: EncodingSeries;
+    category: EncodingCategory;
+    value: EncodingValue;
+    multivariate: EncodingMultivariate;
+    color: EncodingColor;
+}

package/dist/src/types/Event.d.ts

@@ -0,0 +1,12 @@
+import { ModelType, RenderDatumBase } from '../../../core/src/types/index';
+
+export type EventType = 'click' | 'mouseover' | 'mousemove' | 'mouseout' | 'dragstart' | 'drag' | 'dragend' | 'zoom' | 'transitionMove' | 'transitionEnd';
+export interface EventData<T extends ModelType = ModelType, ExtendTypes extends Record<string, any> = {}> {
+    eventName: EventType;
+    pluginName: string;
+    layerName: string;
+    target: RenderDatumBase<T, ExtendTypes> | null;
+    data?: any;
+    tween?: number;
+    event?: Event;
+}

package/dist/src/types/Layers.d.ts

@@ -0,0 +1,55 @@
+import { Observable } from 'rxjs';
+import { DeepPartial, ChartContext, ExtendableContext, ValidatorResult } from './index';
+
+export interface LayerInfo {
+    pluginId: string;
+    pluginName: string;
+    layerName: string;
+    layerIndex: number;
+}
+export interface SVGLayerEnableProps<ExtendContext extends ExtendableContext, PluginParams, LayerParams> {
+    context: ChartContext<ExtendContext>;
+    svgG: SVGGElement;
+    pluginParams$: Observable<PluginParams>;
+    initLayerParams: DeepPartial<LayerParams>;
+}
+export interface CanvasLayerEnableProps<ExtendContext extends ExtendableContext, PluginParams, LayerParams> {
+    context: ChartContext<ExtendContext>;
+    canvas: HTMLCanvasElement;
+    pluginParams$: Observable<PluginParams>;
+    initLayerParams: DeepPartial<LayerParams>;
+}
+export type LayerEnableProps<ElementType extends 'svg' | 'canvas', ExtendContext extends ExtendableContext, PluginParams, LayerParams> = ElementType extends 'svg' ? SVGLayerEnableProps<ExtendContext, PluginParams, LayerParams> : ElementType extends 'canvas' ? CanvasLayerEnableProps<ExtendContext, PluginParams, LayerParams> : never;
+export interface SVGLayerSetupProps<ExtendContext extends ExtendableContext, PluginParams, LayerParams> {
+    context: ChartContext<ExtendContext>;
+    svgG: SVGGElement;
+    pluginParams$: Observable<PluginParams>;
+    layerParams$: Observable<LayerParams>;
+}
+export interface CanvasLayerSetupProps<ExtendContext extends ExtendableContext, PluginParams, LayerParams> {
+    context: ChartContext<ExtendContext>;
+    canvas: HTMLCanvasElement;
+    pluginParams$: Observable<PluginParams>;
+    layerParams$: Observable<LayerParams>;
+}
+export type LayerSetupProps<ElementType extends 'svg' | 'canvas', ExtendContext extends ExtendableContext, PluginParams, LayerParams> = ElementType extends 'svg' ? SVGLayerSetupProps<ExtendContext, PluginParams, LayerParams> : ElementType extends 'canvas' ? CanvasLayerSetupProps<ExtendContext, PluginParams, LayerParams> : never;
+export interface DefineLayerConfig<ElementType extends 'svg' | 'canvas', ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>, LayerParams extends Record<string, any>> {
+    name: string;
+    defaultParams: LayerParams;
+    layerIndex: number;
+    initShow: boolean;
+    validator?: (params: DeepPartial<LayerParams>) => ValidatorResult;
+    setup: (setupProps: LayerSetupProps<ElementType, ExtendContext, PluginParams, LayerParams>) => () => void;
+}
+export interface LayerEntity<ExtendContext extends ExtendableContext, PluginParams, LayerParams> {
+    readonly _name: string;
+    readonly _defaultParams: LayerParams;
+    readonly _layerIndex: number;
+    readonly _initShow: boolean;
+    _enable(enableProps: LayerEnableProps<'svg' | 'canvas', ExtendContext, PluginParams, LayerParams>): void;
+    _disable(): void;
+    _updateParams(params: DeepPartial<LayerParams>): void;
+    _forceReplaceParams(params: LayerParams): void;
+    _getParams: () => LayerParams;
+    _destroy(): void;
+}

package/dist/src/types/ModelData.d.ts

@@ -0,0 +1,70 @@
+export type ModelType = 'series' | 'grid' | 'multivariate' | 'graph' | 'tree';
+export interface ModelDatumBase {
+    id: string;
+    index: number;
+    modelType: ModelType;
+    name: string;
+    data: any;
+    value: number | null;
+    color: string;
+}
+export interface ModelDatumSeries extends ModelDatumBase {
+    series: string;
+    seriesIndex: number;
+    category: string;
+    categoryIndex: number;
+}
+export interface ModelDatumGrid extends ModelDatumBase {
+    series: string;
+    seriesIndex: number;
+    category: string;
+    categoryIndex: number;
+}
+export interface ModelDatumMultivariate extends ModelDatumBase {
+    series: string;
+    seriesIndex: number;
+    category: string;
+    categoryIndex: number;
+    multivariate: Array<{
+        index: number;
+        name: string;
+        value: number | null;
+    }>;
+}
+export interface ModelDatumGraphNode extends ModelDatumBase {
+    series: string;
+    seriesIndex: number;
+    category: string;
+    categoryIndex: number;
+}
+export interface ModelDatumGraphEdge extends ModelDatumBase {
+    series: string;
+    seriesIndex: number;
+    category: string;
+    categoryIndex: number;
+    source: string;
+    sourceIndex: number;
+    target: string;
+    targetIndex: number;
+}
+export interface ModelDatumTree extends ModelDatumBase {
+    parent: string | null;
+    parentIndex: number | null;
+    depth: number;
+    seq: number;
+    children: ModelDatumTree[];
+    series: string;
+    seriesIndex: number;
+    category: string;
+    categoryIndex: number;
+}
+export type ModelDatum<T extends ModelType> = T extends 'series' ? ModelDatumSeries : T extends 'grid' ? ModelDatumGrid : T extends 'multivariate' ? ModelDatumMultivariate : T extends 'graph' ? ModelDatumGraphNode : T extends 'tree' ? ModelDatumTree : unknown;
+export type ModelDataSeries = ModelDatum<'series'>[][];
+export type ModelDataGrid = ModelDatum<'grid'>[][];
+export type ModelDataMultivariate = ModelDatum<'multivariate'>[][];
+export interface ModelDataGraph {
+    nodes: ModelDatumGraphNode[];
+    edges: ModelDatumGraphEdge[];
+}
+export type ModelDataTree = ModelDatum<'tree'>;
+export type ModelData<T extends ModelType = ModelType> = T extends 'series' ? ModelDataSeries : T extends 'grid' ? ModelDataGrid : T extends 'multivariate' ? ModelDataMultivariate : T extends 'graph' ? ModelDataGraph : T extends 'tree' ? ModelDataTree : unknown;

package/dist/src/types/Plugin.d.ts

@@ -0,0 +1,39 @@
+import { Observable } from 'rxjs';
+import { DeepPartial, LayerEntity, ChartContext, ExtendableContext } from './index';
+import { ValidatorResult } from '../types/Validator';
+
+export interface PluginInfo {
+    id: string;
+    name: string;
+    elementType: 'svg' | 'canvas';
+    shownLayers: string[];
+}
+export interface PluginSetupProps<ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>> {
+    context: ChartContext<ExtendContext>;
+    pluginParams$: Observable<PluginParams>;
+}
+export interface DefinePluginConfig<ExtendContext extends ExtendableContext, PluginParams extends Record<string, any>, AllLayerParams extends Record<string, any>> {
+    name: string;
+    defaultParams?: PluginParams;
+    validator?: (params: DeepPartial<AllLayerParams | PluginParams>) => ValidatorResult;
+    layers?: LayerEntity<ExtendContext, PluginParams, AllLayerParams[keyof AllLayerParams]>[];
+    setup?: (props: PluginSetupProps<ExtendContext, PluginParams>) => () => void;
+}
+export interface PluginEntity<ElementType extends 'svg' | 'canvas', PluginParams extends Record<string, any>, AllLayerParams extends Record<string, any>> {
+    readonly _name: string;
+    readonly _elementType: ElementType;
+    _getId: () => string;
+    _setId: (id: string) => void;
+    _injectContext(context: ChartContext<{}>): void;
+    show(names: (keyof AllLayerParams) | (keyof AllLayerParams)[]): void;
+    showOnly(names: (keyof AllLayerParams) | (keyof AllLayerParams)[]): void;
+    showAll(): void;
+    hide(names: (keyof AllLayerParams) | (keyof AllLayerParams)[]): void;
+    hideAll(): void;
+    toggle(names: (keyof AllLayerParams) | (keyof AllLayerParams)[]): void;
+    getShownLayerNames(): (keyof AllLayerParams)[];
+    updateParams(patch: DeepPartial<PluginParams | AllLayerParams>): void;
+    forceReplaceParams(full: PluginParams | AllLayerParams): void;
+    getParams(): Readonly<PluginParams | AllLayerParams>;
+    destroy(): void;
+}

package/dist/src/types/RawData.d.ts

@@ -0,0 +1,18 @@
+export type RawData = RawDataColumn[] | RawDataColumn[][];
+export type DynamicDefaultRawDataFields = {
+    value?: number | null;
+    x?: number | null;
+    y?: number | null;
+    z?: number | null;
+    dataset?: string;
+    series?: string;
+    category?: string;
+};
+export type RawDataColumn<DynamicFields extends Record<string, any> = DynamicDefaultRawDataFields> = {
+    id?: string;
+    name?: string;
+    source?: string;
+    target?: string;
+    parent?: string;
+    data?: any;
+} & DynamicFields;

package/dist/src/types/RenderData.d.ts

@@ -0,0 +1,4 @@
+import { ModelType, ModelDatum, ModelDatumGraphEdge } from './index';
+
+export type RenderDatumBase<T extends ModelType, ExtendTypes extends Record<string, any> = {}> = ModelDatum<T> & ExtendTypes;
+export type RenderDatumGraphEdge<ExtendTypes extends Record<string, any> = {}> = ModelDatumGraphEdge & ExtendTypes;

package/dist/src/types/Theme.d.ts

@@ -0,0 +1,17 @@
+export interface Colors {
+    data: string[];
+    primary: string;
+    secondary: string;
+    dataContrast: string[];
+    background: string;
+}
+export type ColorScheme = 'light' | 'dark';
+export interface Theme {
+    colorScheme: ColorScheme | 'auto';
+    colors: {
+        light: Colors;
+        dark: Colors;
+    };
+    fontSize: string | number;
+}
+export type ColorType = 'none' | keyof Colors;

package/dist/src/types/Validator.d.ts

@@ -0,0 +1,20 @@
+export type ToBeTypes = 'string' | 'number' | 'boolean' | 'object' | 'object[]' | 'string[]' | 'number[]' | 'Function' | 'null' | 'undefined';
+export type ToBeOption = 'ColorType';
+export interface ValidatorRuleToBeTypes {
+    toBeTypes: ToBeTypes[];
+}
+export interface ValidatorRuleToBe {
+    toBe: string;
+    test: (value: any) => boolean;
+}
+export interface ValidatorRuleToBeOption {
+    toBeOption: ToBeOption;
+}
+export type ValidatorRule<T> = {
+    [key in keyof T]: ValidatorRuleToBeTypes | ValidatorRuleToBe | ValidatorRuleToBeOption;
+};
+export interface ValidatorResult {
+    status: 'success' | 'warning' | 'error';
+    columnName: string;
+    expectToBe: string;
+}

package/dist/src/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from './Chart';
+export * from './ChartContext';
+export * from './Encoding';
+export * from './Event';
+export * from './Layers';
+export * from './ModelData';
+export * from './Plugin';
+export * from './RawData';
+export * from './RenderData';
+export * from './Theme';
+export * from './Validator';
+export * from './Common';

package/dist/src/utils/aggregateUtils.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 聚合函數工具集
+ * 用於處理數值陣列的各種聚合運算
+ */
+export type AggregateType = 'sum' | 'mean' | 'median' | 'min' | 'max' | 'count' | 'none';
+/**
+ * 計算數值陣列的總和
+ */
+export declare function sum(values: (number | null)[]): number | null;
+/**
+ * 計算數值陣列的平均值
+ */
+export declare function mean(values: (number | null)[]): number | null;
+/**
+ * 計算數值陣列的中位數
+ */
+export declare function median(values: (number | null)[]): number | null;
+/**
+ * 計算數值陣列的最小值
+ */
+export declare function min(values: (number | null)[]): number | null;
+/**
+ * 計算數值陣列的最大值
+ */
+export declare function max(values: (number | null)[]): number | null;
+/**
+ * 計算數值陣列的有效數量
+ */
+export declare function count(values: (number | null)[]): number;
+/**
+ * 不進行聚合，返回第一個有效值
+ */
+export declare function none(values: (number | null)[]): number | null;
+/**
+ * 根據聚合類型執行對應的聚合函數
+ */
+export declare function aggregate(values: (number | null)[], type: AggregateType): number | null;

package/dist/src/utils/colorUtils.d.ts

@@ -0,0 +1,22 @@
+import { Theme } from '../types';
+
+/**
+ * 根據索引和主題計算對應的顏色
+ * @param index 索引值
+ * @param theme 主題設定
+ * @returns 對應的顏色（hex 格式）
+ */
+export declare function getColorByIndex(index: number, theme: Theme): string;
+/**
+ * 根據不同的 encoding.color.from 計算顏色
+ * @param colorFrom 顏色來源類型
+ * @param options 包含所有可能索引的選項物件
+ * @param theme 主題設定
+ * @returns 對應的顏色（hex 格式）
+ */
+export declare function getColorByFrom(colorFrom: 'index' | 'series' | 'category' | 'dataset', options: {
+    index?: number;
+    seriesIndex?: number;
+    categoryIndex?: number;
+    datasetIndex?: number;
+}, theme: Theme): string;