mirror of
https://github.com/svgdotjs/svg.js.git
synced 2024-08-30 18:00:08 +02:00
1017 lines
30 KiB
TypeScript
1017 lines
30 KiB
TypeScript
export = svgjs;
|
|
export as namespace svgjs;
|
|
|
|
declare var svgjs: svgjs.Library;
|
|
|
|
// todo add SVG.FX
|
|
declare namespace svgjs {
|
|
export interface Library {
|
|
(id: string): Doc;
|
|
(domElement: HTMLElement): Doc;
|
|
ns: string;
|
|
xmlns: string;
|
|
xlink: string;
|
|
svgjs: string;
|
|
supported: boolean;
|
|
|
|
did: number;
|
|
eid(name: string): string;
|
|
|
|
create(name: string): any;
|
|
extend(parent: Object, obj: Object): void;
|
|
invent(config: Object): any;
|
|
adopt(node: HTMLElement): Element;
|
|
prepare(element: HTMLElement): void;
|
|
}
|
|
interface LinkedHTMLElement extends HTMLElement {
|
|
instance: Element;
|
|
}
|
|
|
|
// arrange.js
|
|
interface Element {
|
|
front(): this;
|
|
back(): this;
|
|
forward(): this;
|
|
backward(): this;
|
|
|
|
siblings(): Element[];
|
|
position(): number;
|
|
next(): Element;
|
|
previous(): Element;
|
|
before(element: Element): Element;
|
|
after(element: Element): Element;
|
|
}
|
|
|
|
// array.js
|
|
type ArrayAlias = _Array | number[] | string;
|
|
|
|
interface _Array {
|
|
new (array?: ArrayAlias, fallback?: number[]): _Array;
|
|
value: number[];
|
|
morph(array: number[]): this;
|
|
settle(): number[];
|
|
at(pos: NumberAlias): _Array;
|
|
toString(): string;
|
|
valueOf(): number[];
|
|
parse(array: ArrayAlias): number[];
|
|
split(string: string): number[];
|
|
reverse(): this;
|
|
clone(): _Array;
|
|
}
|
|
interface Library { Array: _Array }
|
|
|
|
// attr.js
|
|
interface Element {
|
|
attr(): object;
|
|
attr(name: string): any;
|
|
attr(obj: Object): this;
|
|
attr(name: string, value: any, namespace?: string): this;
|
|
}
|
|
|
|
// bare.js
|
|
export interface Bare extends Element {
|
|
new (element: string, inherit?: any): Bare;
|
|
words(text: string): this;
|
|
}
|
|
interface Parent {
|
|
element(element: string, inherit?: Object): Bare;
|
|
}
|
|
interface Library { Bare: Bare; }
|
|
|
|
// boxes.js
|
|
interface Box {
|
|
height: number;
|
|
width: number;
|
|
y: number;
|
|
x: number;
|
|
cx: number;
|
|
cy: number;
|
|
w: number;
|
|
h: number;
|
|
x2: number;
|
|
y2: number;
|
|
merge(box: Box): Box;
|
|
transform(m: Matrix): Box
|
|
}
|
|
|
|
export interface BBox extends Box {
|
|
new (element?: Element): BBox;
|
|
}
|
|
export interface RBox extends Box {
|
|
new (element?: Element): RBox;
|
|
}
|
|
export interface TBox extends Box {
|
|
new (element?: Element): TBox;
|
|
}
|
|
interface Element {
|
|
bbox(): BBox;
|
|
rbox(): RBox;
|
|
tbox(): TBox;
|
|
}
|
|
interface Library {
|
|
BBox: BBox;
|
|
RBox: RBox;
|
|
TBox: TBox;
|
|
}
|
|
|
|
// clip.js
|
|
export interface ClipPath extends Container {
|
|
new (): ClipPath;
|
|
targets: Element[];
|
|
remove(): this;
|
|
}
|
|
interface Container {
|
|
clip(): ClipPath;
|
|
}
|
|
interface Element {
|
|
clipWith(element: Element): this;
|
|
clipper: ClipPath;
|
|
unclip(): this;
|
|
}
|
|
interface Library { ClipPath: ClipPath; }
|
|
|
|
// color.js
|
|
interface ColorLike {
|
|
r: number;
|
|
g: number;
|
|
b: number;
|
|
}
|
|
|
|
type ColorAlias = string | ColorLike;
|
|
|
|
export interface Color extends ColorLike{
|
|
new (): Color;
|
|
new (color: ColorAlias): Color;
|
|
|
|
toString(): string;
|
|
toHex(): string;
|
|
toRgb(): string;
|
|
brightness(): number;
|
|
morph(color: ColorAlias): Color;
|
|
at(pos: number): Color;
|
|
}
|
|
interface Library { Color: Color; }
|
|
|
|
// container.js
|
|
interface ViewBoxLike {
|
|
x: number;
|
|
y: number;
|
|
width: number;
|
|
height:number;
|
|
}
|
|
|
|
export interface Container extends Parent {
|
|
new (): Container;
|
|
}
|
|
interface Library { Container: Container }
|
|
|
|
// data.js
|
|
interface Element {
|
|
data(name: string): any;
|
|
data(name: string, value: any, sustain?: boolean): this;
|
|
}
|
|
|
|
// default.js
|
|
interface Library {
|
|
defaults: {
|
|
attrs: {
|
|
'fill-opacity': number;
|
|
'stroke-opacity': number;
|
|
'stroke-width': number;
|
|
'stroke-linejoin': string;
|
|
'stroke-linecap': string;
|
|
'fill': string;
|
|
'stroke': string;
|
|
'opacity': number;
|
|
'x': number;
|
|
'y': number;
|
|
'cx': number;
|
|
'cy': number;
|
|
'width': number;
|
|
'height': number;
|
|
'r': number;
|
|
'rx': number;
|
|
'ry': number;
|
|
'offset': number;
|
|
'stop-opacity': number;
|
|
'stop-color': string;
|
|
'font-size': number;
|
|
'font-family': string;
|
|
'text-anchor': string;
|
|
}
|
|
}
|
|
}
|
|
|
|
// defs.js
|
|
export interface Defs extends Container {
|
|
new (): Defs;
|
|
}
|
|
interface Library { Defs: Defs }
|
|
|
|
// doc.js
|
|
export interface Doc extends Container {
|
|
new (): Doc;
|
|
new (id: string): Doc;
|
|
new (domElement: HTMLElement): Doc;
|
|
namespace(): this;
|
|
defs(): Defs;
|
|
parent(): HTMLElement;
|
|
spof(): this;
|
|
remove(): this;
|
|
}
|
|
interface Library { Doc: Doc; }
|
|
|
|
// element.js
|
|
export interface Element {
|
|
new (): Element;
|
|
node: LinkedHTMLElement;
|
|
type: string;
|
|
|
|
x(x: NumberAlias): this;
|
|
x(): number;
|
|
y(y: NumberAlias): this;
|
|
y(): number;
|
|
//cx(x: number, anchor?: boolean): this;
|
|
cx(x: number): this;
|
|
cx(): number;
|
|
//cy(y: number, anchor?: boolean): this;
|
|
cy(y: number): this;
|
|
cy(): number;
|
|
move(x: NumberAlias, y: NumberAlias): this;
|
|
center(x: number, y: number): this;
|
|
|
|
width(width: NumberAlias): this;
|
|
width(): number;
|
|
height(height: NumberAlias): this;
|
|
height(): number;
|
|
size(width?: NumberAlias, height?: NumberAlias): this;
|
|
|
|
clone(): Element;
|
|
remove(): this;
|
|
replace(element: Element): Element;
|
|
|
|
addTo(parent: Parent): this;
|
|
putIn(parent: Parent): Parent;
|
|
|
|
id(): string;
|
|
id(id: string): this;
|
|
|
|
inside(x: number, y: number): boolean;
|
|
|
|
show(): this;
|
|
hide(): this;
|
|
visible(): boolean;
|
|
|
|
toString(): string;
|
|
|
|
classes(): string[];
|
|
hasClass(name: string): boolean;
|
|
addClass(name: string): this;
|
|
removeClass(name: string): this;
|
|
toggleClass(name: string): this;
|
|
|
|
reference(type: string): Element;
|
|
|
|
parents(): Parent[];
|
|
|
|
matches(selector: string): boolean;
|
|
native(): LinkedHTMLElement;
|
|
|
|
svg(svg: string): this;
|
|
|
|
writeDataToDom(): this,
|
|
setData(data: object): this,
|
|
|
|
is(cls: any): boolean;
|
|
}
|
|
interface Library { Element: Element; }
|
|
|
|
// ellipse.js
|
|
interface CircleMethods extends Shape {
|
|
rx(rx: number): this;
|
|
rx(): this;
|
|
ry(ry: number): this;
|
|
ry(): this;
|
|
|
|
radius(x: number, y?: number): this;
|
|
}
|
|
export interface Circle extends CircleMethods {
|
|
new (): Circle;
|
|
}
|
|
export interface Ellipse extends CircleMethods {
|
|
new (): Ellipse;
|
|
}
|
|
interface Container {
|
|
circle(size?: number): Circle;
|
|
ellipse(width?: number, height?: number): Ellipse;
|
|
}
|
|
interface Library {
|
|
Circle: Circle;
|
|
Ellipse: Ellipse;
|
|
}
|
|
|
|
// event.js
|
|
interface Element {
|
|
on(event: string, cb: Function, context?: Object): this;
|
|
off(event: string, cb: Function, context?: Object): this;
|
|
fire(event: string, data?: any): this;
|
|
fire(event: Event): this;
|
|
|
|
click(cb: Function): this;
|
|
dblclick(cb: Function): this;
|
|
mousedown(cb: Function): this;
|
|
mouseup(cb: Function): this;
|
|
mouseover(cb: Function): this;
|
|
mouseout(cb: Function): this;
|
|
mousemove(cb: Function): this;
|
|
touchstart(cb: Function): this;
|
|
touchmove(cb: Function): this;
|
|
touchleave(cb: Function): this;
|
|
touchend(cb: Function): this;
|
|
touchcancel(cb: Function): this;
|
|
}
|
|
|
|
//fx.js
|
|
interface Library {
|
|
easing: {
|
|
'-'(pos: number): number;
|
|
'<>'(pos: number): number;
|
|
'>'(pos: number): number;
|
|
'<'(pos: number): number;
|
|
}
|
|
}
|
|
interface Element {
|
|
animate(duration?: number, ease?: string, delay?: number): Animation;
|
|
animate(info: { ease?: string; duration?: number; delay?: number }): Animation;
|
|
stop(jumpToEnd:boolean,clearQueue:boolean): Animation;
|
|
}
|
|
// TODO finishs FX
|
|
interface StopProperties {
|
|
color?: ColorAlias;
|
|
offset?: number;
|
|
opacity?: number;
|
|
}
|
|
|
|
// gradient.js
|
|
export interface Stop extends Element {
|
|
new (): Stop;
|
|
update(offset?: number, color?: ColorAlias, opacity?: number): this;
|
|
update(opts: StopProperties): this;
|
|
}
|
|
export interface Gradient extends Container {
|
|
new (type: string): Gradient;
|
|
at(offset?: number, color?: ColorAlias, opacity?: number): Stop;
|
|
at(opts: StopProperties): Stop;
|
|
update(block?: Function): this;
|
|
fill(): string;
|
|
fill(...params: any[]): never;
|
|
toString(): string;
|
|
from(x: number, y: number): this;
|
|
to(x: number, y: number): this;
|
|
radius(x: number, y?: number): this;
|
|
}
|
|
interface Container {
|
|
gradient(type: string, block?: (stop: Gradient) => void): Gradient;
|
|
}
|
|
interface Library {
|
|
Gradient: Gradient;
|
|
Stop: Stop;
|
|
}
|
|
|
|
// group.js
|
|
export interface G extends Container {
|
|
new (): G;
|
|
gbox(): BBox;
|
|
}
|
|
interface Container { group(): G; }
|
|
interface Library { G: G; }
|
|
|
|
// hyperlink.js
|
|
export interface A extends Container {
|
|
new (): A;
|
|
to(url: string): this;
|
|
to(): string;
|
|
show(target: string): this;
|
|
show(): string;
|
|
show(...params: any[]): never;
|
|
target(target: string): this;
|
|
target(): string;
|
|
}
|
|
interface Container {
|
|
link(url: string): A;
|
|
}
|
|
interface Element {
|
|
linkTo(url: string): A;
|
|
linkTo(url: (link: A) => void): A;
|
|
}
|
|
interface Library { A: A; }
|
|
|
|
// image.js
|
|
export interface Image extends Shape {
|
|
new (): Image;
|
|
load(url?: string): this;
|
|
loaded(cb: (info: { width: number, height: number, ratio: number, url: string }) => void): this;
|
|
error(cb: (event: Event) => void): this;
|
|
}
|
|
interface Container {
|
|
image(): Image;
|
|
image(href: string, size?: number): Image;
|
|
image(href: string, width?: number, height?: number): Image;
|
|
}
|
|
interface Library { Image: Image; }
|
|
|
|
// line.js
|
|
interface ArrayPoint extends Array<number> { }
|
|
type PointArrayAlias = ArrayPoint | number[] | PointArray | string;
|
|
|
|
export interface Line extends Shape {
|
|
new (): Line;
|
|
array(): PointArray;
|
|
plot(points: PointArrayAlias): this;
|
|
plot(x1: number, y1: number, x2: number, y2: number): this;
|
|
move(x: number, y: number): this;
|
|
size(width?: number, height?: number): this;
|
|
}
|
|
interface Container {
|
|
line(points: PointArrayAlias): Line;
|
|
line(x1: number, y1: number, x2: number, y2: number): Line;
|
|
}
|
|
interface Library { Line: Line; }
|
|
|
|
// marker.js
|
|
export interface Marker extends Container {
|
|
new (): Marker;
|
|
ref(x: string | number, y: string | number): this;
|
|
update(block: (marker: Marker) => void): this;
|
|
toString(): string;
|
|
}
|
|
interface Container {
|
|
marker(width?: number, height?: number, block?: (marker: Marker) => void): Marker
|
|
}
|
|
interface Defs {
|
|
marker(width?: number, height?: number, block?: (marker: Marker) => void): Marker
|
|
}
|
|
interface Line {
|
|
marker(position: string, width?: number, height?: number, block?: (marker: Marker) => void): Marker;
|
|
marker(position: string, marker: Marker): Marker;
|
|
}
|
|
interface Polyline {
|
|
marker(position: string, width?: number, height?: number, block?: (marker: Marker) => void): Marker;
|
|
marker(position: string, marker: Marker): Marker;
|
|
}
|
|
interface Polygon {
|
|
marker(position: string, width?: number, height?: number, block?: (marker: Marker) => void): Marker;
|
|
marker(position: string, marker: Marker): Marker;
|
|
}
|
|
interface Path {
|
|
marker(position: string, width?: number, height?: number, block?: (marker: Marker) => void): Marker;
|
|
marker(position: string, marker: Marker): Marker;
|
|
}
|
|
interface Library {
|
|
Marker: Marker;
|
|
}
|
|
|
|
// mask.js
|
|
export interface Mask extends Container {
|
|
new (): Mask;
|
|
targets: Element[];
|
|
}
|
|
interface Container { mask(): Mask; }
|
|
interface Element {
|
|
maskWith(mask: Mask): this;
|
|
maskWith(element: Element): this;
|
|
masker: Mask;
|
|
unmask(): this;
|
|
}
|
|
interface Library { Mask: Mask; }
|
|
|
|
// matrix.js
|
|
interface MatrixExtract {
|
|
x: number;
|
|
y: number;
|
|
transformedX: number;
|
|
transformedY: number;
|
|
skewX: number;
|
|
skewY: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
rotation: number;
|
|
a: number;
|
|
b: number;
|
|
c: number;
|
|
d: number;
|
|
e: number;
|
|
f: number;
|
|
matrix: Matrix;
|
|
}
|
|
|
|
interface MatrixLike {
|
|
a: number;
|
|
b: number;
|
|
c: number;
|
|
d: number;
|
|
e: number;
|
|
f: number;
|
|
}
|
|
|
|
type MatrixAlias = MatrixLike | number[] | Element | string;
|
|
|
|
export interface Matrix {
|
|
new (): Matrix;
|
|
new (source: MatrixAlias): Matrix;
|
|
new (a: number, b: number, c: number, d: number, e: number, f: number): Matrix;
|
|
a: number;
|
|
b: number;
|
|
c: number;
|
|
d: number;
|
|
e: number;
|
|
f: number;
|
|
extract(): MatrixExtract;
|
|
clone(): Matrix;
|
|
morph(matrix: Matrix): this;
|
|
at(pos: number): Matrix;
|
|
multiply(matrix: Matrix): Matrix;
|
|
inverse(): Matrix;
|
|
translate(x: number, y: number): Matrix;
|
|
scale(x: number, y?: number, cx?: number, cy?: number): Matrix;
|
|
rotate(r: number, cx?: number, cy?: number): Matrix;
|
|
flip(a: string, offset?: number): Matrix;
|
|
flip(offset?: number): Matrix;
|
|
skew(x: number, y?: number, cx?: number, cy?: number): Matrix;
|
|
skewX(x: number, cx?: number, cy?: number): Matrix;
|
|
skewY(y: number, cx?: number, cy?: number): Matrix;
|
|
around(cx: number, cy: number, matrix: Matrix): Matrix;
|
|
native(): SVGMatrix;
|
|
toString(): string;
|
|
}
|
|
interface Element {
|
|
ctm(): Matrix;
|
|
screenCTM(): Matrix;
|
|
}
|
|
interface Library { Matrix: Matrix }
|
|
|
|
// memory.js
|
|
interface Element {
|
|
remember(name: string, value: any): this;
|
|
remember(obj: Object): this;
|
|
remember(name: string): any;
|
|
forget(...keys: string[]): this;
|
|
forget(): this;
|
|
memory(): Object;
|
|
}
|
|
|
|
// nested.js
|
|
export interface Nested extends Container {
|
|
new (): Nested;
|
|
}
|
|
interface Container { nested(): Nested; }
|
|
interface Library { Nested: Nested; }
|
|
|
|
// number.js
|
|
interface _Number {
|
|
new (): _Number;
|
|
new (value: _Number): _Number;
|
|
new (value: string): _Number;
|
|
new (value: number, unit?: any): _Number;
|
|
toString(): string;
|
|
toJSON(): Object;
|
|
valueOf(): number;
|
|
plus(number: number): _Number;
|
|
minus(number: number): _Number;
|
|
times(number: number): _Number;
|
|
divide(number: number): _Number;
|
|
to(unit: string): _Number;
|
|
morph(number: any): this;
|
|
at(pos: number): _Number;
|
|
}
|
|
interface Library { Number: _Number; }
|
|
|
|
type NumberAlias = _Number | number | string;
|
|
|
|
// parent.js
|
|
export interface Parent extends Element {
|
|
new (): Parent;
|
|
children(): Element[];
|
|
add(element: Element, i?: number): this;
|
|
put(element: Element, i?: number): Element;
|
|
has(element: Element): boolean;
|
|
index(element: Element): number;
|
|
get(i: number): Element;
|
|
first(): Element;
|
|
last(): Element;
|
|
each(block: (index: number, children: Element[]) => void, deep?: boolean): this;
|
|
removeElement(element: Element): this;
|
|
clear(): this;
|
|
defs(): Defs;
|
|
}
|
|
interface Library{ Parent: Parent }
|
|
|
|
// path.js
|
|
interface PathArrayPoint extends Array<number | string> { }
|
|
type PathArrayAlias = PathArray | (string | number)[] | PathArrayPoint[] | string;
|
|
|
|
export interface Path extends Shape {
|
|
new (): Path;
|
|
morphArray: PathArray;
|
|
array(): PathArray;
|
|
plot(d: PathArrayAlias): this;
|
|
}
|
|
interface Container {
|
|
path(): Path;
|
|
path(d: PathArrayAlias): Path;
|
|
}
|
|
interface Library{ Path: Path }
|
|
|
|
// pathArray.js
|
|
export interface PathArray extends _Array {
|
|
new (): PathArray;
|
|
new (d: PathArrayAlias): PathArray;
|
|
move(x: number, y: number): this;
|
|
size(width?: number, height?: number): this;
|
|
parse(array: PathArrayAlias): PathArrayPoint[];
|
|
parse(array: ArrayAlias): never;
|
|
bbox(): BBox;
|
|
}
|
|
interface Library { PathArray: PathArray; }
|
|
|
|
// pattern.js
|
|
export interface Pattern extends Container {
|
|
new (): Pattern;
|
|
fill(): string;
|
|
fill(...rest: any[]): never;
|
|
update(block: (pattern: Pattern) => void): this;
|
|
toString(): string;
|
|
}
|
|
interface Container {
|
|
pattern(width?: number, height?: number, block?: (pattern: Pattern) => void): Pattern
|
|
}
|
|
interface Library { Pattern: Pattern }
|
|
|
|
// point.js
|
|
export interface Point {
|
|
new (): Point;
|
|
new (position: ArrayPoint): Point;
|
|
new (point: Point): Point;
|
|
new (position: { x: number, y: number }): Point;
|
|
new (x: number, y: number): Point;
|
|
|
|
clone(): Point;
|
|
morph(point: Point): this;
|
|
at(pos: number): Point;
|
|
native(): SVGPoint;
|
|
transform(matrix: Matrix): Point;
|
|
}
|
|
interface Library { Point: Point; }
|
|
interface Element {
|
|
point(): Point;
|
|
point(position: ArrayPoint): Point;
|
|
point(position: { x: number, y: number }): Point;
|
|
point(x: number, y: number): Point;
|
|
}
|
|
|
|
// pointArray.js
|
|
export interface PointArray extends _Array {
|
|
new (): PointArray;
|
|
new (points: PointArrayAlias): PointArray;
|
|
toString(): string;
|
|
toLine(): {
|
|
x1: number;
|
|
y1: number;
|
|
x2: number;
|
|
y2: number;
|
|
};
|
|
parse(points: PointArrayAlias): ArrayPoint[];
|
|
parse(array: ArrayAlias): never;
|
|
move(x: number, y: number): this;
|
|
size(width?: number, height?: number): this;
|
|
bbox(): BBox;
|
|
}
|
|
interface Library { PointArray: PointArray }
|
|
|
|
// poly.js
|
|
interface poly extends Shape {
|
|
array(): PointArray;
|
|
plot(p: PointArrayAlias): this;
|
|
move(x: number, y: number): this;
|
|
size(width: number, height: number): this;
|
|
}
|
|
export interface PolyLine extends poly {
|
|
new (): PolyLine;
|
|
}
|
|
interface Library { PolyLine: PolyLine; }
|
|
interface Container {
|
|
polyline(points: PointArrayAlias): PolyLine;
|
|
}
|
|
export interface Polygon extends poly {
|
|
new (): Polygon;
|
|
}
|
|
interface Library { Polygon: Polygon; }
|
|
interface Container {
|
|
polygon(points: PointArrayAlias): Polygon;
|
|
}
|
|
|
|
// rect.js
|
|
export interface Rect extends Shape {
|
|
new (): Rect;
|
|
radius(x: number, y?: number): this;
|
|
}
|
|
interface Library { Rect: Rect; }
|
|
interface Container {
|
|
rect(width?: number, height?: number): Rect;
|
|
}
|
|
|
|
// regex.js
|
|
interface Library {
|
|
regex: {
|
|
numberAndUnit: RegExp;
|
|
hex: RegExp;
|
|
rgb: RegExp;
|
|
reference: RegExp;
|
|
transforms: RegExp;
|
|
whitespace: RegExp;
|
|
isHex: RegExp;
|
|
isRgb: RegExp;
|
|
isCss: RegExp;
|
|
isBlank: RegExp;
|
|
isNumber: RegExp;
|
|
isPercent: RegExp;
|
|
isImage: RegExp;
|
|
delimiter: RegExp;
|
|
hyphen: RegExp;
|
|
pathLetters: RegExp;
|
|
isPathLetter: RegExp;
|
|
dots: RegExp;
|
|
}
|
|
}
|
|
|
|
// selector.js
|
|
interface Library {
|
|
get(id: string): Element;
|
|
select(query: string, parent: HTMLElement): Set;
|
|
}
|
|
interface Parent {
|
|
select(query: string): Set;
|
|
}
|
|
|
|
// set.js
|
|
export interface Set {
|
|
new (members?: Element[]): Set;
|
|
add(...elments: Element[]): this;
|
|
remove(element: Element): this;
|
|
each(block: (index: number, members: Element[]) => void): this;
|
|
clear(): this;
|
|
length(): number;
|
|
has(element: Element): this;
|
|
index(element: Element): number;
|
|
get(i: number): Element;
|
|
first(): Element;
|
|
last(): Element;
|
|
valueOf(): Element[];
|
|
bbox(): BBox;
|
|
}
|
|
interface Container { set(members?: Element[]): Set; }
|
|
interface Library { Set: Set; }
|
|
|
|
// shape.js
|
|
export interface Shape extends Element {
|
|
new (): Shape;
|
|
}
|
|
interface Library { Shape: Shape; }
|
|
|
|
// style.js
|
|
interface Element {
|
|
style(styles: Object): this;
|
|
style(style: string): any;
|
|
style(style: string, value: any): this;
|
|
}
|
|
|
|
// sugar.js
|
|
interface StrokeData {
|
|
color?: string;
|
|
width?: number;
|
|
opacity?: number;
|
|
linecap?: string;
|
|
linejoin?: string;
|
|
miterlimit?: number;
|
|
dasharray?: string;
|
|
dashoffset?: number;
|
|
}
|
|
interface Element {
|
|
fill(fill: { color?: string; opacity?: number, rule?: string }): this;
|
|
fill(color: string): this;
|
|
fill(pattern: Element): this;
|
|
fill(image: Image): this;
|
|
stroke(stroke: StrokeData): this;
|
|
stroke(color: string): this;
|
|
rotate(d: number, cx?: number, cy?: number): this;
|
|
skew(x: number, y?: number, cx?: number, cy?: number): this;
|
|
scale(x: number, y?: number, cx?: number, cy?: number): this;
|
|
translate(x: number, y: number): this;
|
|
flip(a: string, offset?: number): this;
|
|
flip(offset?: number): this;
|
|
matrix(m: MatrixAlias): this;
|
|
matrix(a: number, b: number, c: number, d: number, e: number, f: number): this;
|
|
opacity(o: number): this;
|
|
opacity(): number;
|
|
dx(x: NumberAlias): this;
|
|
dy(y: NumberAlias): this;
|
|
dmove(x: NumberAlias, y: NumberAlias): this;
|
|
}
|
|
interface Path {
|
|
length(): number;
|
|
pointAt(length: number): { x: number, y: number };
|
|
}
|
|
interface FontData {
|
|
family?: string;
|
|
size?: NumberAlias;
|
|
anchor?: string;
|
|
leading?: NumberAlias;
|
|
weight?: string;
|
|
style?: string
|
|
}
|
|
interface Parent {
|
|
font(font: FontData): this;
|
|
}
|
|
interface Text {
|
|
font(font: FontData): this;
|
|
}
|
|
|
|
// text.js
|
|
export interface Text extends Shape {
|
|
new (): Text;
|
|
clone(): Text;
|
|
text(): string;
|
|
text(text: string): this;
|
|
text(block: (text: Text) => void): this;
|
|
size(fontSize: NumberAlias): this;
|
|
leading(): number;
|
|
leading(leading: NumberAlias): this;
|
|
lines(): Set;
|
|
rebuild(enabled: boolean): this;
|
|
build(enabled: boolean): this;
|
|
plain(text: string): this;
|
|
tspan(text: string): Tspan;
|
|
tspan(block: (tspan: Tspan) => void): this;
|
|
clear(): this;
|
|
length(): number;
|
|
}
|
|
interface Container {
|
|
text(text: string): Text;
|
|
text(block: (tspan: Tspan) => void): Text;
|
|
plain(text: string): Text;
|
|
}
|
|
interface Library { Text: Text; }
|
|
export interface Tspan extends Shape {
|
|
new (): Tspan;
|
|
text(): string;
|
|
text(text: string): Tspan;
|
|
text(block: (tspan: Tspan) => void): this;
|
|
dx(x: NumberAlias): this;
|
|
dy(y: NumberAlias): this;
|
|
newLine(): this;
|
|
plain(text: any): this;
|
|
tspan(text: string): Tspan;
|
|
tspan(block: (tspan: Tspan) => void): this;
|
|
clear(): this;
|
|
length(): number;
|
|
}
|
|
interface Library { Tspan: Tspan; }
|
|
|
|
// textpath.js
|
|
export interface TextPath extends Parent {
|
|
new (): TextPath;
|
|
}
|
|
interface Text {
|
|
path(d: PathArrayAlias): this;
|
|
track(): Element;
|
|
textPath(): Element;
|
|
}
|
|
interface Library { TextPath: TextPath; }
|
|
|
|
// transform.js
|
|
interface Element {
|
|
transform(t: Transform, relative?: boolean): Element;
|
|
transform(): Transform;
|
|
untransform(): this;
|
|
matrixify(): Matrix;
|
|
toParent(parent: Parent): this;
|
|
toDoc(): this;
|
|
}
|
|
interface Transform {
|
|
x?: number;
|
|
y?: number;
|
|
rotation?: number;
|
|
cx?: number;
|
|
cy?: number;
|
|
scaleX?: number;
|
|
scaleY?: number;
|
|
skewX?: number;
|
|
skewY?: number;
|
|
matrix?: Matrix; // 1,0,0,1,0,0
|
|
a?: number; // direct digits of matrix
|
|
b?: number;
|
|
c?: number;
|
|
d?: number;
|
|
e?: number;
|
|
f?: number;
|
|
}
|
|
export interface Transformation {
|
|
new (...transform: Transform[]): Transformation;
|
|
new (source: Transform, inversed?: boolean): Transformation;
|
|
at(pos: number): Matrix;
|
|
undo(transform: Transform): this
|
|
}
|
|
export interface Translate extends Transformation {new (): Translate}
|
|
export interface Rotate extends Transformation {new (): Rotate}
|
|
export interface Scale extends Transformation {new (): Scale}
|
|
export interface Skew extends Transformation {new (): Skew}
|
|
interface Library {
|
|
Transformation: Transformation;
|
|
Translate: Translate;
|
|
Rotate: Rotate;
|
|
Scale: Scale;
|
|
Skew: Skew;
|
|
}
|
|
|
|
// ungroup.js
|
|
interface Parent {
|
|
ungroup(parent: Parent, depth?: number): this;
|
|
flatten(parent: Parent, depth?: number): this;
|
|
}
|
|
|
|
// use.js
|
|
export interface Use extends Shape {
|
|
new (): Use;
|
|
element(element: Element, file?: string): this;
|
|
}
|
|
interface Container {
|
|
use(element: Element, file?: string): Use;
|
|
}
|
|
interface Library { Use: Use; }
|
|
|
|
// utilities.js
|
|
interface Library {
|
|
utils: {
|
|
map(array: any[], block: Function): any;
|
|
filter(array: any[], block: Function): any;
|
|
radians(d: number): number;
|
|
degrees(r: number): number;
|
|
filterSVGElements: HTMLElement[]
|
|
}
|
|
}
|
|
|
|
// viewbox.js
|
|
type ViewBoxAlias = ViewBoxLike | number[] | string | Element;
|
|
|
|
interface ViewBox {
|
|
new (source: ViewBoxAlias): ViewBox;
|
|
new (x: number, y: number, width: number, height: number): ViewBox;
|
|
x: number;
|
|
y: number;
|
|
width: number;
|
|
height: number;
|
|
zoom?: number;
|
|
toString(): string;
|
|
morph(source: ViewBoxAlias): ViewBox;
|
|
morph(x: number, y: number, width: number, height: number): ViewBox;
|
|
at(pos:number): ViewBox;
|
|
}
|
|
interface Container {
|
|
viewbox(): ViewBox;
|
|
viewbox(x: number, y: number, width: number, height: number): this;
|
|
viewbox(viewbox: ViewBoxLike): this;
|
|
}
|
|
interface Library { ViewBox: ViewBox; }
|
|
|
|
export interface Animation {
|
|
stop(): Animation;
|
|
|
|
attr(name: string, value: any, namespace?: string): Animation;
|
|
attr(obj: Object): Animation;
|
|
attr(name: string): any;
|
|
attr(): object;
|
|
|
|
viewbox(x: number, y: number, w: number, h: number): Animation;
|
|
|
|
move(x: number, y: number, anchor?: boolean): Animation;
|
|
x(x: number, anchor?: boolean): Animation;
|
|
y(y: number, anchor?: boolean): Animation;
|
|
|
|
center(x: number, y: number, anchor?: boolean): Animation;
|
|
cx(x: number, anchor?: boolean): Animation;
|
|
cy(y: number, anchor?: boolean): Animation;
|
|
|
|
size(w: number, h: number, anchor?: boolean): Animation;
|
|
during(cb: (pos: number) => void): Animation;
|
|
to(value: number): Animation;
|
|
after(cb: () => void): Animation;
|
|
|
|
rotate(degrees: number, cx?: number, cy?: number): Animation
|
|
skew(skewX: number, skewY?: number, cx?: number, cy?: number): Animation
|
|
scale(scaleX: number, scaleY?: number, cx?: number, cy?: number): Animation
|
|
translate(x: number, y: number): Animation
|
|
|
|
// TODO style, etc, bbox...
|
|
}
|
|
}
|