mirror of
https://github.com/FlipsideCrypto/DefinitelyTyped.git
synced 2026-02-06 10:56:53 +00:00
937 lines
53 KiB
TypeScript
937 lines
53 KiB
TypeScript
// Type definitions for d3JS d3-zoom module 1.7
|
||
// Project: https://github.com/d3/d3-zoom/, https://d3js.org/d3-zoom
|
||
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
|
||
// Alex Ford <https://github.com/gustavderdrache>
|
||
// Boris Yankov <https://github.com/borisyankov>
|
||
// denisname <https://github.com/denisname>
|
||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||
// TypeScript Version: 2.3
|
||
|
||
// Last module patch version validated against: 1.7.0
|
||
|
||
import { ArrayLike, Selection, TransitionLike, ValueFn } from 'd3-selection';
|
||
import { ZoomView, ZoomInterpolator } from 'd3-interpolate';
|
||
|
||
// --------------------------------------------------------------------------
|
||
// Shared Type Definitions and Interfaces
|
||
// --------------------------------------------------------------------------
|
||
|
||
/**
|
||
* ZoomedElementBaseType serves as an alias for the 'minimal' data type which can be selected
|
||
* without 'd3-zoom' (and related code in 'd3-selection') trying to use properties internally which would otherwise not
|
||
* be supported.
|
||
*/
|
||
export type ZoomedElementBaseType = Element;
|
||
|
||
/**
|
||
* Minimal interface for a continuous scale.
|
||
* This interface is used as a minimum contract for scale objects
|
||
* that can be passed into zoomTransform methods rescaleX and rescaleY
|
||
*/
|
||
export interface ZoomScale {
|
||
domain(): number[] | Date[];
|
||
domain(domain: Array<Date | number>): this;
|
||
range(): number[];
|
||
range(range: number[]): this;
|
||
copy(): ZoomScale;
|
||
invert(value: number): number | Date;
|
||
}
|
||
|
||
// --------------------------------------------------------------------------
|
||
// Zoom Behavior
|
||
// --------------------------------------------------------------------------
|
||
|
||
/**
|
||
* A D3 Zoom Behavior
|
||
*
|
||
* The first generic refers to the type of reference element to which the zoom behavior is attached.
|
||
* The second generic refers to the type of the datum of the reference element.
|
||
*/
|
||
export interface ZoomBehavior<ZoomRefElement extends ZoomedElementBaseType, Datum> extends Function {
|
||
/**
|
||
* Applies this zoom behavior to the specified selection, binding the necessary event listeners to
|
||
* allow panning and zooming, and initializing the zoom transform on each selected element to the identity transform if not already defined. This function is typically not invoked directly,
|
||
* and is instead invoked via selection.call.
|
||
*
|
||
* For details see: {@link https://github.com/d3/d3-zoom#_zoom}
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param args Optional arguments to be passed in.
|
||
*/
|
||
(selection: Selection<ZoomRefElement, Datum, any, any>, ...args: any[]): void;
|
||
/**
|
||
* Sets the current zoom transform of the selected elements to the specified transform,
|
||
* instantaneously emitting start, zoom and end events.
|
||
*
|
||
* This method requires that you specify the new zoom transform completely,
|
||
* and does not enforce the defined scale extent and translate extent, if any.
|
||
* To derive a new transform from the existing transform, and to enforce the scale and translate extents,
|
||
* see the convenience methods zoom.translateBy, zoom.scaleBy and zoom.scaleTo.
|
||
*
|
||
* This function is typically not invoked directly, and is instead invoked via selection.call.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param transform A zoom transform object.
|
||
*/
|
||
transform(selection: Selection<ZoomRefElement, Datum, any, any>, transform: ZoomTransform): void;
|
||
/**
|
||
* Sets the current zoom transform of the selected elements to the transform returned by the specified
|
||
* zoom transform factory function evaluated for each element, instantaneously emitting start, zoom and end events.
|
||
*
|
||
* This method requires that you specify the new zoom transform completely,
|
||
* and does not enforce the defined scale extent and translate extent, if any.
|
||
* To derive a new transform from the existing transform, and to enforce the scale and translate extents,
|
||
* see the convenience methods zoom.translateBy, zoom.scaleBy and zoom.scaleTo.
|
||
*
|
||
* This function is typically not invoked directly, and is instead invoked via selection.call.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param transform A zoom transform factory function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element. The function returns a zoom transform object.
|
||
*/
|
||
transform(selection: Selection<ZoomRefElement, Datum, any, any>, transform: ValueFn<ZoomRefElement, Datum, ZoomTransform>): void;
|
||
/**
|
||
* Sets the current zoom transform of the transitioning elements to the specified transform.
|
||
* It defines a “zoom” tween to the specified transform using d3.interpolateZoom,
|
||
* emitting a start event when the transition starts, zoom events for each tick of the transition,
|
||
* and then an end event when the transition ends (or is interrupted).
|
||
*
|
||
* This method requires that you specify the new zoom transform completely,
|
||
* and does not enforce the defined scale extent and translate extent, if any.
|
||
* To derive a new transform from the existing transform, and to enforce the scale and translate extents,
|
||
* see the convenience methods zoom.translateBy, zoom.scaleBy and zoom.scaleTo.
|
||
*
|
||
* This function is typically not invoked directly, and is instead invoked via selection.call.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param transform A zoom transform object.
|
||
*/
|
||
transform(transition: TransitionLike<ZoomRefElement, Datum>, transform: ZoomTransform): void;
|
||
/**
|
||
* Sets the current zoom transform of the transitioning elements to the transform returned by the specified
|
||
* zoom transform factory function evaluated for each element.
|
||
* It defines a “zoom” tween to the specified transform using d3.interpolateZoom,
|
||
* emitting a start event when the transition starts, zoom events for each tick of the transition,
|
||
* and then an end event when the transition ends (or is interrupted).
|
||
*
|
||
* This method requires that you specify the new zoom transform completely,
|
||
* and does not enforce the defined scale extent and translate extent, if any.
|
||
* To derive a new transform from the existing transform, and to enforce the scale and translate extents,
|
||
* see the convenience methods zoom.translateBy, zoom.scaleBy and zoom.scaleTo.
|
||
*
|
||
* This function is typically not invoked directly, and is instead invoked via selection.call.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param transform A zoom transform factory function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element. The function returns a zoom transform object.
|
||
*/
|
||
transform(transition: TransitionLike<ZoomRefElement, Datum>, transform: ValueFn<ZoomRefElement, Datum, ZoomTransform>): void;
|
||
|
||
/**
|
||
* Translates the current zoom transform of the selected elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x Amount of translation in x-direction.
|
||
* @param y Amount of translation in y-direction.
|
||
*/
|
||
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: number, y: number): void;
|
||
/**
|
||
* Translates the current zoom transform of the selected elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in x-direction.
|
||
* @param y Amount of translation in y-direction.
|
||
*/
|
||
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: ValueFn<ZoomRefElement, Datum, number>, y: number): void;
|
||
/**
|
||
* Translates the current zoom transform of the selected elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x Amount of translation in x-direction.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in y-direction.
|
||
*/
|
||
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: number, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Translates the current zoom transform of the selected elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in x-direction.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in y-direction.
|
||
*/
|
||
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: ValueFn<ZoomRefElement, Datum, number>, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x Amount of translation in x-direction.
|
||
* @param y Amount of translation in y-direction.
|
||
*/
|
||
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: number, y: number): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in x-direction.
|
||
* @param y Amount of translation in y-direction.
|
||
*/
|
||
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: ValueFn<ZoomRefElement, Datum, number>, y: number): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x Amount of translation in x-direction.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in y-direction.
|
||
*/
|
||
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: number, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements by x and y,
|
||
* such that the new t(x1) = t(x0) + kx and t(y1) = t(y0) + ky.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in x-direction.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the amount of translation in y-direction.
|
||
*/
|
||
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: ValueFn<ZoomRefElement, Datum, number>, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
|
||
/**
|
||
* Translates the current zoom transform of the selected elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x Target x-position of translation.
|
||
* @param y Target y-position of translation.
|
||
*/
|
||
translateTo(selection: Selection<ZoomRefElement, Datum, any, any>, x: number, y: number): void;
|
||
/**
|
||
* Translates the current zoom transform of the selected elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target x-position of translation.
|
||
* @param y Target y-position of translation.
|
||
*/
|
||
translateTo(selection: Selection<ZoomRefElement, Datum, any, any>, x: ValueFn<ZoomRefElement, Datum, number>, y: number): void;
|
||
/**
|
||
* Translates the current zoom transform of the selected elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x Target x-position of translation.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target y-position of translation.
|
||
*/
|
||
translateTo(selection: Selection<ZoomRefElement, Datum, any, any>, x: number, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Translates the current zoom transform of the selected elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target x-position of translation.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target y-position of translation.
|
||
*/
|
||
translateTo(selection: Selection<ZoomRefElement, Datum, any, any>, x: ValueFn<ZoomRefElement, Datum, number>, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x Target x-position of translation.
|
||
* @param y Target y-position of translation.
|
||
*/
|
||
translateTo(transition: TransitionLike<ZoomRefElement, Datum>, x: number, y: number): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target x-position of translation.
|
||
* @param y Target y-position of translation.
|
||
*/
|
||
translateTo(transition: TransitionLike<ZoomRefElement, Datum>, x: ValueFn<ZoomRefElement, Datum, number>, y: number): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided as a constant for all elements.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x Target x-position of translation.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target y-position of translation.
|
||
*/
|
||
translateTo(transition: TransitionLike<ZoomRefElement, Datum>, x: number, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Defines a “zoom” tween translating the current transform for the transitioning elements such that the specified position ⟨x,y⟩ appears at the center of the viewport extent.
|
||
* The new tx = cx - kx and ty = cy - ky, where ⟨cx,cy⟩ is the center.
|
||
*
|
||
* x is provided by a value function evaluated for each element in the selection.
|
||
* y is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param x A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target x-position of translation.
|
||
* @param y A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the target y-position of translation.
|
||
*/
|
||
translateTo(transition: TransitionLike<ZoomRefElement, Datum>, x: ValueFn<ZoomRefElement, Datum, number>, y: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
|
||
/**
|
||
* Scales the current zoom transform of the selected elements by k, such that the new k(1) = k(0)k.
|
||
*
|
||
* k is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param k Scale factor.
|
||
*/
|
||
scaleBy(selection: Selection<ZoomRefElement, Datum, any, any>, k: number): void;
|
||
/**
|
||
* Scales the current zoom transform of the selected elements by k, such that the new k(1) = k(0)k.
|
||
*
|
||
* k is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param k A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the scale factor.
|
||
*/
|
||
scaleBy(selection: Selection<ZoomRefElement, Datum, any, any>, k: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Defines a “zoom” tween translating scaling the current transform of the selected elements by k, such that the new k(1) = k(0)k.
|
||
*
|
||
* k is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param k Scale factor.
|
||
*/
|
||
scaleBy(transition: TransitionLike<ZoomRefElement, Datum>, k: number): void;
|
||
/**
|
||
* Defines a “zoom” tween translating scaling the current transform of the selected elements by k, such that the new k(1) = k(0)k.
|
||
*
|
||
* k is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param k A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the scale factor.
|
||
*/
|
||
scaleBy(transition: TransitionLike<ZoomRefElement, Datum>, k: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
|
||
/**
|
||
* Scales the current zoom transform of the selected elements to k, such that the new k(1) = k.
|
||
*
|
||
* k is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param k New scale.
|
||
* @param p The reference point p does move. If p is not specified, it defaults to the center of the viewport extent.
|
||
*/
|
||
scaleTo(selection: Selection<ZoomRefElement, Datum, any, any>, k: number, p?: number[]): void;
|
||
/**
|
||
* Scales the current zoom transform of the selected elements to k, such that the new k(1) = k.
|
||
*
|
||
* k is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param selection A D3 selection of elements.
|
||
* @param k A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the new scale.
|
||
*/
|
||
scaleTo(selection: Selection<ZoomRefElement, Datum, any, any>, k: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
/**
|
||
* Defines a “zoom” tween translating scaling the current transform of the selected elements to k, such that the new k(1) = k.
|
||
*
|
||
* k is provided as a constant for all elements.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param k New scale.
|
||
*/
|
||
scaleTo(transition: TransitionLike<ZoomRefElement, Datum>, k: number): void;
|
||
/**
|
||
* Defines a “zoom” tween translating scaling the current transform of the selected elements to k, such that the new k(1) = k.
|
||
*
|
||
* k is provided by a value function evaluated for each element in the selection.
|
||
*
|
||
* This method is a convenience method for zoom.transform.
|
||
* In contrast to zoom.transform, however, it is subject to the constraints imposed by zoom.extent, zoom.scaleExtent, and zoom.translateExtent.
|
||
*
|
||
* @param transition A D3 transition on elements.
|
||
* @param k A value function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the new scale.
|
||
*/
|
||
scaleTo(transition: TransitionLike<ZoomRefElement, Datum>, k: ValueFn<ZoomRefElement, Datum, number>): void;
|
||
|
||
/**
|
||
* Returns the current constraint function.
|
||
* The default implementation attempts to ensure that the viewport extent does not go outside the translate extent.
|
||
*/
|
||
constrain(): (transform: ZoomTransform, extent: [[number, number], [number, number]], translateExtent: [[number, number], [number, number]]) => ZoomTransform;
|
||
/**
|
||
* Sets the transform constraint function to the specified function and returns the zoom behavior.
|
||
*
|
||
* @param constraint A constraint function which returns a transform given the current transform, viewport extent and translate extent.
|
||
* The default implementation attempts to ensure that the viewport extent does not go outside the translate extent.
|
||
*/
|
||
constrain(constraint: ((transform: ZoomTransform, extent: [[number, number], [number, number]], translateExtent: [[number, number], [number, number]]) => ZoomTransform)): this;
|
||
|
||
/**
|
||
* Returns the current filter function.
|
||
*/
|
||
filter(): ValueFn<ZoomRefElement, Datum, boolean>;
|
||
/**
|
||
* Sets the filter to the specified filter function and returns the zoom behavior.
|
||
* The filter function is invoked in the zoom initiating event handlers of each element to which the zoom behavior was applied.
|
||
*
|
||
* If the filter returns falsey, the initiating event is ignored and no zoom gesture is started.
|
||
* Thus, the filter determines which input events are ignored. The default filter ignores mousedown events on secondary buttons,
|
||
* since those buttons are typically intended for other purposes, such as the context menu.
|
||
*
|
||
* @param filterFn A filter function which is invoked in the zoom initiating event handlers of each element to which the zoom behavior was applied,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element. The function returns a boolean value.
|
||
*/
|
||
filter(filterFn: ValueFn<ZoomRefElement, Datum, boolean>): this;
|
||
|
||
/**
|
||
* Returns the current touch support detector, which defaults to a function returning true,
|
||
* if the "ontouchstart" event is supported on the current element.
|
||
*/
|
||
touchable(): ValueFn<ZoomRefElement, Datum, boolean>;
|
||
/**
|
||
* Sets the touch support detector to the specified boolean value and returns the zoom behavior.
|
||
*
|
||
* Touch event listeners are only registered if the detector returns truthy for the corresponding element when the zoom behavior is applied.
|
||
* The default detector works well for most browsers that are capable of touch input, but not all; Chrome’s mobile device emulator, for example,
|
||
* fails detection.
|
||
*
|
||
* @param touchable A boolean value. true when touch event listeners should be applied to the corresponding element, otherwise false.
|
||
*/
|
||
touchable(touchable: boolean): this;
|
||
/**
|
||
* Sets the touch support detector to the specified function and returns the zoom behavior.
|
||
*
|
||
* Touch event listeners are only registered if the detector returns truthy for the corresponding element when the zoom behavior is applied.
|
||
* The default detector works well for most browsers that are capable of touch input, but not all; Chrome’s mobile device emulator, for example,
|
||
* fails detection.
|
||
*
|
||
* @param touchable A touch support detector function, which returns true when touch event listeners should be applied to the corresponding element.
|
||
* The function is evaluated for each selected element to which the zoom behavior was applied, in order, being passed the current datum (d),
|
||
* the current index (i), and the current group (nodes), with this as the current DOM element. The function returns a boolean value.
|
||
*/
|
||
touchable(touchable: ValueFn<ZoomRefElement, Datum, boolean>): this;
|
||
|
||
/**
|
||
* Returns the current wheelDelta function.
|
||
*/
|
||
wheelDelta(): ValueFn<ZoomRefElement, Datum, number>;
|
||
/**
|
||
* Sets the wheel delta function to the specified function and returns the zoom behavior. The wheel delta function which is invoked in the wheel event handler
|
||
* of each element to which the zoom behavior was applied.
|
||
* The value Δ returned by the wheel delta function determines the amount of scaling applied in response to a WheelEvent.
|
||
* The scale factor transform.k is multiplied by 2Δ; for example, a Δ of +1 doubles the scale factor, Δ of -1 halves the scale factor.
|
||
*
|
||
* @param delta Wheel delta function which is invoked in the wheel event handler of each element to which the zoom behavior was applied,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element. The function returns a numeric value.
|
||
*/
|
||
wheelDelta(delta: ValueFn<ZoomRefElement, Datum, number>): this;
|
||
|
||
/**
|
||
* Return the current extent accessor, which defaults to [[0, 0], [width, height]] where width is the client width of the element and height is its client height;
|
||
* for SVG elements, the nearest ancestor SVG element’s width and height is used. In this case,
|
||
* the owner SVG element must have defined width and height attributes rather than (for example) relying on CSS properties or the viewBox attribute;
|
||
* SVG provides no programmatic method for retrieving the initial viewport size. Alternatively, consider using element.getBoundingClientRect.
|
||
* (In Firefox, element.clientWidth and element.clientHeight is zero for SVG elements!)
|
||
*/
|
||
extent(): ValueFn<ZoomRefElement, Datum, [[number, number], [number, number]]>;
|
||
/**
|
||
* Set the viewport extent to the specified array of points [[x0, y0], [x1, y1]],
|
||
* where [x0, y0] is the top-left corner of the viewport and [x1, y1] is the bottom-right corner of the viewport,
|
||
* and return this zoom behavior.
|
||
*
|
||
* The viewport extent affects several functions: the center of the viewport remains fixed during changes by zoom.scaleBy and zoom.scaleTo;
|
||
* the viewport center and dimensions affect the path chosen by d3.interpolateZoom; and the viewport extent is needed to enforce the optional translate extent.
|
||
*
|
||
* @param extent An extent specified as an array of two coordinates.
|
||
*/
|
||
extent(extent: [[number, number], [number, number]]): this;
|
||
/**
|
||
* Set the viewport extent to the array of points [[x0, y0], [x1, y1]] returned by the
|
||
* extent accessor function, and return this zoom behavior.
|
||
* The extent accessor function is evaluated for each element.
|
||
*
|
||
* [x0, y0] is the top-left corner of the viewport and [x1, y1] is the bottom-right corner of the viewport.
|
||
*
|
||
* The viewport extent affects several functions: the center of the viewport remains fixed during changes by zoom.scaleBy and zoom.scaleTo;
|
||
* the viewport center and dimensions affect the path chosen by d3.interpolateZoom; and the viewport extent is needed to enforce the optional translate extent.
|
||
*
|
||
* The default is [[0, 0], [width, height]] where width is the client width of the element and height is its client height;
|
||
* for SVG elements, the nearest ancestor SVG element’s width and height is used.
|
||
* In this case, the owner SVG element must have defined width and height attributes rather than (for example) relying on CSS properties or the viewBox attribute;
|
||
* SVG provides no programmatic method for retrieving the initial viewport size. Alternatively, consider using element.getBoundingClientRect.
|
||
* (In Firefox, element.clientWidth and element.clientHeight is zero for SVG elements!)
|
||
*
|
||
* @extent An extent accessor function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.The function returns the extent array.
|
||
*/
|
||
extent(extent: ValueFn<ZoomRefElement, Datum, [[number, number], [number, number]]>): this;
|
||
|
||
/**
|
||
* Return the current scale extent.
|
||
*/
|
||
scaleExtent(): [number, number];
|
||
/**
|
||
* Set the scale extent to the specified array of numbers [k0, k1] where k0 is the minimum allowed scale factor and k1 is the maximum allowed scale factor,
|
||
* and return this zoom behavior.
|
||
*
|
||
* The scale extent restricts zooming in and out. It is enforced on interaction and when using zoom.scaleBy, zoom.scaleTo and zoom.translateBy;
|
||
* however, it is not enforced when using zoom.transform to set the transform explicitly.
|
||
*
|
||
* The default scale extent is [0, infinity].
|
||
*
|
||
* If the user tries to zoom by wheeling when already at the corresponding limit of the scale extent, the wheel events will be ignored and not initiate a zoom gesture.
|
||
* This allows the user to scroll down past a zoomable area after zooming in, or to scroll up after zooming out.
|
||
* If you would prefer to always prevent scrolling on wheel input regardless of the scale extent, register a wheel event listener to prevent the browser default behavior
|
||
*
|
||
* @param extent A scale extent array of two numbers representing the scale boundaries.
|
||
*/
|
||
scaleExtent(extent: [number, number]): this;
|
||
|
||
/**
|
||
* Return the current translate extent.
|
||
*/
|
||
translateExtent(): [[number, number], [number, number]];
|
||
/**
|
||
* Set the translate extent to the specified array of points [[x0, y0], [x1, y1]], where [x0, y0] is the top-left corner of the world and [x1, y1]
|
||
* is the bottom-right corner of the world, and return this zoom behavior.
|
||
*
|
||
* The translate extent restricts panning, and may cause translation on zoom out. It is enforced on interaction and when using zoom.scaleBy, zoom.scaleTo and zoom.translateBy;
|
||
* however, it is not enforced when using zoom.transform to set the transform explicitly.
|
||
*
|
||
* The default scale extent is [[-infinity, infinity], [-infinity, infinity]].
|
||
*
|
||
* @param extent A translate extent array, i.e. an array of two arrays, each representing a point.
|
||
*/
|
||
translateExtent(extent: [[number, number], [number, number]]): this;
|
||
|
||
/**
|
||
* Return the current click distance threshold, which defaults to zero.
|
||
*/
|
||
clickDistance(): number;
|
||
/**
|
||
* Set the maximum distance that the mouse can move between mousedown and mouseup that will trigger
|
||
* a subsequent click event. If at any point between mousedown and mouseup the mouse is greater than or equal to
|
||
* distance from its position on mousedown, the click event following mouseup will be suppressed.
|
||
*
|
||
* @param distance The distance threshold between mousedown and mouseup measured in client coordinates (event.clientX and event.clientY).
|
||
* The default is zero.
|
||
*/
|
||
clickDistance(distance: number): this;
|
||
|
||
/**
|
||
* Get the duration for zoom transitions on double-click and double-tap in milliseconds.
|
||
*/
|
||
duration(): number;
|
||
/**
|
||
* Set the duration for zoom transitions on double-click and double-tap to the specified number of milliseconds and returns the zoom behavior.
|
||
*
|
||
* To disable double-click and double-tap transitions, you can remove the zoom behavior’s dblclick event listener after applying the zoom behavior to the selection.
|
||
*
|
||
* @param Duration in milliseconds.
|
||
*/
|
||
duration(duration: number): this;
|
||
|
||
/**
|
||
* Returns the current interpolation factory, which defaults to d3.interpolateZoom to implement smooth zooming.
|
||
*/
|
||
interpolate<InterpolationFactory extends (a: ZoomView, b: ZoomView) => ((t: number) => ZoomView)>(): InterpolationFactory;
|
||
|
||
/**
|
||
* Sets the interpolation factory for zoom transitions to the specified function.
|
||
* Use the default d3.interpolateZoom to implement smooth zooming.
|
||
* To apply direct interpolation between two views, try d3.interpolate instead.
|
||
*
|
||
* Each view is defined as an array of three numbers: cx, cy and width. The first two coordinates cx, cy represent the center of the viewport;
|
||
* the last coordinate width represents the size of the viewport.
|
||
*
|
||
* @param interpolatorFactory An interpolator factory to be used to generate interpolators between zooms for transitions.
|
||
*/
|
||
interpolate(interpolatorFactory: (a: ZoomView, b: ZoomView) => ((t: number) => ZoomView)): this;
|
||
|
||
/**
|
||
* Return the first currently-assigned listener matching the specified typenames, if any.
|
||
*
|
||
* @param typenames The typenames is a string containing one or more typename separated by whitespace.
|
||
* Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
|
||
* the name allows multiple listeners to be registered for the same type. The type must be one of the following:
|
||
* start (after zooming begins [such as mousedown]), zoom (after a change to the zoom transform [such as mousemove], or
|
||
* end (after an active pointer becomes inactive [such as on mouseup].)
|
||
*/
|
||
on(typenames: string): ValueFn<ZoomRefElement, Datum, void> | undefined;
|
||
/**
|
||
* Remove the current event listeners for the specified typenames, if any, return the drag behavior.
|
||
*
|
||
* @param typenames The typenames is a string containing one or more typename separated by whitespace.
|
||
* Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
|
||
* the name allows multiple listeners to be registered for the same type. The type must be one of the following:
|
||
* start (after zooming begins [such as mousedown]), zoom (after a change to the zoom transform [such as mousemove], or
|
||
* end (after an active pointer becomes inactive [such as on mouseup].)
|
||
* @param listener Use null to remove the listener.
|
||
*/
|
||
on(typenames: string, listener: null): this;
|
||
/**
|
||
* Set the event listener for the specified typenames and return the zoom behavior.
|
||
* If an event listener was already registered for the same type and name,
|
||
* the existing listener is removed before the new listener is added.
|
||
* When a specified event is dispatched, each listener will be invoked with the same context and arguments as selection.on listeners.
|
||
*
|
||
*
|
||
* @param typenames The typenames is a string containing one or more typename separated by whitespace.
|
||
* Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
|
||
* the name allows multiple listeners to be registered for the same type. The type must be one of the following:
|
||
* start (after zooming begins [such as mousedown]), zoom (after a change to the zoom transform [such as mousemove], or
|
||
* end (after an active pointer becomes inactive [such as on mouseup].)
|
||
* @param listener An event listener function which is evaluated for each selected element,
|
||
* in order, being passed the current datum (d), the current index (i), and the current group (nodes),
|
||
* with this as the current DOM element.
|
||
*/
|
||
on(typenames: string, listener: ValueFn<ZoomRefElement, Datum, void>): this;
|
||
}
|
||
|
||
/**
|
||
* Creates a new zoom behavior. The returned behavior, zoom, is both an object and a function,
|
||
* and is typically applied to selected elements via selection.call.
|
||
*
|
||
* The first generic refers to the type of reference element to which the zoom behavior is attached.
|
||
* The second generic refers to the type of the datum of the reference element.
|
||
*/
|
||
export function zoom<ZoomRefElement extends ZoomedElementBaseType, Datum>(): ZoomBehavior<ZoomRefElement, Datum>;
|
||
|
||
// --------------------------------------------------------------------------
|
||
// Zoom Event
|
||
// --------------------------------------------------------------------------
|
||
|
||
/**
|
||
* A D3 Zoom Event
|
||
*
|
||
* The first generic refers to the type of reference element to which the zoom behavior is attached.
|
||
* The second generic refers to the type of the datum of the reference element.
|
||
*/
|
||
export interface D3ZoomEvent<ZoomRefElement extends ZoomedElementBaseType, Datum> {
|
||
/**
|
||
* The ZoomBehavior associated with the event
|
||
*/
|
||
target: ZoomBehavior<ZoomRefElement, Datum>;
|
||
/**
|
||
* The event type for the zoom event
|
||
*/
|
||
type: 'start' | 'zoom' | 'end' | string; // Leave failsafe string type for cases like 'zoom.foo'
|
||
/**
|
||
* The current zoom transform
|
||
*/
|
||
transform: ZoomTransform;
|
||
/**
|
||
* The underlying input event, such as mousemove or touchmove.
|
||
*/
|
||
sourceEvent: any;
|
||
}
|
||
|
||
// --------------------------------------------------------------------------
|
||
// Zoom Transforms
|
||
// --------------------------------------------------------------------------
|
||
|
||
/**
|
||
* A zoom transform
|
||
*
|
||
* The zoom behavior stores the zoom state on the element to which the zoom behavior was applied, not on the zoom behavior itself.
|
||
* This is because the zoom behavior can be applied to many elements simultaneously, and each element can be zoomed independently.
|
||
* The zoom state can change either on user interaction or programmatically via zoom.transform.
|
||
*
|
||
* To retrieve the zoom state, use event.transform on the current zoom event within a zoom event listener (see zoom.on), or use d3.zoomTransform for a given node.
|
||
* The latter is particularly useful for modifying the zoom state programmatically,
|
||
* say to implement buttons for zooming in and out.
|
||
*
|
||
* For details see {@link https://github.com/d3/d3-zoom#zoom-transforms}
|
||
*/
|
||
export interface ZoomTransform {
|
||
/**
|
||
* The translation amount tx along the x-axis.
|
||
* This property should be considered read-only; instead of mutating a transform,
|
||
* use transform.scale and transform.translate to derive a new transform.
|
||
* Also see zoom.scaleBy, zoom.scaleTo and zoom.translateBy for convenience methods on the zoom behavior.
|
||
*/
|
||
readonly x: number;
|
||
|
||
/**
|
||
* The translation amount ty along the y-axis
|
||
* This property should be considered read-only; instead of mutating a transform,
|
||
* use transform.scale and transform.translate to derive a new transform.
|
||
* Also see zoom.scaleBy, zoom.scaleTo and zoom.translateBy for convenience methods on the zoom behavior.
|
||
*/
|
||
readonly y: number;
|
||
|
||
/**
|
||
* The scale factor k.
|
||
* This property should be considered read-only; instead of mutating a transform,
|
||
* use transform.scale and transform.translate to derive a new transform.
|
||
* Also see zoom.scaleBy, zoom.scaleTo and zoom.translateBy for convenience methods on the zoom behavior.
|
||
*/
|
||
readonly k: number;
|
||
|
||
/**
|
||
* Return the transformation of the specified point which is a two-element array of numbers [x, y].
|
||
* The returned point is equal to [xk + tx, yk + ty].
|
||
*
|
||
* @param point Point coordinates [x, y]
|
||
*/
|
||
apply(point: [number, number]): [number, number];
|
||
|
||
/**
|
||
* Return the transformation of the specified x-coordinate, xk + tx.
|
||
*
|
||
* @param x Value of x-coordinate.
|
||
*/
|
||
applyX(x: number): number;
|
||
|
||
/**
|
||
* Return the transformation of the specified y-coordinate, yk + ty.
|
||
*
|
||
* @param y Value of y-coordinate.
|
||
*/
|
||
applyY(y: number): number;
|
||
|
||
/**
|
||
* Return the inverse transformation of the specified point which is a two-element array of numbers [x, y].
|
||
* The returned point is equal to [(x - tx) / k, (y - ty) / k].
|
||
*
|
||
* @param point Point coordinates [x, y]
|
||
*/
|
||
invert(point: [number, number]): [number, number];
|
||
|
||
/**
|
||
* Return the inverse transformation of the specified x-coordinate, (x - tx) / k.
|
||
*
|
||
* @param x Value of x-coordinate.
|
||
*/
|
||
invertX(x: number): number;
|
||
|
||
/**
|
||
* Return the inverse transformation of the specified y-coordinate, (y - ty) / k.
|
||
*
|
||
* @param y Value of y-coordinate.
|
||
*/
|
||
invertY(y: number): number;
|
||
|
||
/**
|
||
* Returns a copy of the continuous scale x whose domain is transformed.
|
||
* This is implemented by first applying the inverse x-transform on the scale’s range,
|
||
* and then applying the inverse scale to compute the corresponding domain
|
||
*
|
||
* The scale x must use d3.interpolateNumber; do not use continuous.rangeRound as this
|
||
* reduces the accuracy of continuous.invert and can lead to an inaccurate rescaled domain.
|
||
* This method does not modify the input scale x; x thus represents the untransformed scale,
|
||
* while the returned scale represents its transformed view.
|
||
*
|
||
* @param xScale A continuous scale for x-dimension.
|
||
*/
|
||
rescaleX<S extends ZoomScale>(xScale: S): S;
|
||
|
||
/**
|
||
* Returns a copy of the continuous scale y whose domain is transformed.
|
||
* This is implemented by first applying the inverse y-transform on the scale’s range,
|
||
* and then applying the inverse scale to compute the corresponding domain
|
||
*
|
||
* The scale y must use d3.interpolateNumber; do not use continuous.rangeRound as this
|
||
* reduces the accuracy of continuous.invert and can lead to an inaccurate rescaled domain.
|
||
* This method does not modify the input scale x; x thus represents the untransformed scale,
|
||
* while the returned scale represents its transformed view.
|
||
*
|
||
* @param yScale A continuous scale for y-dimension.
|
||
*/
|
||
rescaleY<S extends ZoomScale>(yScale: S): S;
|
||
|
||
/**
|
||
* Return a transform whose scale k1 is equal to k0 × k, where k0 is this transform’s scale.
|
||
*
|
||
* @param k A scale factor.
|
||
*/
|
||
scale(k: number): ZoomTransform;
|
||
|
||
/**
|
||
* Return a string representing the SVG transform corresponding to this transform.
|
||
*/
|
||
toString(): string;
|
||
|
||
/**
|
||
* Return a transform whose translation tx1 and ty1 is equal to tx0 + x and ty0 + y,
|
||
* where tx0 and ty0 is this transform’s translation.
|
||
*
|
||
* @param x Amount of translation in x-direction.
|
||
* @param y Amount of translation in y-direction.
|
||
*/
|
||
translate(x: number, y: number): ZoomTransform;
|
||
}
|
||
|
||
/**
|
||
* Returns the current transform for the specified node. Note that node should typically be a DOM element, and not a selection.
|
||
* (A selection may consist of multiple nodes, in different states, and this function only returns a single transform.) If you have a selection, call selection.node first.
|
||
* In the context of an event listener, the node is typically the element that received the input event (which should be equal to event.transform), "this".
|
||
* Internally, an element’s transform is stored as element.__zoom; however, you should use this method rather than accessing it directly.
|
||
* If the given node has no defined transform, returns the identity transformation.
|
||
* The returned transform represents a two-dimensional transformation matrix
|
||
*
|
||
* For details see {@link https://github.com/d3/d3-zoom#zoom-transforms}
|
||
*
|
||
* @param node An element for which to retrieve its current zoom transform.
|
||
*/
|
||
export function zoomTransform(node: ZoomedElementBaseType): ZoomTransform;
|
||
|
||
/**
|
||
* The identity transform, where k = 1, tx = ty = 0.
|
||
*/
|
||
export const zoomIdentity: ZoomTransform;
|