import { Path, PathProps, MatrixArray, Displayable, BoundingRect, ZRText, BoxLayoutOptionMixin, ElementProps, Element, Model, AnimationOptionMixin, AnimationOption, ZRRectLike, ZRImage, Transformable, VectorArray, DisplayableProps, Source, OptionSourceData, SeriesDimensionDefine, DimensionDefinitionLoose, HashMap, OptionEncodeValue, DimensionName, OptionEncode, EncodeDefaulter, DimensionDefinition, DataVisualDimensions, OrdinalMeta, DimensionIndex, GradientObject, SeriesModel, SeriesOption, SeriesStackOptionMixin, DataCalculationInfo, SeriesData, SeriesDataSchema, DataStore, DataModel, ECEventData, SeriesDataType, InnerFocus, BlurScope, ComponentMainType, ComponentItemTooltipOption, DefaultDataVisual, AxisBaseModel, Scale, Dictionary, TextCommonOption, DisplayState, TextStyleProps as TextStyleProps$1, createSymbol, GeoJSON, GeoJSONCompressed, GeoJSONRegion, LocaleOption, Arc, BezierCurve, Circle, CompoundPath, Ellipse, Group, Line, LinearGradient, Polygon, Polyline, RadialGradient, Rect, Ring, Sector, addCommas, capitalFirst, formatTime, formatTpl, getTooltipMarker, normalizeCssArray, toCamelCase, bind, clone, curry, defaults, each, extend, filter, indexOf, inherits, isArray, isFunction, isObject, isString, map, merge, reduce, ComponentModel, ChartView, ComponentOption, ECBasicOption } from './internal/extension.js'; export { AnimationDelayCallback, AnimationDelayCallbackParam as AnimationDelayCallbackParams, AnimationDurationCallback, AriaOption as AriaComponentOption, Axis, BrushOption as BrushComponentOption, ZRColor as Color, ComponentView, CustomSeriesRenderItem, CustomSeriesRenderItemAPI, CustomSeriesRenderItemParams, CustomSeriesRenderItemReturn, DatasetOption as DatasetComponentOption, CallbackDataParams as DefaultLabelFormatterCallbackParams, DownplayPayload, ECElementEvent, EChartsType as ECharts, EChartsInitOpts, EChartsType, ElementEvent, HighlightPayload, ImagePatternObject, LabelFormatterCallback, LabelLayoutOptionCallback, LabelLayoutOptionCallbackParams, LinearGradientObject, PRIORITY, PatternObject, Payload, LegendOption as PlainLegendComponentOption, RadialGradientObject, ResizeOpts, SVGPatternObject, SelectChangedPayload, SetOptionOpts, SetOptionTransitionOpt, SetOptionTransitionOptItem, TooltipFormatterCallback as TooltipComponentFormatterCallback, TooltipPositionCallback as TooltipComponentPositionCallback, TooltipPositionCallbackParams as TooltipComponentPositionCallbackParams, connect, dataTool, dependencies, disConnect, disconnect, dispose, getCoordinateSystemDimensions, getInstanceByDom, getInstanceById, getMap, init, matrix_d as matrix, registerAction, registerCoordinateSystem, registerLayout, registerLoading, registerLocale, registerMap, registerPostInit, registerPostUpdate, registerPreprocessor, registerProcessor, registerTheme, registerTransform, registerUpdateLifecycle, registerVisual, setCanvasCreator, use, vector_d as vector, version, util_d as zrUtil, zrender_d as zrender } from './internal/extension.js'; import { XAXisOption, YAXisOption, AxisPointerOption, AngleAxisOption, RadiusAxisOption, ParallelAxisOption } from './internal/option.js'; export { BarSeriesOption, BoxplotSeriesOption, CalendarOption as CalendarComponentOption, CandlestickSeriesOption, ContinousVisualMapOption as ContinousVisualMapComponentOption, CustomSeriesOption, DataZoomComponentOption, EChartsOption, EffectScatterSeriesOption, FunnelSeriesOption, GaugeSeriesOption, GeoOption as GeoComponentOption, GraphSeriesOption, GraphicComponentLooseOption as GraphicComponentOption, GridOption as GridComponentOption, HeatmapSeriesOption, InsideDataZoomOption as InsideDataZoomComponentOption, LegendComponentOption, LineSeriesOption, LinesSeriesOption, MapSeriesOption, MarkAreaOption as MarkAreaComponentOption, MarkLineOption as MarkLineComponentOption, MarkPointOption as MarkPointComponentOption, ParallelCoordinateSystemOption as ParallelComponentOption, ParallelSeriesOption, PictorialBarSeriesOption, PieSeriesOption, PiecewiseVisualMapOption as PiecewiseVisualMapComponentOption, PolarOption as PolarComponentOption, RadarOption as RadarComponentOption, RadarSeriesOption, RegisteredSeriesOption, SankeySeriesOption, ScatterSeriesOption, ScrollableLegendOption as ScrollableLegendComponentOption, SeriesOption, SingleAxisOption as SingleAxisComponentOption, SliderDataZoomOption as SliderDataZoomComponentOption, SunburstSeriesOption, ThemeRiverSeriesOption, TimelineOption as TimelineComponentOption, TitleOption as TitleComponentOption, ToolboxComponentOption, TopLevelFormatterParams as TooltipComponentFormatterCallbackParams, TooltipOption as TooltipComponentOption, TreeSeriesOption, TreemapSeriesOption, VisualMapComponentOption } from './internal/option.js'; declare type SVGPathOption$1 = Omit; declare class SVGPath$1 extends Path { applyTransform(m: MatrixArray): void; } declare function extendFromString(str: string, defaultOpts?: SVGPathOption$1): typeof SVGPath$1; declare function mergePath$1(pathEls: Path[], opts: PathProps): Path; declare class IncrementalDisplayable extends Displayable { notClear: boolean; incremental: boolean; private _displayables; private _temporaryDisplayables; private _cursor; traverse(cb: (this: T, el: this) => void, context: T): void; useStyle(): void; getCursor(): number; innerAfterBrush(): void; clearDisplaybles(): void; clearTemporalDisplayables(): void; addDisplayable(displayable: Displayable, notPersistent?: boolean): void; addDisplayables(displayables: Displayable[], notPersistent?: boolean): void; getDisplayables(): Displayable[]; getTemporalDisplayables(): Displayable[]; eachPendingDisplayable(cb: (displayable: Displayable) => void): void; update(): void; getBoundingRect(): BoundingRect; contain(x: number, y: number): boolean; } declare function encodeHTML(source: string): string; interface InnerTruncateOption { maxIteration?: number; minChar?: number; placeholder?: string; maxIterations?: number; } declare function truncateText(text: string, containerWidth: number, font: string, ellipsis?: string, options?: InnerTruncateOption): string; declare type TextStyleProps = ZRText['style']; declare function getTextRect(text: TextStyleProps['text'], font?: TextStyleProps['font'], align?: TextStyleProps['align'], verticalAlign?: TextStyleProps['verticalAlign'], padding?: TextStyleProps['padding'], rich?: TextStyleProps['rich'], truncate?: boolean, lineHeight?: number): BoundingRect; interface LayoutRect extends BoundingRect { margin: number[]; } /** * Parse position info. */ declare function getLayoutRect(positionInfo: BoxLayoutOptionMixin & { aspect?: number; }, containerRect: { width: number; height: number; }, margin?: number | number[]): LayoutRect; declare type AnimateOrSetPropsOption = { dataIndex?: number; cb?: () => void; during?: (percent: number) => void; removeOpt?: AnimationOption; isFrom?: boolean; }; /** * Update graphic element properties with or without animation according to the * configuration in series. * * Caution: this method will stop previous animation. * So do not use this method to one element twice before * animation starts, unless you know what you are doing. * @example * graphic.updateProps(el, { * position: [100, 100] * }, seriesModel, dataIndex, function () { console.log('Animation done!'); }); * // Or * graphic.updateProps(el, { * position: [100, 100] * }, seriesModel, function () { console.log('Animation done!'); }); */ declare function updateProps(el: Element, props: Props, animatableModel?: Model, dataIndex?: AnimateOrSetPropsOption['dataIndex'] | AnimateOrSetPropsOption['cb'] | AnimateOrSetPropsOption, cb?: AnimateOrSetPropsOption['cb'] | AnimateOrSetPropsOption['during'], during?: AnimateOrSetPropsOption['during']): void; /** * Init graphic element properties with or without animation according to the * configuration in series. * * Caution: this method will stop previous animation. * So do not use this method to one element twice before * animation starts, unless you know what you are doing. */ declare function initProps(el: Element, props: Props, animatableModel?: Model, dataIndex?: AnimateOrSetPropsOption['dataIndex'] | AnimateOrSetPropsOption['cb'] | AnimateOrSetPropsOption, cb?: AnimateOrSetPropsOption['cb'] | AnimateOrSetPropsOption['during'], during?: AnimateOrSetPropsOption['during']): void; declare type ExtendShapeOpt = Parameters[0]; declare type ExtendShapeReturn = ReturnType; /** * Extend shape with parameters */ declare function extendShape(opts: ExtendShapeOpt): ExtendShapeReturn; declare const extendPathFromString: typeof extendFromString; declare type SVGPathOption = Parameters[1]; declare type SVGPathCtor = ReturnType; declare type SVGPath = InstanceType; /** * Extend path */ declare function extendPath(pathData: string, opts: SVGPathOption): SVGPathCtor; /** * Register a user defined shape. * The shape class can be fetched by `getShapeClass` * This method will overwrite the registered shapes, including * the registered built-in shapes, if using the same `name`. * The shape can be used in `custom series` and * `graphic component` by declaring `{type: name}`. * * @param name * @param ShapeClass Can be generated by `extendShape`. */ declare function registerShape(name: string, ShapeClass: { new (): Path; }): void; /** * Find shape class registered by `registerShape`. Usually used in * fetching user defined shape. * * [Caution]: * (1) This method **MUST NOT be used inside echarts !!!**, unless it is prepared * to use user registered shapes. * Because the built-in shape (see `getBuiltInShape`) will be registered by * `registerShape` by default. That enables users to get both built-in * shapes as well as the shapes belonging to themsleves. But users can overwrite * the built-in shapes by using names like 'circle', 'rect' via calling * `registerShape`. So the echarts inner featrues should not fetch shapes from here * in case that it is overwritten by users, except that some features, like * `custom series`, `graphic component`, do it deliberately. * * (2) In the features like `custom series`, `graphic component`, the user input * `{tpye: 'xxx'}` does not only specify shapes but also specify other graphic * elements like `'group'`, `'text'`, `'image'` or event `'path'`. Those names * are reserved names, that is, if some user registers a shape named `'image'`, * the shape will not be used. If we intending to add some more reserved names * in feature, that might bring break changes (disable some existing user shape * names). But that case probably rarely happens. So we don't make more mechanism * to resolve this issue here. * * @param name * @return The shape class. If not found, return nothing. */ declare function getShapeClass(name: string): { new (): Path; }; /** * Create a path element from path data string * @param pathData * @param opts * @param rect * @param layout 'center' or 'cover' default to be cover */ declare function makePath(pathData: string, opts: SVGPathOption, rect: ZRRectLike, layout?: 'center' | 'cover'): SVGPath; /** * Create a image element from image url * @param imageUrl image url * @param opts options * @param rect constrain rect * @param layout 'center' or 'cover'. Default to be 'cover' */ declare function makeImage(imageUrl: string, rect: ZRRectLike, layout?: 'center' | 'cover'): ZRImage; declare const mergePath: typeof mergePath$1; /** * Resize a path to fit the rect * @param path * @param rect */ declare function resizePath(path: SVGPath, rect: ZRRectLike): void; /** * Get transform matrix of target (param target), * in coordinate of its ancestor (param ancestor) * * @param target * @param [ancestor] */ declare function getTransform(target: Transformable, ancestor?: Transformable): MatrixArray; declare function clipPointsByRect(points: VectorArray[], rect: ZRRectLike): number[][]; /** * Return a new clipped rect. If rect size are negative, return undefined. */ declare function clipRectByRect(targetRect: ZRRectLike, rect: ZRRectLike): ZRRectLike | undefined; declare function createIcon(iconStr: string, // Support 'image://' or 'path://' or direct svg path. opt?: Omit, rect?: ZRRectLike): SVGPath | ZRImage; interface CoordDimensionDefinition extends DimensionDefinition { dimsDef?: (DimensionName | { name: DimensionName; defaultTooltip?: boolean; })[]; otherDims?: DataVisualDimensions; ordinalMeta?: OrdinalMeta; coordDim?: DimensionName; coordDimIndex?: DimensionIndex; } declare type CoordDimensionDefinitionLoose = CoordDimensionDefinition['name'] | CoordDimensionDefinition; declare type PrepareSeriesDataSchemaParams = { coordDimensions?: CoordDimensionDefinitionLoose[]; /** * Will use `source.dimensionsDefine` if not given. */ dimensionsDefine?: DimensionDefinitionLoose[]; /** * Will use `source.encodeDefine` if not given. */ encodeDefine?: HashMap | OptionEncode; dimensionsCount?: number; /** * Make default encode if user not specified. */ encodeDefaulter?: EncodeDefaulter; generateCoord?: string; generateCoordCount?: number; /** * If be able to omit unused dimension * Used to improve the performance on high dimension data. */ canOmitUnusedDimensions?: boolean; }; /** * For outside usage compat (like echarts-gl are using it). */ declare function createDimensions(source: Source | OptionSourceData, opt?: PrepareSeriesDataSchemaParams): SeriesDimensionDefine[]; declare function parse(colorStr: string, rgbaArr?: number[]): number[]; declare function lift(color: string, level: number): string; declare function toHex(color: string): string; declare function fastLerp(normalizedValue: number, colors: number[][], out?: number[]): number[]; declare const fastMapToColor: typeof fastLerp; declare type LerpFullOutput = { color: string; leftIndex: number; rightIndex: number; value: number; }; declare function lerp(normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput; declare function lerp(normalizedValue: number, colors: string[]): string; declare const mapToColor: typeof lerp; declare function modifyHSL(color: string, h?: number, s?: number, l?: number): string; declare function modifyAlpha(color: string, alpha?: number): string; declare function stringify(arrColor: number[], type: string): string; declare function lum(color: string, backgroundLum: number): number; declare function random(): string; declare function liftColor(color: GradientObject): GradientObject; declare function liftColor(color: string): string; declare const color_d_fastLerp: typeof fastLerp; declare const color_d_fastMapToColor: typeof fastMapToColor; declare const color_d_lerp: typeof lerp; declare const color_d_lift: typeof lift; declare const color_d_liftColor: typeof liftColor; declare const color_d_lum: typeof lum; declare const color_d_mapToColor: typeof mapToColor; declare const color_d_modifyAlpha: typeof modifyAlpha; declare const color_d_modifyHSL: typeof modifyHSL; declare const color_d_parse: typeof parse; declare const color_d_random: typeof random; declare const color_d_stringify: typeof stringify; declare const color_d_toHex: typeof toHex; declare namespace color_d { export { color_d_fastLerp as fastLerp, color_d_fastMapToColor as fastMapToColor, color_d_lerp as lerp, color_d_lift as lift, color_d_liftColor as liftColor, color_d_lum as lum, color_d_mapToColor as mapToColor, color_d_modifyAlpha as modifyAlpha, color_d_modifyHSL as modifyHSL, color_d_parse as parse, color_d_random as random, color_d_stringify as stringify, color_d_toHex as toHex }; } declare type ThrottleFunction = (this: unknown, ...args: unknown[]) => void; interface ThrottleController { clear(): void; debounceNextCall(debounceDelay: number): void; } /** * @public * @param {(Function)} fn * @param {number} [delay=0] Unit: ms. * @param {boolean} [debounce=false] * true: If call interval less than `delay`, only the last call works. * false: If call interval less than `delay, call works on fixed rate. * @return {(Function)} throttled fn. */ declare function throttle(fn: T, delay?: number, debounce?: boolean): T & ThrottleController; declare type EnableDataStackDimensionsInput = { schema: SeriesDataSchema; store?: DataStore; }; declare type EnableDataStackDimensionsInputLegacy = (SeriesDimensionDefine | string)[]; /** * Note that it is too complicated to support 3d stack by value * (have to create two-dimension inverted index), so in 3d case * we just support that stacked by index. * * @param seriesModel * @param dimensionsInput The same as the input of . * The input will be modified. * @param opt * @param opt.stackedCoordDimension Specify a coord dimension if needed. * @param opt.byIndex=false * @return calculationInfo * { * stackedDimension: string * stackedByDimension: string * isStackedByIndex: boolean * stackedOverDimension: string * stackResultDimension: string * } */ declare function enableDataStack(seriesModel: SeriesModel, dimensionsInput: EnableDataStackDimensionsInput | EnableDataStackDimensionsInputLegacy, opt?: { stackedCoordDimension?: string; byIndex?: boolean; }): Pick, 'stackedDimension' | 'stackedByDimension' | 'isStackedByIndex' | 'stackedOverDimension' | 'stackResultDimension'>; declare function isDimensionStacked(data: SeriesData, stackedDim: string): boolean; declare function getStackedDimension(data: SeriesData, targetDim: string): DimensionName; declare type SSRItemType = 'chart' | 'legend'; /** * ECData stored on graphic element */ interface ECData { dataIndex?: number; dataModel?: DataModel; eventData?: ECEventData; seriesIndex?: number; dataType?: SeriesDataType; focus?: InnerFocus; blurScope?: BlurScope; ssrType?: SSRItemType; componentMainType?: ComponentMainType; componentIndex?: number; componentHighDownName?: string; tooltipConfig?: { name: string; option: ComponentItemTooltipOption; }; } declare const getECData: (hostObj: Element) => ECData; /** * Enable the function that mouseover will trigger the emphasis state. * * NOTE: * This function should be used on the element with dataIndex, seriesIndex. * */ declare function enableHoverEmphasis(el: Element, focus?: InnerFocus, blurScope?: BlurScope): void; /** * Create a multi dimension List structure from seriesModel. */ declare function createList(seriesModel: SeriesModel): SeriesData, DefaultDataVisual>; declare const dataStack: { isDimensionStacked: typeof isDimensionStacked; enableDataStack: typeof enableDataStack; getStackedDimension: typeof getStackedDimension; }; /** * Create scale * @param {Array.} dataExtent * @param {Object|module:echarts/Model} option If `optoin.type` * is secified, it can only be `'value'` currently. */ declare function createScale(dataExtent: number[], option: object | AxisBaseModel): Scale>; /** * Mixin common methods to axis model, * * Include methods * `getFormattedLabels() => Array.` * `getCategories() => Array.` * `getMin(origin: boolean) => number` * `getMax(origin: boolean) => number` * `getNeedCrossZero() => boolean` */ declare function mixinAxisModelCommonMethods(Model: Model): void; declare function createTextStyle(textStyleModel: Model, opts?: { state?: DisplayState; }): TextStyleProps$1; declare const helper_d_createDimensions: typeof createDimensions; declare const helper_d_createList: typeof createList; declare const helper_d_createScale: typeof createScale; declare const helper_d_createSymbol: typeof createSymbol; declare const helper_d_createTextStyle: typeof createTextStyle; declare const helper_d_dataStack: typeof dataStack; declare const helper_d_enableHoverEmphasis: typeof enableHoverEmphasis; declare const helper_d_getECData: typeof getECData; declare const helper_d_getLayoutRect: typeof getLayoutRect; declare const helper_d_mixinAxisModelCommonMethods: typeof mixinAxisModelCommonMethods; declare namespace helper_d { export { helper_d_createDimensions as createDimensions, helper_d_createList as createList, helper_d_createScale as createScale, helper_d_createSymbol as createSymbol, helper_d_createTextStyle as createTextStyle, helper_d_dataStack as dataStack, helper_d_enableHoverEmphasis as enableHoverEmphasis, helper_d_getECData as getECData, helper_d_getLayoutRect as getLayoutRect, helper_d_mixinAxisModelCommonMethods as mixinAxisModelCommonMethods }; } interface Platform { createCanvas(): HTMLCanvasElement; measureText(text: string, font?: string): { width: number; }; loadImage(src: string, onload: () => void | HTMLImageElement['onload'], onerror: () => void | HTMLImageElement['onerror']): HTMLImageElement; } declare function setPlatformAPI(newPlatformApis: Partial): void; declare function parseGeoJSON(geoJson: GeoJSON | GeoJSONCompressed, nameProperty: string): GeoJSONRegion[]; /** * Linear mapping a value from domain to range * @param val * @param domain Domain extent domain[0] can be bigger than domain[1] * @param range Range extent range[0] can be bigger than range[1] * @param clamp Default to be false */ declare function linearMap(val: number, domain: number[], range: number[], clamp?: boolean): number; /** * (1) Fix rounding error of float numbers. * (2) Support return string to avoid scientific notation like '3.5e-7'. */ declare function round(x: number | string, precision?: number): number; declare function round(x: number | string, precision: number, returnStr: false): number; declare function round(x: number | string, precision: number, returnStr: true): string; /** * Inplacd asc sort arr. * The input arr will be modified. */ declare function asc(arr: T): T; /** * Get precision. */ declare function getPrecision(val: string | number): number; /** * Get precision with slow but safe method */ declare function getPrecisionSafe(val: string | number): number; /** * Minimal dicernible data precisioin according to a single pixel. */ declare function getPixelPrecision(dataExtent: [number, number], pixelExtent: [number, number]): number; /** * Get a data of given precision, assuring the sum of percentages * in valueList is 1. * The largest remainder method is used. * https://en.wikipedia.org/wiki/Largest_remainder_method * * @param valueList a list of all data * @param idx index of the data to be processed in valueList * @param precision integer number showing digits of precision * @return percent ranging from 0 to 100 */ declare function getPercentWithPrecision(valueList: number[], idx: number, precision: number): number; declare const MAX_SAFE_INTEGER = 9007199254740991; /** * To 0 - 2 * PI, considering negative radian. */ declare function remRadian(radian: number): number; /** * @param {type} radian * @return {boolean} */ declare function isRadianAroundZero(val: number): boolean; /** * @param value valid type: number | string | Date, otherwise return `new Date(NaN)` * These values can be accepted: * + An instance of Date, represent a time in its own time zone. * + Or string in a subset of ISO 8601, only including: * + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06', * + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123', * + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00', * all of which will be treated as local time if time zone is not specified * (see ). * + Or other string format, including (all of which will be treated as local time): * '2012', '2012-3-1', '2012/3/1', '2012/03/01', * '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123' * + a timestamp, which represent a time in UTC. * @return date Never be null/undefined. If invalid, return `new Date(NaN)`. */ declare function parseDate(value: unknown): Date; /** * Quantity of a number. e.g. 0.1, 1, 10, 100 * * @param val * @return */ declare function quantity(val: number): number; /** * Exponent of the quantity of a number * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3 * * @param val non-negative value * @return */ declare function quantityExponent(val: number): number; /** * find a “nice” number approximately equal to x. Round the number if round = true, * take ceiling if round = false. The primary observation is that the “nicest” * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers. * * See "Nice Numbers for Graph Labels" of Graphic Gems. * * @param val Non-negative value. * @param round * @return Niced number */ declare function nice(val: number, round?: boolean): number; /** * This code was copied from "d3.js" * . * See the license statement at the head of this file. * @param ascArr */ declare function quantile(ascArr: number[], p: number): number; declare type IntervalItem = { interval: [number, number]; close: [0 | 1, 0 | 1]; }; /** * Order intervals asc, and split them when overlap. * expect(numberUtil.reformIntervals([ * {interval: [18, 62], close: [1, 1]}, * {interval: [-Infinity, -70], close: [0, 0]}, * {interval: [-70, -26], close: [1, 1]}, * {interval: [-26, 18], close: [1, 1]}, * {interval: [62, 150], close: [1, 1]}, * {interval: [106, 150], close: [1, 1]}, * {interval: [150, Infinity], close: [0, 0]} * ])).toEqual([ * {interval: [-Infinity, -70], close: [0, 0]}, * {interval: [-70, -26], close: [1, 1]}, * {interval: [-26, 18], close: [0, 1]}, * {interval: [18, 62], close: [0, 1]}, * {interval: [62, 150], close: [0, 1]}, * {interval: [150, Infinity], close: [0, 0]} * ]); * @param list, where `close` mean open or close * of the interval, and Infinity can be used. * @return The origin list, which has been reformed. */ declare function reformIntervals(list: IntervalItem[]): IntervalItem[]; /** * [Numeric is defined as]: * `parseFloat(val) == val` * For example: * numeric: * typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity, * and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec) * not-numeric: * null, undefined, [], {}, true, false, 'NaN', NaN, '123ab', * empty string, string with only white-spaces or line-terminal (see es spec), * 0x12, '0x12', '-0x12', 012, '012', '-012', * non-string, ... * * @test See full test cases in `test/ut/spec/util/number.js`. * @return Must be a typeof number. If not numeric, return NaN. */ declare function numericToNumber(val: unknown): number; /** * Definition of "numeric": see `numericToNumber`. */ declare function isNumeric(val: unknown): val is number; declare const number_d_MAX_SAFE_INTEGER: typeof MAX_SAFE_INTEGER; declare const number_d_asc: typeof asc; declare const number_d_getPercentWithPrecision: typeof getPercentWithPrecision; declare const number_d_getPixelPrecision: typeof getPixelPrecision; declare const number_d_getPrecision: typeof getPrecision; declare const number_d_getPrecisionSafe: typeof getPrecisionSafe; declare const number_d_isNumeric: typeof isNumeric; declare const number_d_isRadianAroundZero: typeof isRadianAroundZero; declare const number_d_linearMap: typeof linearMap; declare const number_d_nice: typeof nice; declare const number_d_numericToNumber: typeof numericToNumber; declare const number_d_parseDate: typeof parseDate; declare const number_d_quantile: typeof quantile; declare const number_d_quantity: typeof quantity; declare const number_d_quantityExponent: typeof quantityExponent; declare const number_d_reformIntervals: typeof reformIntervals; declare const number_d_remRadian: typeof remRadian; declare const number_d_round: typeof round; declare namespace number_d { export { number_d_MAX_SAFE_INTEGER as MAX_SAFE_INTEGER, number_d_asc as asc, number_d_getPercentWithPrecision as getPercentWithPrecision, number_d_getPixelPrecision as getPixelPrecision, number_d_getPrecision as getPrecision, number_d_getPrecisionSafe as getPrecisionSafe, number_d_isNumeric as isNumeric, number_d_isRadianAroundZero as isRadianAroundZero, number_d_linearMap as linearMap, number_d_nice as nice, number_d_numericToNumber as numericToNumber, number_d_parseDate as parseDate, number_d_quantile as quantile, number_d_quantity as quantity, number_d_quantityExponent as quantityExponent, number_d_reformIntervals as reformIntervals, number_d_remRadian as remRadian, number_d_round as round }; } declare function format(time: unknown, template: string, isUTC: boolean, lang?: string | Model): string; declare const time_d_format: typeof format; declare namespace time_d { export { time_d_format as format, parseDate as parse }; } declare const graphic_d_Arc: typeof Arc; declare const graphic_d_BezierCurve: typeof BezierCurve; declare const graphic_d_BoundingRect: typeof BoundingRect; declare const graphic_d_Circle: typeof Circle; declare const graphic_d_CompoundPath: typeof CompoundPath; declare const graphic_d_Ellipse: typeof Ellipse; declare const graphic_d_Group: typeof Group; type graphic_d_IncrementalDisplayable = IncrementalDisplayable; declare const graphic_d_IncrementalDisplayable: typeof IncrementalDisplayable; declare const graphic_d_Line: typeof Line; declare const graphic_d_LinearGradient: typeof LinearGradient; declare const graphic_d_Polygon: typeof Polygon; declare const graphic_d_Polyline: typeof Polyline; declare const graphic_d_RadialGradient: typeof RadialGradient; declare const graphic_d_Rect: typeof Rect; declare const graphic_d_Ring: typeof Ring; declare const graphic_d_Sector: typeof Sector; declare const graphic_d_clipPointsByRect: typeof clipPointsByRect; declare const graphic_d_clipRectByRect: typeof clipRectByRect; declare const graphic_d_createIcon: typeof createIcon; declare const graphic_d_extendPath: typeof extendPath; declare const graphic_d_extendShape: typeof extendShape; declare const graphic_d_getShapeClass: typeof getShapeClass; declare const graphic_d_getTransform: typeof getTransform; declare const graphic_d_initProps: typeof initProps; declare const graphic_d_makeImage: typeof makeImage; declare const graphic_d_makePath: typeof makePath; declare const graphic_d_mergePath: typeof mergePath; declare const graphic_d_registerShape: typeof registerShape; declare const graphic_d_resizePath: typeof resizePath; declare const graphic_d_updateProps: typeof updateProps; declare namespace graphic_d { export { graphic_d_Arc as Arc, graphic_d_BezierCurve as BezierCurve, graphic_d_BoundingRect as BoundingRect, graphic_d_Circle as Circle, graphic_d_CompoundPath as CompoundPath, graphic_d_Ellipse as Ellipse, graphic_d_Group as Group, ZRImage as Image, graphic_d_IncrementalDisplayable as IncrementalDisplayable, graphic_d_Line as Line, graphic_d_LinearGradient as LinearGradient, graphic_d_Polygon as Polygon, graphic_d_Polyline as Polyline, graphic_d_RadialGradient as RadialGradient, graphic_d_Rect as Rect, graphic_d_Ring as Ring, graphic_d_Sector as Sector, ZRText as Text, graphic_d_clipPointsByRect as clipPointsByRect, graphic_d_clipRectByRect as clipRectByRect, graphic_d_createIcon as createIcon, graphic_d_extendPath as extendPath, graphic_d_extendShape as extendShape, graphic_d_getShapeClass as getShapeClass, graphic_d_getTransform as getTransform, graphic_d_initProps as initProps, graphic_d_makeImage as makeImage, graphic_d_makePath as makePath, graphic_d_mergePath as mergePath, graphic_d_registerShape as registerShape, graphic_d_resizePath as resizePath, graphic_d_updateProps as updateProps }; } declare const format_d_addCommas: typeof addCommas; declare const format_d_capitalFirst: typeof capitalFirst; declare const format_d_encodeHTML: typeof encodeHTML; declare const format_d_formatTime: typeof formatTime; declare const format_d_formatTpl: typeof formatTpl; declare const format_d_getTextRect: typeof getTextRect; declare const format_d_getTooltipMarker: typeof getTooltipMarker; declare const format_d_normalizeCssArray: typeof normalizeCssArray; declare const format_d_toCamelCase: typeof toCamelCase; declare const format_d_truncateText: typeof truncateText; declare namespace format_d { export { format_d_addCommas as addCommas, format_d_capitalFirst as capitalFirst, format_d_encodeHTML as encodeHTML, format_d_formatTime as formatTime, format_d_formatTpl as formatTpl, format_d_getTextRect as getTextRect, format_d_getTooltipMarker as getTooltipMarker, format_d_normalizeCssArray as normalizeCssArray, format_d_toCamelCase as toCamelCase, format_d_truncateText as truncateText }; } declare const util_d_bind: typeof bind; declare const util_d_clone: typeof clone; declare const util_d_curry: typeof curry; declare const util_d_defaults: typeof defaults; declare const util_d_each: typeof each; declare const util_d_extend: typeof extend; declare const util_d_filter: typeof filter; declare const util_d_indexOf: typeof indexOf; declare const util_d_inherits: typeof inherits; declare const util_d_isArray: typeof isArray; declare const util_d_isFunction: typeof isFunction; declare const util_d_isObject: typeof isObject; declare const util_d_isString: typeof isString; declare const util_d_map: typeof map; declare const util_d_merge: typeof merge; declare const util_d_reduce: typeof reduce; declare namespace util_d { export { util_d_bind as bind, util_d_clone as clone, util_d_curry as curry, util_d_defaults as defaults, util_d_each as each, util_d_extend as extend, util_d_filter as filter, util_d_indexOf as indexOf, util_d_inherits as inherits, util_d_isArray as isArray, util_d_isFunction as isFunction, util_d_isObject as isObject, util_d_isString as isString, util_d_map as map, util_d_merge as merge, util_d_reduce as reduce }; } declare class Browser { firefox: boolean; ie: boolean; edge: boolean; newEdge: boolean; weChat: boolean; version: string | number; } declare class Env { browser: Browser; node: boolean; wxa: boolean; worker: boolean; svgSupported: boolean; touchEventsSupported: boolean; pointerEventsSupported: boolean; domSupported: boolean; transformSupported: boolean; transform3dSupported: boolean; hasGlobalWindow: boolean; } declare const env: Env; declare function brushSingle(ctx: CanvasRenderingContext2D, el: Displayable): void; declare function extendComponentModel(proto: object): ComponentModel; declare function extendComponentView(proto: object): ChartView; declare function extendSeriesModel(proto: object): SeriesModel; declare function extendChartView(proto: object): ChartView; declare type Dependencies = { grid: XAXisOption | YAXisOption | AxisPointerOption; polar: AngleAxisOption | RadiusAxisOption; parallel: ParallelAxisOption; }; declare type DependenciesKeys = keyof Dependencies & string; declare type Arrayable = T | T[]; declare type GetMainType = Exclude; declare type ExtractComponentOption = OptionUnion extends { mainType?: ExtractMainType; } ? OptionUnion : never; declare type GetDependency = { [key in GetMainType]?: Arrayable>; }; declare type GetDependencies = GetDependency]>; declare type ComposeUnitOption = CheckMainType> & Omit & { [key in GetMainType]?: Arrayable>; } & GetDependencies>; declare type CheckMainType = string extends OptionUnionMainType ? never : {}; declare type ComposeOption = ComposeUnitOption & { baseOption?: ComposeUnitOption; options?: ComposeUnitOption[]; }; export { AngleAxisOption as AngleAxisComponentOption, AxisPointerOption as AxisPointerComponentOption, ChartView, ComponentModel, type ComposeOption, ECBasicOption as EChartsCoreOption, SeriesData as List, Model, RadiusAxisOption as RadiusAxisComponentOption, SeriesModel, XAXisOption as XAXisComponentOption, YAXisOption as YAXisComponentOption, color_d as color, env, extendChartView, extendComponentModel, extendComponentView, extendSeriesModel, format_d as format, graphic_d as graphic, helper_d as helper, brushSingle as innerDrawElementOnCanvas, number_d as number, parseGeoJSON, parseGeoJSON as parseGeoJson, setPlatformAPI, throttle, time_d as time, util_d as util };