83a391b46b
 ### Change Type - [x] `minor` — New feature [^1]: publishes a `patch` release, for devDependencies use `internal` [^2]: will not publish a new version ### Test Plan 1. Make some cloud shapes, try different sizes, colors, fills. 2. Export cloud shapes to images. - [ ] Unit Tests - [ ] End to end tests ### Release Notes - Adds a cloud shape.
857 lines
25 KiB
Markdown
857 lines
25 KiB
Markdown
## API Report File for "@tldraw/primitives"
|
|
|
|
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
|
|
|
|
```ts
|
|
|
|
import { Box2dModel } from '@tldraw/tlschema';
|
|
import { Vec2dModel } from '@tldraw/tlschema';
|
|
|
|
// @public
|
|
export function angleDelta(a0: number, a1: number): number;
|
|
|
|
// @public
|
|
export function approximately(a: number, b: number, precision?: number): boolean;
|
|
|
|
// @public
|
|
export function areAnglesCompatible(a: number, b: number): boolean;
|
|
|
|
// @public (undocumented)
|
|
export class Box2d {
|
|
constructor(x?: number, y?: number, w?: number, h?: number);
|
|
// (undocumented)
|
|
get aspectRatio(): number;
|
|
// (undocumented)
|
|
get center(): Vec2d;
|
|
set center(v: Vec2d);
|
|
// (undocumented)
|
|
clone(): Box2d;
|
|
// (undocumented)
|
|
static Collides: (A: Box2d, B: Box2d) => boolean;
|
|
// (undocumented)
|
|
collides(B: Box2d): boolean;
|
|
// (undocumented)
|
|
static Common: (boxes: Box2d[]) => Box2d;
|
|
// (undocumented)
|
|
static Contains: (A: Box2d, B: Box2d) => boolean;
|
|
// (undocumented)
|
|
contains(B: Box2d): boolean;
|
|
// (undocumented)
|
|
static ContainsPoint: (A: Box2d, B: number | VecLike, y?: number) => boolean;
|
|
// (undocumented)
|
|
containsPoint(V: number | VecLike, y?: number): boolean;
|
|
// (undocumented)
|
|
get corners(): Vec2d[];
|
|
// (undocumented)
|
|
static Equals(a: Box2d | Box2dModel, b: Box2d | Box2dModel): boolean;
|
|
// (undocumented)
|
|
equals(other: Box2d | Box2dModel): boolean;
|
|
// (undocumented)
|
|
static Expand(A: Box2d, B: Box2d): Box2d;
|
|
// (undocumented)
|
|
expand(A: Box2d): this;
|
|
// (undocumented)
|
|
static ExpandBy(A: Box2d, n: number): Box2d;
|
|
// (undocumented)
|
|
expandBy(n: number): this;
|
|
// (undocumented)
|
|
static From(box: Box2dModel): Box2d;
|
|
// (undocumented)
|
|
static FromPoints(points: VecLike[]): Box2d;
|
|
// (undocumented)
|
|
getHandlePoint(handle: SelectionCorner | SelectionEdge): Vec2d;
|
|
// (undocumented)
|
|
h: number;
|
|
// (undocumented)
|
|
get height(): number;
|
|
set height(n: number);
|
|
// (undocumented)
|
|
static Includes: (A: Box2d, B: Box2d) => boolean;
|
|
// (undocumented)
|
|
includes(B: Box2d): boolean;
|
|
// (undocumented)
|
|
get maxX(): number;
|
|
// (undocumented)
|
|
get maxY(): number;
|
|
// (undocumented)
|
|
get midX(): number;
|
|
// (undocumented)
|
|
get midY(): number;
|
|
// (undocumented)
|
|
get minX(): number;
|
|
set minX(n: number);
|
|
// (undocumented)
|
|
get minY(): number;
|
|
set minY(n: number);
|
|
// (undocumented)
|
|
get point(): Vec2d;
|
|
set point(val: Vec2d);
|
|
// (undocumented)
|
|
static Resize(box: Box2d, handle: SelectionCorner | SelectionEdge | string, dx: number, dy: number, isAspectRatioLocked?: boolean): {
|
|
box: Box2d;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
};
|
|
// (undocumented)
|
|
resize(handle: SelectionCorner | SelectionEdge | string, dx: number, dy: number): void;
|
|
// (undocumented)
|
|
scale(n: number): this;
|
|
// (undocumented)
|
|
set(x?: number, y?: number, w?: number, h?: number): this;
|
|
// (undocumented)
|
|
setTo(B: Box2d): this;
|
|
// (undocumented)
|
|
static Sides: (A: Box2d, inset?: number) => Vec2d[][];
|
|
// (undocumented)
|
|
get sides(): Array<[Vec2d, Vec2d]>;
|
|
// (undocumented)
|
|
get size(): Vec2d;
|
|
// (undocumented)
|
|
get snapPoints(): Vec2d[];
|
|
// (undocumented)
|
|
snapToGrid(size: number): void;
|
|
// (undocumented)
|
|
toFixed(): this;
|
|
// (undocumented)
|
|
toJson(): Box2dModel;
|
|
// (undocumented)
|
|
translate(delta: VecLike): this;
|
|
// (undocumented)
|
|
union(box: Box2dModel): this;
|
|
// (undocumented)
|
|
w: number;
|
|
// (undocumented)
|
|
get width(): number;
|
|
set width(n: number);
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function canonicalizeRotation(a: number): number;
|
|
|
|
// @public
|
|
export function clamp(n: number, min: number): number;
|
|
|
|
// @public
|
|
export function clamp(n: number, min: number, max: number): number;
|
|
|
|
// @public
|
|
export function clampRadians(r: number): number;
|
|
|
|
// @public (undocumented)
|
|
export class CubicSegment2d extends BaseSegment2d<CubicSegment2dModel> {
|
|
// (undocumented)
|
|
[Symbol.iterator]: (this: InstanceType<typeof CubicSegment2d>) => Generator<VecLike, void, undefined>;
|
|
constructor(a: VecLike, b: VecLike, c: VecLike, d: VecLike, p?: number);
|
|
// (undocumented)
|
|
getPath(head?: boolean): string;
|
|
// (undocumented)
|
|
getPoint(t: number): Vec2d;
|
|
// (undocumented)
|
|
getX(t: number): number;
|
|
// (undocumented)
|
|
getY(t: number): number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface CubicSegment2dModel {
|
|
// (undocumented)
|
|
a: VecLike;
|
|
// (undocumented)
|
|
b: VecLike;
|
|
// (undocumented)
|
|
c: VecLike;
|
|
// (undocumented)
|
|
d: VecLike;
|
|
// (undocumented)
|
|
p: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class CubicSpline2d extends BaseSpline2d<CubicSegment2dModel> {
|
|
constructor(points: VecLike[], k?: number, p?: number);
|
|
// (undocumented)
|
|
static FromPoints(points: Vec2d[]): CubicSpline2d;
|
|
// (undocumented)
|
|
getSegmentsFromPoints(points: VecLike[], k?: number, p?: number): CubicSegment2d[];
|
|
// (undocumented)
|
|
segments: CubicSegment2d[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function decomposeMatrix2d(m: MatLike): {
|
|
x: number;
|
|
y: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
rotation: number;
|
|
};
|
|
|
|
// @public
|
|
export function degreesToRadians(d: number): number;
|
|
|
|
// @public (undocumented)
|
|
export const EASINGS: {
|
|
readonly linear: (t: number) => number;
|
|
readonly easeInQuad: (t: number) => number;
|
|
readonly easeOutQuad: (t: number) => number;
|
|
readonly easeInOutQuad: (t: number) => number;
|
|
readonly easeInCubic: (t: number) => number;
|
|
readonly easeOutCubic: (t: number) => number;
|
|
readonly easeInOutCubic: (t: number) => number;
|
|
readonly easeInQuart: (t: number) => number;
|
|
readonly easeOutQuart: (t: number) => number;
|
|
readonly easeInOutQuart: (t: number) => number;
|
|
readonly easeInQuint: (t: number) => number;
|
|
readonly easeOutQuint: (t: number) => number;
|
|
readonly easeInOutQuint: (t: number) => number;
|
|
readonly easeInSine: (t: number) => number;
|
|
readonly easeOutSine: (t: number) => number;
|
|
readonly easeInOutSine: (t: number) => number;
|
|
readonly easeInExpo: (t: number) => number;
|
|
readonly easeOutExpo: (t: number) => number;
|
|
readonly easeInOutExpo: (t: number) => number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type EasingType = keyof typeof EASINGS;
|
|
|
|
// @public (undocumented)
|
|
export const EPSILON: number;
|
|
|
|
// @public (undocumented)
|
|
export function flipSelectionHandleX(handle: SelectionHandle): "bottom_left" | "bottom_right" | "bottom" | "left" | "right" | "top_left" | "top_right" | "top";
|
|
|
|
// @public (undocumented)
|
|
export function flipSelectionHandleY(handle: SelectionHandle): "bottom_left" | "bottom_right" | "bottom" | "left" | "right" | "top_left" | "top_right" | "top";
|
|
|
|
// @public
|
|
export function getArcLength(C: VecLike, r: number, A: VecLike, B: VecLike): number;
|
|
|
|
// @public (undocumented)
|
|
export function getDrawLinePathData(id: string, outline: VecLike[], strokeWidth: number): string[];
|
|
|
|
// @public (undocumented)
|
|
export function getHeight(pts: VecLike[]): number;
|
|
|
|
// @public (undocumented)
|
|
export function getMaxX(pts: VecLike[]): number;
|
|
|
|
// @public (undocumented)
|
|
export function getMaxY(pts: VecLike[]): number;
|
|
|
|
// @public (undocumented)
|
|
export function getMidX(pts: VecLike[]): number;
|
|
|
|
// @public (undocumented)
|
|
export function getMidY(pts: VecLike[]): number;
|
|
|
|
// @public (undocumented)
|
|
export function getMinX(pts: VecLike[]): number;
|
|
|
|
// @public (undocumented)
|
|
export function getMinY(pts: VecLike[]): number;
|
|
|
|
// @public
|
|
export function getPointOnCircle(cx: number, cy: number, r: number, a: number): Vec2d;
|
|
|
|
// @public (undocumented)
|
|
export function getPolygonVertices(width: number, height: number, sides: number): Vec2d[];
|
|
|
|
// @public (undocumented)
|
|
export function getRoundedInkyPolygonPath(points: VecLike[]): string;
|
|
|
|
// @public (undocumented)
|
|
export function getRoundedPolygonPoints(id: string, outline: VecLike[], offset: number, roundness: number, passes: number): VecLike[];
|
|
|
|
// @public
|
|
export const getStarBounds: (sides: number, w: number, h: number) => Box2d;
|
|
|
|
// @public
|
|
export function getStroke(points: VecLike[], options?: StrokeOptions): Vec2d[];
|
|
|
|
// @public
|
|
export function getStrokeOutlinePoints(strokePoints: StrokePoint[], options?: StrokeOptions): Vec2d[];
|
|
|
|
// @public
|
|
export function getStrokePoints(rawInputPoints: VecLike[], options?: StrokeOptions): StrokePoint[];
|
|
|
|
// @public
|
|
export function getSweep(C: VecLike, A: VecLike, B: VecLike): number;
|
|
|
|
// @public (undocumented)
|
|
export function getWidth(pts: VecLike[]): number;
|
|
|
|
// @public
|
|
export function intersectCircleCircle(c1: VecLike, r1: number, c2: VecLike, r2: number): Vec2d[];
|
|
|
|
// @public
|
|
export function intersectCirclePolygon(c: VecLike, r: number, points: VecLike[]): null | VecLike[];
|
|
|
|
// @public
|
|
export function intersectCirclePolyline(c: VecLike, r: number, points: VecLike[]): null | VecLike[];
|
|
|
|
// @public
|
|
export function intersectLineSegmentCircle(a1: VecLike, a2: VecLike, c: VecLike, r: number): null | VecLike[];
|
|
|
|
// @public
|
|
export function intersectLineSegmentLineSegment(a1: VecLike, a2: VecLike, b1: VecLike, b2: VecLike): null | Vec2d;
|
|
|
|
// @public
|
|
export function intersectLineSegmentPolygon(a1: VecLike, a2: VecLike, points: VecLike[]): null | VecLike[];
|
|
|
|
// @public
|
|
export function intersectLineSegmentPolyline(a1: VecLike, a2: VecLike, points: VecLike[]): null | VecLike[];
|
|
|
|
// @public
|
|
export function intersectPolygonBounds(points: VecLike[], bounds: Box2d): null | VecLike[];
|
|
|
|
// @public
|
|
export function intersectPolygonPolygon(polygonA: VecLike[], polygonB: VecLike[]): null | VecLike[];
|
|
|
|
// @public
|
|
export function isAngleBetween(a: number, b: number, c: number): boolean;
|
|
|
|
// @public
|
|
export const isSafeFloat: (n: number) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export function isSelectionCorner(selection: string): selection is SelectionCorner;
|
|
|
|
// @public
|
|
export function lerpAngles(a0: number, a1: number, t: number): number;
|
|
|
|
// @public (undocumented)
|
|
export class LineSegment2d extends BaseSegment2d<LineSegment2dModel> {
|
|
constructor(a: VecLike, b: VecLike, p?: number);
|
|
// (undocumented)
|
|
a: VecLike;
|
|
// (undocumented)
|
|
static Angle(A: LineSegment2d): number;
|
|
// (undocumented)
|
|
get angle(): number;
|
|
// (undocumented)
|
|
b: VecLike;
|
|
// (undocumented)
|
|
get bounds(): Box2d;
|
|
getClosestPointTo(point: VecLike): {
|
|
point: Vec2d;
|
|
distance: number;
|
|
};
|
|
// (undocumented)
|
|
getNormal(): Vec2d;
|
|
// (undocumented)
|
|
getPath(head?: boolean): string;
|
|
// (undocumented)
|
|
getPoint(t: number): Vec2d;
|
|
// (undocumented)
|
|
getX(t: number): number;
|
|
// (undocumented)
|
|
getY(t: number): number;
|
|
// (undocumented)
|
|
static Length(A: LineSegment2d): number;
|
|
// (undocumented)
|
|
get length(): number;
|
|
// (undocumented)
|
|
static Tangent(A: LineSegment2d): Vec2d;
|
|
// (undocumented)
|
|
get tangent(): Vec2d;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface LineSegment2dModel {
|
|
// (undocumented)
|
|
a: VecLike;
|
|
// (undocumented)
|
|
b: VecLike;
|
|
// (undocumented)
|
|
p: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function linesIntersect(A: VecLike, B: VecLike, C: VecLike, D: VecLike): boolean;
|
|
|
|
// @public
|
|
export function longAngleDist(a0: number, a1: number): number;
|
|
|
|
// @public (undocumented)
|
|
export type MatLike = Matrix2d | Matrix2dModel;
|
|
|
|
// @public (undocumented)
|
|
export class Matrix2d {
|
|
constructor(a: number, b: number, c: number, d: number, e: number, f: number);
|
|
// (undocumented)
|
|
a: number;
|
|
// (undocumented)
|
|
static Absolute(m: MatLike): Matrix2dModel;
|
|
// (undocumented)
|
|
static applyToBounds(m: MatLike, box: Box2d): Box2d;
|
|
// (undocumented)
|
|
applyToPoint(point: VecLike): Vec2d;
|
|
// (undocumented)
|
|
static applyToPoint(m: MatLike, point: VecLike): Vec2d;
|
|
// (undocumented)
|
|
applyToPoints(points: VecLike[]): Vec2d[];
|
|
// (undocumented)
|
|
static applyToPoints(m: MatLike, points: VecLike[]): Vec2d[];
|
|
// (undocumented)
|
|
static applyToXY(m: MatLike, x: number, y: number): number[];
|
|
// (undocumented)
|
|
b: number;
|
|
// (undocumented)
|
|
c: number;
|
|
// (undocumented)
|
|
clone(): Matrix2d;
|
|
// (undocumented)
|
|
static Compose(...matrices: MatLike[]): Matrix2d;
|
|
// (undocumented)
|
|
d: number;
|
|
// (undocumented)
|
|
static Decompose(m: MatLike): MatrixInfo;
|
|
// (undocumented)
|
|
decompose(): MatrixInfo;
|
|
// (undocumented)
|
|
decomposed(): MatrixInfo;
|
|
// (undocumented)
|
|
e: number;
|
|
// (undocumented)
|
|
equals(m: Matrix2d | Matrix2dModel): boolean;
|
|
// (undocumented)
|
|
f: number;
|
|
// (undocumented)
|
|
static From(m: MatLike): Matrix2d;
|
|
// (undocumented)
|
|
static Identity(): Matrix2d;
|
|
// (undocumented)
|
|
identity(): this;
|
|
// (undocumented)
|
|
static Inverse(m: Matrix2dModel): Matrix2dModel;
|
|
// (undocumented)
|
|
invert(): this;
|
|
// (undocumented)
|
|
static Multiply(m1: Matrix2dModel, m2: Matrix2dModel): Matrix2dModel;
|
|
// (undocumented)
|
|
multiply(m: Matrix2d | Matrix2dModel): this;
|
|
// (undocumented)
|
|
static Rotate(r: number, cx?: number, cy?: number): Matrix2d;
|
|
// (undocumented)
|
|
rotate(r: number, cx?: number, cy?: number): Matrix2d;
|
|
// (undocumented)
|
|
static Scale: {
|
|
(x: number, y: number): Matrix2dModel;
|
|
(x: number, y: number, cx: number, cy: number): Matrix2dModel;
|
|
};
|
|
// (undocumented)
|
|
scale(x: number, y: number): this;
|
|
// (undocumented)
|
|
setTo(model: Matrix2dModel): this;
|
|
// (undocumented)
|
|
static Smooth(m: MatLike, precision?: number): MatLike;
|
|
// (undocumented)
|
|
toCssString(): string;
|
|
// (undocumented)
|
|
static toCssString(m: MatLike): string;
|
|
// (undocumented)
|
|
static Translate(x: number, y: number): Matrix2d;
|
|
// (undocumented)
|
|
translate(x: number, y: number): Matrix2d;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface Matrix2dModel {
|
|
// (undocumented)
|
|
a: number;
|
|
// (undocumented)
|
|
b: number;
|
|
// (undocumented)
|
|
c: number;
|
|
// (undocumented)
|
|
d: number;
|
|
// (undocumented)
|
|
e: number;
|
|
// (undocumented)
|
|
f: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface MatrixInfo {
|
|
// (undocumented)
|
|
rotation: number;
|
|
// (undocumented)
|
|
scaleX: number;
|
|
// (undocumented)
|
|
scaleY: number;
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: number;
|
|
}
|
|
|
|
// @public
|
|
export function perimeterOfEllipse(rx: number, ry: number): number;
|
|
|
|
// @public (undocumented)
|
|
export const PI: number;
|
|
|
|
// @public (undocumented)
|
|
export const PI2: number;
|
|
|
|
// @public
|
|
export function pointInBounds(A: VecLike, b: Box2d): boolean;
|
|
|
|
// @public
|
|
export function pointInCircle(A: VecLike, C: VecLike, r: number): boolean;
|
|
|
|
// @public
|
|
export function pointInEllipse(A: VecLike, C: VecLike, rx: number, ry: number, rotation?: number): boolean;
|
|
|
|
// @public
|
|
export function pointInPolygon(A: VecLike, points: VecLike[]): boolean;
|
|
|
|
// @public
|
|
export function pointInPolyline(A: VecLike, points: VecLike[], distance?: number): boolean;
|
|
|
|
// @public
|
|
export function pointInRect(A: VecLike, point: VecLike, size: VecLike): boolean;
|
|
|
|
// @public
|
|
export function pointNearToLineSegment(A: VecLike, p1: VecLike, p2: VecLike, distance?: number): boolean;
|
|
|
|
// @public
|
|
export function pointNearToPolyline(A: VecLike, points: VecLike[], distance?: number): boolean;
|
|
|
|
// @public (undocumented)
|
|
export function polygonsIntersect(a: VecLike[], b: VecLike[]): boolean;
|
|
|
|
// @public (undocumented)
|
|
export class Polyline2d extends BaseSpline2d<LineSegment2dModel> {
|
|
constructor(points: VecLike[], k?: number, p?: number);
|
|
// (undocumented)
|
|
static FromPoints(points: VecLike[]): Polyline2d;
|
|
// (undocumented)
|
|
getSegmentsFromPoints(points: VecLike[], p?: number): LineSegment2d[];
|
|
// (undocumented)
|
|
segments: LineSegment2d[];
|
|
}
|
|
|
|
// @public
|
|
export function radiansToDegrees(r: number): number;
|
|
|
|
// @public
|
|
export function rangeIntersection(a0: number, a1: number, b0: number, b1: number): [number, number] | null;
|
|
|
|
// @public (undocumented)
|
|
export function rangesOverlap(a0: number, a1: number, b0: number, b1: number): boolean;
|
|
|
|
// @public (undocumented)
|
|
export const ROTATE_CORNER_TO_SELECTION_CORNER: {
|
|
readonly top_left_rotate: "top_left";
|
|
readonly top_right_rotate: "top_right";
|
|
readonly bottom_right_rotate: "bottom_right";
|
|
readonly bottom_left_rotate: "bottom_left";
|
|
readonly mobile_rotate: "top_left";
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type RotateCorner = 'bottom_left_rotate' | 'bottom_right_rotate' | 'mobile_rotate' | 'top_left_rotate' | 'top_right_rotate';
|
|
|
|
// @public (undocumented)
|
|
export function rotateSelectionHandle(handle: SelectionHandle, rotation: number): SelectionHandle;
|
|
|
|
// @public (undocumented)
|
|
export type SelectionCorner = 'bottom_left' | 'bottom_right' | 'top_left' | 'top_right';
|
|
|
|
// @public (undocumented)
|
|
export type SelectionEdge = 'bottom' | 'left' | 'right' | 'top';
|
|
|
|
// @public (undocumented)
|
|
export type SelectionHandle = SelectionCorner | SelectionEdge;
|
|
|
|
// @public (undocumented)
|
|
export function setStrokePointRadii(strokePoints: StrokePoint[], options: StrokeOptions): StrokePoint[];
|
|
|
|
// @public
|
|
export function shortAngleDist(a0: number, a1: number): number;
|
|
|
|
// @public
|
|
export function simplify(points: VecLike[], tolerance?: number): VecLike[];
|
|
|
|
// @public (undocumented)
|
|
export function simplify2(points: VecLike[], tolerance?: number): VecLike[];
|
|
|
|
// @public (undocumented)
|
|
export const SIN: (x: number) => number;
|
|
|
|
// @public
|
|
export function snapAngle(r: number, segments: number): number;
|
|
|
|
// @public
|
|
export interface StrokeOptions {
|
|
easing?: (pressure: number) => number;
|
|
end?: {
|
|
cap?: boolean;
|
|
taper?: boolean | number;
|
|
easing?: (distance: number) => number;
|
|
};
|
|
last?: boolean;
|
|
simulatePressure?: boolean;
|
|
size?: number;
|
|
smoothing?: number;
|
|
start?: {
|
|
cap?: boolean;
|
|
taper?: boolean | number;
|
|
easing?: (distance: number) => number;
|
|
};
|
|
// (undocumented)
|
|
streamline?: number;
|
|
thinning?: number;
|
|
}
|
|
|
|
// @public
|
|
export interface StrokePoint {
|
|
// (undocumented)
|
|
distance: number;
|
|
// (undocumented)
|
|
input: Vec2d;
|
|
// (undocumented)
|
|
point: Vec2d;
|
|
// (undocumented)
|
|
pressure: number;
|
|
// (undocumented)
|
|
radius: number;
|
|
// (undocumented)
|
|
runningLength: number;
|
|
// (undocumented)
|
|
vector: Vec2d;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const TAU: number;
|
|
|
|
// @public
|
|
export function toDomPrecision(v: number): number;
|
|
|
|
// @public (undocumented)
|
|
export function toFixed(v: number): number;
|
|
|
|
// @public
|
|
export function toPrecision(n: number, precision?: number): number;
|
|
|
|
// @public (undocumented)
|
|
export class Vec2d {
|
|
constructor(x?: number, y?: number, z?: number);
|
|
// (undocumented)
|
|
static Abs(A: VecLike): Vec2d;
|
|
// (undocumented)
|
|
abs(): this;
|
|
// (undocumented)
|
|
static Add(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
add(V: VecLike): this;
|
|
// (undocumented)
|
|
static AddScalar(A: VecLike, n: number): Vec2d;
|
|
// (undocumented)
|
|
addScalar(n: number): this;
|
|
// (undocumented)
|
|
static AddXY(A: VecLike, x: number, y: number): Vec2d;
|
|
// (undocumented)
|
|
addXY(x: number, y: number): this;
|
|
// (undocumented)
|
|
static Angle(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
angle(B: VecLike): number;
|
|
// (undocumented)
|
|
static Average(arr: VecLike[]): Vec2d;
|
|
// (undocumented)
|
|
static Cast(A: VecLike): Vec2d;
|
|
// (undocumented)
|
|
static Clamp(A: Vec2d, min: number, max?: number): Vec2d;
|
|
// (undocumented)
|
|
clamp(min: number, max?: number): this;
|
|
// (undocumented)
|
|
static Clockwise(A: VecLike, B: VecLike, C: VecLike): boolean;
|
|
// (undocumented)
|
|
clone(): Vec2d;
|
|
// (undocumented)
|
|
static Cpr(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
cpr(V: VecLike): number;
|
|
// (undocumented)
|
|
static Cross(A: VecLike, V: VecLike): Vec2d;
|
|
// (undocumented)
|
|
cross(V: VecLike): this;
|
|
// (undocumented)
|
|
static Dist(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
dist(V: VecLike): number;
|
|
// (undocumented)
|
|
static Dist2(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
static DistanceToLineSegment(A: VecLike, B: VecLike, P: VecLike, clamp?: boolean): number;
|
|
// (undocumented)
|
|
distanceToLineSegment(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
static DistanceToLineThroughPoint(A: VecLike, u: VecLike, P: VecLike): number;
|
|
// (undocumented)
|
|
static Div(A: VecLike, t: number): Vec2d;
|
|
// (undocumented)
|
|
div(t: number): this;
|
|
// (undocumented)
|
|
static DivV(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
divV(V: VecLike): this;
|
|
// (undocumented)
|
|
static Dpr(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
dpr(V: VecLike): number;
|
|
// (undocumented)
|
|
static Equals(A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
equals(B: VecLike): boolean;
|
|
// (undocumented)
|
|
static EqualsXY(A: VecLike, x: number, y: number): boolean;
|
|
// (undocumented)
|
|
equalsXY(x: number, y: number): boolean;
|
|
// (undocumented)
|
|
static From({ x, y, z }: Vec2dModel): Vec2d;
|
|
// (undocumented)
|
|
static FromAngle(r: number, length?: number): Vec2d;
|
|
// (undocumented)
|
|
static FromArray(v: number[]): Vec2d;
|
|
// (undocumented)
|
|
static Len(A: VecLike): number;
|
|
// (undocumented)
|
|
len(): number;
|
|
// (undocumented)
|
|
static Len2(A: VecLike): number;
|
|
// (undocumented)
|
|
len2(): number;
|
|
// (undocumented)
|
|
static Lrp(A: VecLike, B: VecLike, t: number): Vec2d;
|
|
// (undocumented)
|
|
lrp(B: VecLike, t: number): Vec2d;
|
|
// (undocumented)
|
|
static Max(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
static Med(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
static Min(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
static Mul(A: VecLike, t: number): Vec2d;
|
|
// (undocumented)
|
|
mul(t: number): this;
|
|
// (undocumented)
|
|
static MulV(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
mulV(V: VecLike): this;
|
|
// (undocumented)
|
|
static NearestPointOnLineSegment(A: VecLike, B: VecLike, P: VecLike, clamp?: boolean): Vec2d;
|
|
static NearestPointOnLineThroughPoint(A: VecLike, u: VecLike, P: VecLike): Vec2d;
|
|
// (undocumented)
|
|
static Neg(A: VecLike): Vec2d;
|
|
// (undocumented)
|
|
neg(): this;
|
|
// (undocumented)
|
|
norm(): this;
|
|
// (undocumented)
|
|
static Nudge(A: VecLike, B: VecLike, distance: number): Vec2d;
|
|
// (undocumented)
|
|
nudge(B: VecLike, distance: number): this;
|
|
// (undocumented)
|
|
static Per(A: VecLike): Vec2d;
|
|
// (undocumented)
|
|
per(): this;
|
|
static PointsBetween(A: Vec2dModel, B: Vec2dModel, steps?: number): Vec2d[];
|
|
// (undocumented)
|
|
get pressure(): number;
|
|
// (undocumented)
|
|
static Pry(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
pry(V: VecLike): number;
|
|
// (undocumented)
|
|
static Rescale(A: VecLike, n: number): Vec2d;
|
|
// (undocumented)
|
|
static Rot(A: VecLike, r?: number): Vec2d;
|
|
// (undocumented)
|
|
rot(r: number): this;
|
|
// (undocumented)
|
|
static RotWith(A: VecLike, C: VecLike, r: number): Vec2d;
|
|
// (undocumented)
|
|
rotWith(C: VecLike, r: number): this;
|
|
// (undocumented)
|
|
static ScaleWithOrigin(A: VecLike, scale: number, origin: VecLike): Vec2d;
|
|
// (undocumented)
|
|
set(x?: number, y?: number, z?: number): this;
|
|
// (undocumented)
|
|
setTo({ x, y, z }: VecLike): this;
|
|
// (undocumented)
|
|
static Slope(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
slope(B: VecLike): number;
|
|
// (undocumented)
|
|
static Snap(A: VecLike, step?: number): Vec2d;
|
|
// (undocumented)
|
|
static SnapToGrid(A: VecLike, gridSize?: number): Vec2d;
|
|
// (undocumented)
|
|
snapToGrid(gridSize: number): this;
|
|
// (undocumented)
|
|
static Sub(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
sub(V: VecLike): this;
|
|
// (undocumented)
|
|
static SubScalar(A: VecLike, n: number): Vec2d;
|
|
// (undocumented)
|
|
subScalar(n: number): this;
|
|
// (undocumented)
|
|
static SubXY(A: VecLike, x: number, y: number): Vec2d;
|
|
// (undocumented)
|
|
subXY(x: number, y: number): this;
|
|
// (undocumented)
|
|
static Tan(A: VecLike, B: VecLike): Vec2d;
|
|
// (undocumented)
|
|
tan(V: VecLike): Vec2d;
|
|
// (undocumented)
|
|
static ToAngle(A: VecLike): number;
|
|
// (undocumented)
|
|
toAngle(): number;
|
|
// (undocumented)
|
|
static ToArray(A: VecLike): number[];
|
|
// (undocumented)
|
|
toArray(): number[];
|
|
// (undocumented)
|
|
static ToFixed(A: VecLike, n?: number): Vec2d;
|
|
// (undocumented)
|
|
toFixed(): Vec2d;
|
|
// (undocumented)
|
|
static ToJson(A: VecLike): {
|
|
x: number;
|
|
y: number;
|
|
z: number | undefined;
|
|
};
|
|
// (undocumented)
|
|
toJson(): Vec2dModel;
|
|
// (undocumented)
|
|
static ToString(A: VecLike): string;
|
|
// (undocumented)
|
|
toString(): string;
|
|
// (undocumented)
|
|
static Uni(A: VecLike): Vec2d;
|
|
// (undocumented)
|
|
uni(): Vec2d;
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: number;
|
|
// (undocumented)
|
|
z: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type VecLike = Vec2d | Vec2dModel;
|
|
|
|
// (No @packageDocumentation comment for this package)
|
|
|
|
```
|