79ca14454e
This PR fixes a bug where alt-dragging the left or right handles of a text shape would not produce the correct outcome: the width would double but the center would change.  This is because the text shape is aspect ratio locked only when dragging handles other than the left or right, but we didn't have the ability to differentiate between that. We've had to add that optionality in, together with a hard-coded override of the normal behavior for text shapes. ### Change Type - [x] `sdk` — Changes the tldraw SDK - [x] `bugfix` — Bug fix ### Test Plan 1. Resize text. 2. Resize text with the alt key held. - [x] Unit Tests ### Release Notes - Fixed a bug with resizing text shapes from the left and right while holding alt.
3083 lines
94 KiB
Markdown
3083 lines
94 KiB
Markdown
## API Report File for "@tldraw/editor"
|
|
|
|
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
|
|
|
|
```ts
|
|
|
|
/// <reference types="react" />
|
|
|
|
import { Atom } from '@tldraw/state';
|
|
import { atom } from '@tldraw/state';
|
|
import { BoxModel } from '@tldraw/tlschema';
|
|
import { ComponentType } from 'react';
|
|
import { Computed } from '@tldraw/state';
|
|
import { computed } from '@tldraw/state';
|
|
import { EmbedDefinition } from '@tldraw/tlschema';
|
|
import { EMPTY_ARRAY } from '@tldraw/state';
|
|
import { EventEmitter } from 'eventemitter3';
|
|
import { Expand } from '@tldraw/utils';
|
|
import { HistoryEntry } from '@tldraw/store';
|
|
import { IndexKey } from '@tldraw/utils';
|
|
import { JsonObject } from '@tldraw/utils';
|
|
import { JSX as JSX_2 } from 'react/jsx-runtime';
|
|
import { LegacyMigrations } from '@tldraw/store';
|
|
import { MigrationSequence } from '@tldraw/store';
|
|
import { NamedExoticComponent } from 'react';
|
|
import { PointerEventHandler } from 'react';
|
|
import { react } from '@tldraw/state';
|
|
import { default as React_2 } from 'react';
|
|
import * as React_3 from 'react';
|
|
import { ReactElement } from 'react';
|
|
import { ReactNode } from 'react';
|
|
import { RecordsDiff } from '@tldraw/store';
|
|
import { SerializedSchema } from '@tldraw/store';
|
|
import { SerializedStore } from '@tldraw/store';
|
|
import { ShapeProps } from '@tldraw/tlschema';
|
|
import { Signal } from '@tldraw/state';
|
|
import { Store } from '@tldraw/store';
|
|
import { StoreSchema } from '@tldraw/store';
|
|
import { StoreSnapshot } from '@tldraw/store';
|
|
import { StyleProp } from '@tldraw/tlschema';
|
|
import { StylePropValue } from '@tldraw/tlschema';
|
|
import { TLArrowShape } from '@tldraw/tlschema';
|
|
import { TLArrowShapeArrowheadStyle } from '@tldraw/tlschema';
|
|
import { TLAsset } from '@tldraw/tlschema';
|
|
import { TLAssetId } from '@tldraw/tlschema';
|
|
import { TLAssetPartial } from '@tldraw/tlschema';
|
|
import { TLBaseShape } from '@tldraw/tlschema';
|
|
import { TLBookmarkAsset } from '@tldraw/tlschema';
|
|
import { TLCamera } from '@tldraw/tlschema';
|
|
import { TLCursor } from '@tldraw/tlschema';
|
|
import { TLCursorType } from '@tldraw/tlschema';
|
|
import { TLDefaultHorizontalAlignStyle } from '@tldraw/tlschema';
|
|
import { TLDocument } from '@tldraw/tlschema';
|
|
import { TLGroupShape } from '@tldraw/tlschema';
|
|
import { TLHandle } from '@tldraw/tlschema';
|
|
import { TLImageAsset } from '@tldraw/tlschema';
|
|
import { TLInstance } from '@tldraw/tlschema';
|
|
import { TLInstancePageState } from '@tldraw/tlschema';
|
|
import { TLInstancePresence } from '@tldraw/tlschema';
|
|
import { TLPage } from '@tldraw/tlschema';
|
|
import { TLPageId } from '@tldraw/tlschema';
|
|
import { TLParentId } from '@tldraw/tlschema';
|
|
import { TLRecord } from '@tldraw/tlschema';
|
|
import { TLScribble } from '@tldraw/tlschema';
|
|
import { TLShape } from '@tldraw/tlschema';
|
|
import { TLShapeId } from '@tldraw/tlschema';
|
|
import { TLShapePartial } from '@tldraw/tlschema';
|
|
import { TLShapePropsMigrations } from '@tldraw/tlschema';
|
|
import { TLStore } from '@tldraw/tlschema';
|
|
import { TLStoreProps } from '@tldraw/tlschema';
|
|
import { TLUnknownShape } from '@tldraw/tlschema';
|
|
import { TLVideoAsset } from '@tldraw/tlschema';
|
|
import { track } from '@tldraw/state';
|
|
import { transact } from '@tldraw/state';
|
|
import { transaction } from '@tldraw/state';
|
|
import { UnknownRecord } from '@tldraw/store';
|
|
import { useComputed } from '@tldraw/state';
|
|
import { useQuickReactor } from '@tldraw/state';
|
|
import { useReactor } from '@tldraw/state';
|
|
import { useValue } from '@tldraw/state';
|
|
import { VecModel } from '@tldraw/tlschema';
|
|
import { whyAmIRunning } from '@tldraw/state';
|
|
|
|
// @public
|
|
export function angleDistance(fromAngle: number, toAngle: number, direction: number): number;
|
|
|
|
// @internal (undocumented)
|
|
export const ANIMATION_MEDIUM_MS = 320;
|
|
|
|
// @internal (undocumented)
|
|
export const ANIMATION_SHORT_MS = 80;
|
|
|
|
// @internal (undocumented)
|
|
export function applyRotationToSnapshotShapes({ delta, editor, snapshot, stage, }: {
|
|
delta: number;
|
|
editor: Editor;
|
|
snapshot: TLRotationSnapshot;
|
|
stage: 'end' | 'one-off' | 'start' | 'update';
|
|
}): void;
|
|
|
|
// @public
|
|
export function approximately(a: number, b: number, precision?: number): boolean;
|
|
|
|
// @public (undocumented)
|
|
export class Arc2d extends Geometry2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & {
|
|
center: Vec;
|
|
end: Vec;
|
|
largeArcFlag: number;
|
|
radius: number;
|
|
start: Vec;
|
|
sweepFlag: number;
|
|
});
|
|
// (undocumented)
|
|
angleEnd: number;
|
|
// (undocumented)
|
|
angleStart: number;
|
|
// (undocumented)
|
|
_center: Vec;
|
|
// (undocumented)
|
|
end: Vec;
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec): boolean;
|
|
// (undocumented)
|
|
length: number;
|
|
// (undocumented)
|
|
measure: number;
|
|
// (undocumented)
|
|
nearestPoint(point: Vec): Vec;
|
|
// (undocumented)
|
|
radius: number;
|
|
// (undocumented)
|
|
start: Vec;
|
|
}
|
|
|
|
// @public
|
|
export function areAnglesCompatible(a: number, b: number): boolean;
|
|
|
|
export { Atom }
|
|
|
|
export { atom }
|
|
|
|
// @public (undocumented)
|
|
export function average(A: VecLike, B: VecLike): string;
|
|
|
|
// @public (undocumented)
|
|
export abstract class BaseBoxShapeTool extends StateNode {
|
|
// (undocumented)
|
|
static children: () => (typeof Idle | typeof Pointing)[];
|
|
// (undocumented)
|
|
static id: string;
|
|
// (undocumented)
|
|
static initial: string;
|
|
// (undocumented)
|
|
onCreate?: (_shape: null | TLShape) => null | void;
|
|
// (undocumented)
|
|
abstract shapeType: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export abstract class BaseBoxShapeUtil<Shape extends TLBaseBoxShape> extends ShapeUtil<Shape> {
|
|
// (undocumented)
|
|
getGeometry(shape: Shape): Geometry2d;
|
|
// (undocumented)
|
|
getHandleSnapGeometry(shape: Shape): HandleSnapGeometry;
|
|
// (undocumented)
|
|
onResize: TLOnResizeHandler<any>;
|
|
}
|
|
|
|
// @public
|
|
export interface BoundsSnapGeometry {
|
|
points?: VecModel[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface BoundsSnapPoint {
|
|
// (undocumented)
|
|
handle?: SelectionCorner;
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class Box {
|
|
constructor(x?: number, y?: number, w?: number, h?: number);
|
|
// (undocumented)
|
|
get aspectRatio(): number;
|
|
// (undocumented)
|
|
get center(): Vec;
|
|
set center(v: Vec);
|
|
// (undocumented)
|
|
clone(): Box;
|
|
// (undocumented)
|
|
static Collides: (A: Box, B: Box) => boolean;
|
|
// (undocumented)
|
|
collides(B: Box): boolean;
|
|
// (undocumented)
|
|
static Common: (boxes: Box[]) => Box;
|
|
// (undocumented)
|
|
static Contains: (A: Box, B: Box) => boolean;
|
|
// (undocumented)
|
|
contains(B: Box): boolean;
|
|
// (undocumented)
|
|
static ContainsPoint: (A: Box, B: VecLike, margin?: number) => boolean;
|
|
// (undocumented)
|
|
containsPoint(V: VecLike, margin?: number): boolean;
|
|
// (undocumented)
|
|
get corners(): Vec[];
|
|
// (undocumented)
|
|
get cornersAndCenter(): Vec[];
|
|
// (undocumented)
|
|
static Equals(a: Box | BoxModel, b: Box | BoxModel): boolean;
|
|
// (undocumented)
|
|
equals(other: Box | BoxModel): boolean;
|
|
// (undocumented)
|
|
static Expand(A: Box, B: Box): Box;
|
|
// (undocumented)
|
|
expand(A: Box): this;
|
|
// (undocumented)
|
|
static ExpandBy(A: Box, n: number): Box;
|
|
// (undocumented)
|
|
expandBy(n: number): this;
|
|
// (undocumented)
|
|
static From(box: BoxModel): Box;
|
|
// (undocumented)
|
|
static FromCenter(center: VecLike, size: VecLike): Box;
|
|
// (undocumented)
|
|
static FromPoints(points: VecLike[]): Box;
|
|
// (undocumented)
|
|
getHandlePoint(handle: SelectionCorner | SelectionEdge): Vec;
|
|
// (undocumented)
|
|
h: number;
|
|
// (undocumented)
|
|
get height(): number;
|
|
set height(n: number);
|
|
// (undocumented)
|
|
static Includes: (A: Box, B: Box) => boolean;
|
|
// (undocumented)
|
|
includes(B: Box): 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(): Vec;
|
|
set point(val: Vec);
|
|
// (undocumented)
|
|
static Resize(box: Box, handle: SelectionCorner | SelectionEdge | string, dx: number, dy: number, isAspectRatioLocked?: boolean): {
|
|
box: Box;
|
|
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: Box): this;
|
|
// (undocumented)
|
|
static Sides: (A: Box, inset?: number) => Vec[][];
|
|
// (undocumented)
|
|
get sides(): Array<[Vec, Vec]>;
|
|
// (undocumented)
|
|
get size(): Vec;
|
|
// (undocumented)
|
|
snapToGrid(size: number): void;
|
|
// (undocumented)
|
|
toFixed(): this;
|
|
// (undocumented)
|
|
toJson(): BoxModel;
|
|
// (undocumented)
|
|
translate(delta: VecLike): this;
|
|
// (undocumented)
|
|
union(box: BoxModel): this;
|
|
// (undocumented)
|
|
w: number;
|
|
// (undocumented)
|
|
get width(): number;
|
|
set width(n: number);
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: number;
|
|
// (undocumented)
|
|
static ZeroFix(other: Box | BoxModel): Box;
|
|
// (undocumented)
|
|
zeroFix(): this;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type BoxLike = Box | BoxModel;
|
|
|
|
// @internal (undocumented)
|
|
export const CAMERA_SLIDE_FRICTION = 0.09;
|
|
|
|
// @public (undocumented)
|
|
export function canonicalizeRotation(a: number): number;
|
|
|
|
// @public (undocumented)
|
|
export class Circle2d extends Geometry2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
isFilled: boolean;
|
|
radius: number;
|
|
x?: number;
|
|
y?: number;
|
|
});
|
|
// (undocumented)
|
|
_center: Vec;
|
|
// (undocumented)
|
|
config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
isFilled: boolean;
|
|
radius: number;
|
|
x?: number;
|
|
y?: number;
|
|
};
|
|
// (undocumented)
|
|
getBounds(): Box;
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
|
|
// (undocumented)
|
|
nearestPoint(point: Vec): Vec;
|
|
// (undocumented)
|
|
radius: number;
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: 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
|
|
export function clockwiseAngleDist(a0: number, a1: number): number;
|
|
|
|
export { computed }
|
|
|
|
// @internal (undocumented)
|
|
export function ContainerProvider({ container, children, }: {
|
|
children: React.ReactNode;
|
|
container: HTMLDivElement;
|
|
}): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export const coreShapes: readonly [typeof GroupShapeUtil];
|
|
|
|
// @public
|
|
export function counterClockwiseAngleDist(a0: number, a1: number): number;
|
|
|
|
// @public
|
|
export function createSessionStateSnapshotSignal(store: TLStore): Signal<null | TLSessionStateSnapshot>;
|
|
|
|
// @public
|
|
export function createTLStore({ initialData, defaultName, id, ...rest }: TLStoreOptions): TLStore;
|
|
|
|
// @public (undocumented)
|
|
export function createTLUser(opts?: {
|
|
derivePresenceState?: ((store: TLStore) => Signal<null | TLInstancePresence>) | undefined;
|
|
setUserPreferences?: ((userPreferences: TLUserPreferences) => void) | undefined;
|
|
userPreferences?: Signal<TLUserPreferences, unknown> | undefined;
|
|
}): TLUser;
|
|
|
|
// @public (undocumented)
|
|
export class CubicBezier2d extends Polyline2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & {
|
|
cp1: Vec;
|
|
cp2: Vec;
|
|
end: Vec;
|
|
start: Vec;
|
|
});
|
|
// (undocumented)
|
|
a: Vec;
|
|
// (undocumented)
|
|
b: Vec;
|
|
// (undocumented)
|
|
c: Vec;
|
|
// (undocumented)
|
|
d: Vec;
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
midPoint(): Vec;
|
|
// (undocumented)
|
|
nearestPoint(A: Vec): Vec;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class CubicSpline2d extends Geometry2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & {
|
|
points: Vec[];
|
|
});
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec): boolean;
|
|
// (undocumented)
|
|
get length(): number;
|
|
// (undocumented)
|
|
_length?: number;
|
|
// (undocumented)
|
|
nearestPoint(A: Vec): Vec;
|
|
// (undocumented)
|
|
points: Vec[];
|
|
// (undocumented)
|
|
get segments(): CubicBezier2d[];
|
|
// (undocumented)
|
|
_segments?: CubicBezier2d[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function dataUrlToFile(url: string, filename: string, mimeType: string): Promise<File>;
|
|
|
|
// @internal (undocumented)
|
|
export type DebugFlag<T> = DebugFlagDef<T> & Atom<T>;
|
|
|
|
// @internal (undocumented)
|
|
export const debugFlags: {
|
|
readonly debugCursors: DebugFlag<boolean>;
|
|
readonly debugGeometry: DebugFlag<boolean>;
|
|
readonly debugSvg: DebugFlag<boolean>;
|
|
readonly editOnType: DebugFlag<boolean>;
|
|
readonly forceSrgb: DebugFlag<boolean>;
|
|
readonly hideShapes: DebugFlag<boolean>;
|
|
readonly logElementRemoves: DebugFlag<boolean>;
|
|
readonly logPointerCaptures: DebugFlag<boolean>;
|
|
readonly logPreventDefaults: DebugFlag<boolean>;
|
|
readonly reconnectOnPing: DebugFlag<boolean>;
|
|
readonly showFps: DebugFlag<boolean>;
|
|
readonly throwToBlob: DebugFlag<boolean>;
|
|
};
|
|
|
|
// @internal (undocumented)
|
|
export const DEFAULT_ANIMATION_OPTIONS: {
|
|
duration: number;
|
|
easing: (t: number) => number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export function DefaultBackground(): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export const DefaultBrush: ({ brush, color, opacity, className }: TLBrushProps) => JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultCanvas({ className }: TLCanvasComponentProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultCollaboratorHint({ className, zoom, point, color, viewport, opacity, }: TLCollaboratorHintProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export const DefaultCursor: NamedExoticComponent<TLCursorProps>;
|
|
|
|
// @public (undocumented)
|
|
export const DefaultErrorFallback: TLErrorFallbackComponent;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultGrid({ x, y, z, size }: TLGridProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultHandle({ handle, isCoarse, className, zoom }: TLHandleProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export const DefaultHandles: ({ children }: TLHandlesProps) => JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultScribble({ scribble, zoom, color, opacity, className }: TLScribbleProps): JSX_2.Element | null;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultSelectionBackground({ bounds, rotation }: TLSelectionBackgroundProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultSelectionForeground({ bounds, rotation }: TLSelectionForegroundProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export const DefaultShapeIndicator: NamedExoticComponent<TLShapeIndicatorProps>;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultSnapIndicator({ className, line, zoom }: TLSnapIndicatorProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export function DefaultSpinner(): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export const DefaultSvgDefs: () => null;
|
|
|
|
// @public (undocumented)
|
|
export const defaultUserPreferences: Readonly<{
|
|
animationSpeed: 0 | 1;
|
|
color: "#02B1CC" | "#11B3A3" | "#39B178" | "#55B467" | "#7B66DC" | "#9D5BD2" | "#BD54C6" | "#E34BA9" | "#EC5E41" | "#F04F88" | "#F2555A" | "#FF802B";
|
|
edgeScrollSpeed: 1;
|
|
isDarkMode: false;
|
|
isSnapMode: false;
|
|
isWrapMode: false;
|
|
locale: "ar" | "ca" | "cs" | "da" | "de" | "en" | "es" | "fa" | "fi" | "fr" | "gl" | "he" | "hi-in" | "hr" | "hu" | "it" | "ja" | "ko-kr" | "ku" | "my" | "ne" | "no" | "pl" | "pt-br" | "pt-pt" | "ro" | "ru" | "sl" | "sv" | "te" | "th" | "tr" | "uk" | "vi" | "zh-cn" | "zh-tw";
|
|
name: "New User";
|
|
}>;
|
|
|
|
// @public
|
|
export function degreesToRadians(d: number): number;
|
|
|
|
// @internal (undocumented)
|
|
export const DOUBLE_CLICK_DURATION = 450;
|
|
|
|
// @internal (undocumented)
|
|
export const DRAG_DISTANCE = 16;
|
|
|
|
// @public (undocumented)
|
|
export const EASINGS: {
|
|
readonly easeInCubic: (t: number) => number;
|
|
readonly easeInExpo: (t: number) => number;
|
|
readonly easeInOutCubic: (t: number) => number;
|
|
readonly easeInOutExpo: (t: number) => number;
|
|
readonly easeInOutQuad: (t: number) => number;
|
|
readonly easeInOutQuart: (t: number) => number;
|
|
readonly easeInOutQuint: (t: number) => number;
|
|
readonly easeInOutSine: (t: number) => number;
|
|
readonly easeInQuad: (t: number) => number;
|
|
readonly easeInQuart: (t: number) => number;
|
|
readonly easeInQuint: (t: number) => number;
|
|
readonly easeInSine: (t: number) => number;
|
|
readonly easeOutCubic: (t: number) => number;
|
|
readonly easeOutExpo: (t: number) => number;
|
|
readonly easeOutQuad: (t: number) => number;
|
|
readonly easeOutQuart: (t: number) => number;
|
|
readonly easeOutQuint: (t: number) => number;
|
|
readonly easeOutSine: (t: number) => number;
|
|
readonly linear: (t: number) => number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export class Edge2d extends Geometry2d {
|
|
constructor(config: {
|
|
end: Vec;
|
|
start: Vec;
|
|
});
|
|
// (undocumented)
|
|
d: Vec;
|
|
// (undocumented)
|
|
end: Vec;
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
|
|
// (undocumented)
|
|
get length(): number;
|
|
// (undocumented)
|
|
_length?: number;
|
|
// (undocumented)
|
|
midPoint(): Vec;
|
|
// (undocumented)
|
|
nearestPoint(point: Vec): Vec;
|
|
// (undocumented)
|
|
start: Vec;
|
|
// (undocumented)
|
|
u: Vec;
|
|
// (undocumented)
|
|
ul: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class Editor extends EventEmitter<TLEventMap> {
|
|
constructor({ store, user, shapeUtils, tools, getContainer, initialState, inferDarkMode, }: TLEditorOptions);
|
|
addOpenMenu(id: string): this;
|
|
alignShapes(shapes: TLShape[] | TLShapeId[], operation: 'bottom' | 'center-horizontal' | 'center-vertical' | 'left' | 'right' | 'top'): this;
|
|
animateShape(partial: null | TLShapePartial | undefined, animationOptions?: TLAnimationOptions): this;
|
|
animateShapes(partials: (null | TLShapePartial | undefined)[], animationOptions?: Partial<{
|
|
duration: number;
|
|
easing: (t: number) => number;
|
|
}>): this;
|
|
animateToShape(shapeId: TLShapeId, opts?: TLAnimationOptions): this;
|
|
animateToUser(userId: string): this;
|
|
// @internal (undocumented)
|
|
annotateError(error: unknown, { origin, willCrashApp, tags, extras, }: {
|
|
extras?: Record<string, unknown>;
|
|
origin: string;
|
|
tags?: Record<string, boolean | number | string>;
|
|
willCrashApp: boolean;
|
|
}): this;
|
|
bail(): this;
|
|
bailToMark(id: string): this;
|
|
batch(fn: () => void, opts?: TLHistoryBatchOptions): this;
|
|
bringForward(shapes: TLShape[] | TLShapeId[]): this;
|
|
bringToFront(shapes: TLShape[] | TLShapeId[]): this;
|
|
cancel(): this;
|
|
cancelDoubleClick(): void;
|
|
// @internal (undocumented)
|
|
capturedPointerId: null | number;
|
|
centerOnPoint(point: VecLike, animation?: TLAnimationOptions): this;
|
|
clearOpenMenus(): this;
|
|
// @internal
|
|
protected _clickManager: ClickManager;
|
|
complete(): this;
|
|
// @internal (undocumented)
|
|
crash(error: unknown): this;
|
|
createAssets(assets: TLAsset[]): this;
|
|
// @internal (undocumented)
|
|
createErrorAnnotations(origin: string, willCrashApp: 'unknown' | boolean): {
|
|
extras: {
|
|
activeStateNode?: string;
|
|
editingShape?: TLUnknownShape;
|
|
inputs?: Record<string, unknown>;
|
|
selectedShapes?: TLUnknownShape[];
|
|
};
|
|
tags: {
|
|
origin: string;
|
|
willCrashApp: 'unknown' | boolean;
|
|
};
|
|
};
|
|
createPage(page: Partial<TLPage>): this;
|
|
createShape<T extends TLUnknownShape>(shape: OptionalKeys<TLShapePartial<T>, 'id'>): this;
|
|
createShapes<T extends TLUnknownShape>(shapes: OptionalKeys<TLShapePartial<T>, 'id'>[]): this;
|
|
deleteAssets(assets: TLAsset[] | TLAssetId[]): this;
|
|
deleteOpenMenu(id: string): this;
|
|
deletePage(page: TLPage | TLPageId): this;
|
|
deleteShape(id: TLShapeId): this;
|
|
// (undocumented)
|
|
deleteShape(shape: TLShape): this;
|
|
deleteShapes(ids: TLShapeId[]): this;
|
|
// (undocumented)
|
|
deleteShapes(shapes: TLShape[]): this;
|
|
deselect(...shapes: TLShape[] | TLShapeId[]): this;
|
|
dispatch: (info: TLEventInfo) => this;
|
|
readonly disposables: Set<() => void>;
|
|
dispose(): void;
|
|
distributeShapes(shapes: TLShape[] | TLShapeId[], operation: 'horizontal' | 'vertical'): this;
|
|
duplicatePage(page: TLPage | TLPageId, createId?: TLPageId): this;
|
|
duplicateShapes(shapes: TLShape[] | TLShapeId[], offset?: VecLike): this;
|
|
readonly environment: EnvironmentManager;
|
|
// @internal (undocumented)
|
|
externalAssetContentHandlers: {
|
|
[K in TLExternalAssetContent['type']]: {
|
|
[Key in K]: ((info: TLExternalAssetContent & {
|
|
type: Key;
|
|
}) => Promise<TLAsset | undefined>) | null;
|
|
}[K];
|
|
};
|
|
// @internal (undocumented)
|
|
externalContentHandlers: {
|
|
[K in TLExternalContent['type']]: {
|
|
[Key in K]: ((info: TLExternalContent & {
|
|
type: Key;
|
|
}) => void) | null;
|
|
}[K];
|
|
};
|
|
findCommonAncestor(shapes: TLShape[] | TLShapeId[], predicate?: (shape: TLShape) => boolean): TLShapeId | undefined;
|
|
findShapeAncestor(shape: TLShape | TLShapeId, predicate: (parent: TLShape) => boolean): TLShape | undefined;
|
|
flipShapes(shapes: TLShape[] | TLShapeId[], operation: 'horizontal' | 'vertical'): this;
|
|
getAncestorPageId(shape?: TLShape | TLShapeId): TLPageId | undefined;
|
|
getArrowInfo(shape: TLArrowShape | TLShapeId): TLArrowInfo | undefined;
|
|
getArrowsBoundTo(shapeId: TLShapeId): {
|
|
arrowId: TLShapeId;
|
|
handleId: "end" | "start";
|
|
}[];
|
|
getAsset(asset: TLAsset | TLAssetId): TLAsset | undefined;
|
|
getAssetForExternalContent(info: TLExternalAssetContent): Promise<TLAsset | undefined>;
|
|
getAssets(): (TLBookmarkAsset | TLImageAsset | TLVideoAsset)[];
|
|
getCamera(): TLCamera;
|
|
getCameraState(): "idle" | "moving";
|
|
getCanRedo(): boolean;
|
|
getCanUndo(): boolean;
|
|
getCollaborators(): TLInstancePresence[];
|
|
getCollaboratorsOnCurrentPage(): TLInstancePresence[];
|
|
getContainer: () => HTMLElement;
|
|
getContentFromCurrentPage(shapes: TLShape[] | TLShapeId[]): TLContent | undefined;
|
|
// @internal
|
|
getCrashingError(): unknown;
|
|
getCroppingShapeId(): null | TLShapeId;
|
|
getCulledShapes(): Set<TLShapeId>;
|
|
getCurrentPage(): TLPage;
|
|
getCurrentPageBounds(): Box | undefined;
|
|
getCurrentPageId(): TLPageId;
|
|
getCurrentPageRenderingShapesSorted(): TLShape[];
|
|
getCurrentPageShapeIds(): Set<TLShapeId>;
|
|
// @internal (undocumented)
|
|
getCurrentPageShapeIdsSorted(): TLShapeId[];
|
|
getCurrentPageShapes(): TLShape[];
|
|
getCurrentPageShapesSorted(): TLShape[];
|
|
getCurrentPageState(): TLInstancePageState;
|
|
getCurrentTool(): StateNode;
|
|
getCurrentToolId(): string;
|
|
getDocumentSettings(): TLDocument;
|
|
getDroppingOverShape(point: VecLike, droppingShapes?: TLShape[]): TLUnknownShape | undefined;
|
|
getEditingShape(): TLShape | undefined;
|
|
getEditingShapeId(): null | TLShapeId;
|
|
getErasingShapeIds(): TLShapeId[];
|
|
getErasingShapes(): NonNullable<TLShape | undefined>[];
|
|
getFocusedGroup(): TLShape | undefined;
|
|
getFocusedGroupId(): TLPageId | TLShapeId;
|
|
getHighestIndexForParent(parent: TLPage | TLParentId | TLShape): IndexKey;
|
|
getHintingShape(): NonNullable<TLShape | undefined>[];
|
|
getHintingShapeIds(): TLShapeId[];
|
|
getHoveredShape(): TLShape | undefined;
|
|
getHoveredShapeId(): null | TLShapeId;
|
|
getInitialMetaForShape(_shape: TLShape): JsonObject;
|
|
getInstanceState(): TLInstance;
|
|
getIsMenuOpen(): boolean;
|
|
getOnlySelectedShape(): null | TLShape;
|
|
getOnlySelectedShapeId(): null | TLShapeId;
|
|
getOpenMenus(): string[];
|
|
getOutermostSelectableShape(shape: TLShape | TLShapeId, filter?: (shape: TLShape) => boolean): TLShape;
|
|
getPage(page: TLPage | TLPageId): TLPage | undefined;
|
|
getPages(): TLPage[];
|
|
getPageShapeIds(page: TLPage | TLPageId): Set<TLShapeId>;
|
|
getPageStates(): TLInstancePageState[];
|
|
getPath(): string;
|
|
getPointInParentSpace(shape: TLShape | TLShapeId, point: VecLike): Vec;
|
|
getPointInShapeSpace(shape: TLShape | TLShapeId, point: VecLike): Vec;
|
|
getRenderingBounds(): Box;
|
|
getRenderingShapes(): {
|
|
backgroundIndex: number;
|
|
id: TLShapeId;
|
|
index: number;
|
|
opacity: number;
|
|
shape: TLShape;
|
|
util: ShapeUtil<TLUnknownShape>;
|
|
}[];
|
|
getSelectedShapeAtPoint(point: VecLike): TLShape | undefined;
|
|
getSelectedShapeIds(): TLShapeId[];
|
|
getSelectedShapes(): TLShape[];
|
|
getSelectionPageBounds(): Box | null;
|
|
getSelectionRotatedPageBounds(): Box | undefined;
|
|
getSelectionRotatedScreenBounds(): Box | undefined;
|
|
getSelectionRotation(): number;
|
|
getShape<T extends TLShape = TLShape>(shape: TLParentId | TLShape): T | undefined;
|
|
getShapeAncestors(shape: TLShape | TLShapeId, acc?: TLShape[]): TLShape[];
|
|
getShapeAndDescendantIds(ids: TLShapeId[]): Set<TLShapeId>;
|
|
getShapeAtPoint(point: VecLike, opts?: {
|
|
filter?: ((shape: TLShape) => boolean) | undefined;
|
|
hitFrameInside?: boolean | undefined;
|
|
hitInside?: boolean | undefined;
|
|
hitLabels?: boolean | undefined;
|
|
hitLocked?: boolean | undefined;
|
|
margin?: number | undefined;
|
|
renderingOnly?: boolean | undefined;
|
|
}): TLShape | undefined;
|
|
getShapeClipPath(shape: TLShape | TLShapeId): string | undefined;
|
|
getShapeGeometry<T extends Geometry2d>(shape: TLShape | TLShapeId): T;
|
|
getShapeHandles<T extends TLShape>(shape: T | T['id']): TLHandle[] | undefined;
|
|
getShapeLocalTransform(shape: TLShape | TLShapeId): Mat;
|
|
getShapeMask(shape: TLShape | TLShapeId): undefined | VecLike[];
|
|
getShapeMaskedPageBounds(shape: TLShape | TLShapeId): Box | undefined;
|
|
getShapePageBounds(shape: TLShape | TLShapeId): Box | undefined;
|
|
getShapePageTransform(shape: TLShape | TLShapeId): Mat;
|
|
getShapeParent(shape?: TLShape | TLShapeId): TLShape | undefined;
|
|
getShapeParentTransform(shape: TLShape | TLShapeId): Mat;
|
|
getShapesAtPoint(point: VecLike, opts?: {
|
|
hitInside?: boolean | undefined;
|
|
margin?: number | undefined;
|
|
}): TLShape[];
|
|
// (undocumented)
|
|
getShapeStyleIfExists<T>(shape: TLShape, style: StyleProp<T>): T | undefined;
|
|
getShapeUtil<S extends TLUnknownShape>(shape: S | TLShapePartial<S>): ShapeUtil<S>;
|
|
// (undocumented)
|
|
getShapeUtil<S extends TLUnknownShape>(type: S['type']): ShapeUtil<S>;
|
|
// (undocumented)
|
|
getShapeUtil<T extends ShapeUtil>(type: T extends ShapeUtil<infer R> ? R['type'] : string): T;
|
|
getSharedOpacity(): SharedStyle<number>;
|
|
getSharedStyles(): ReadonlySharedStyleMap;
|
|
getSortedChildIdsForParent(parent: TLPage | TLParentId | TLShape): TLShapeId[];
|
|
getStateDescendant<T extends StateNode>(path: string): T | undefined;
|
|
getStyleForNextShape<T>(style: StyleProp<T>): T;
|
|
// @deprecated (undocumented)
|
|
getSvg(shapes: TLShape[] | TLShapeId[], opts?: Partial<TLSvgOptions>): Promise<SVGSVGElement | undefined>;
|
|
getSvgElement(shapes: TLShape[] | TLShapeId[], opts?: Partial<TLSvgOptions>): Promise<{
|
|
height: number;
|
|
svg: SVGSVGElement;
|
|
width: number;
|
|
} | undefined>;
|
|
getSvgString(shapes: TLShape[] | TLShapeId[], opts?: Partial<TLSvgOptions>): Promise<{
|
|
height: number;
|
|
svg: string;
|
|
width: number;
|
|
} | undefined>;
|
|
// @internal (undocumented)
|
|
getUnorderedRenderingShapes(useEditorState: boolean): {
|
|
backgroundIndex: number;
|
|
id: TLShapeId;
|
|
index: number;
|
|
opacity: number;
|
|
shape: TLShape;
|
|
util: ShapeUtil;
|
|
}[];
|
|
getViewportPageBounds(): Box;
|
|
getViewportPageCenter(): Vec;
|
|
getViewportScreenBounds(): Box;
|
|
getViewportScreenCenter(): Vec;
|
|
getZoomLevel(): number;
|
|
groupShapes(shapes: TLShape[] | TLShapeId[], groupId?: TLShapeId): this;
|
|
hasAncestor(shape: TLShape | TLShapeId | undefined, ancestorId: TLShapeId): boolean;
|
|
readonly history: HistoryManager<TLRecord>;
|
|
inputs: {
|
|
buttons: Set<number>;
|
|
keys: Set<string>;
|
|
originScreenPoint: Vec;
|
|
originPagePoint: Vec;
|
|
currentScreenPoint: Vec;
|
|
currentPagePoint: Vec;
|
|
previousScreenPoint: Vec;
|
|
previousPagePoint: Vec;
|
|
pointerVelocity: Vec;
|
|
altKey: boolean;
|
|
ctrlKey: boolean;
|
|
isPen: boolean;
|
|
shiftKey: boolean;
|
|
isDragging: boolean;
|
|
isEditing: boolean;
|
|
isPanning: boolean;
|
|
isPinching: boolean;
|
|
isPointing: boolean;
|
|
};
|
|
interrupt(): this;
|
|
isAncestorSelected(shape: TLShape | TLShapeId): boolean;
|
|
isIn(path: string): boolean;
|
|
isInAny(...paths: string[]): boolean;
|
|
isPointInShape(shape: TLShape | TLShapeId, point: VecLike, opts?: {
|
|
hitInside?: boolean | undefined;
|
|
margin?: number | undefined;
|
|
}): boolean;
|
|
isShapeInPage(shape: TLShape | TLShapeId, pageId?: TLPageId): boolean;
|
|
isShapeOfType<T extends TLUnknownShape>(shape: TLUnknownShape, type: T['type']): shape is T;
|
|
// (undocumented)
|
|
isShapeOfType<T extends TLUnknownShape>(shapeId: TLUnknownShape['id'], type: T['type']): shapeId is T['id'];
|
|
isShapeOrAncestorLocked(shape?: TLShape): boolean;
|
|
// (undocumented)
|
|
isShapeOrAncestorLocked(id?: TLShapeId): boolean;
|
|
mark(markId?: string): this;
|
|
moveShapesToPage(shapes: TLShape[] | TLShapeId[], pageId: TLPageId): this;
|
|
nudgeShapes(shapes: TLShape[] | TLShapeId[], offset: VecLike): this;
|
|
packShapes(shapes: TLShape[] | TLShapeId[], gap: number): this;
|
|
pageToScreen(point: VecLike): {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
pageToViewport(point: VecLike): {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
pan(offset: VecLike, animation?: TLAnimationOptions): this;
|
|
panZoomIntoView(ids: TLShapeId[], animation?: TLAnimationOptions): this;
|
|
popFocusedGroupId(): this;
|
|
putContentOntoCurrentPage(content: TLContent, options?: {
|
|
point?: VecLike;
|
|
preserveIds?: boolean;
|
|
preservePosition?: boolean;
|
|
select?: boolean;
|
|
}): this;
|
|
putExternalContent(info: TLExternalContent): Promise<void>;
|
|
redo(): this;
|
|
registerExternalAssetHandler<T extends TLExternalAssetContent['type']>(type: T, handler: ((info: TLExternalAssetContent & {
|
|
type: T;
|
|
}) => Promise<TLAsset>) | null): this;
|
|
registerExternalContentHandler<T extends TLExternalContent['type']>(type: T, handler: ((info: T extends TLExternalContent['type'] ? TLExternalContent & {
|
|
type: T;
|
|
} : TLExternalContent) => void) | null): this;
|
|
renamePage(page: TLPage | TLPageId, name: string): this;
|
|
renderingBoundsMargin: number;
|
|
reparentShapes(shapes: TLShape[] | TLShapeId[], parentId: TLParentId, insertIndex?: IndexKey): this;
|
|
resetZoom(point?: Vec, animation?: TLAnimationOptions): this;
|
|
resizeShape(shape: TLShape | TLShapeId, scale: VecLike, options?: TLResizeShapeOptions): this;
|
|
readonly root: RootState;
|
|
rotateShapesBy(shapes: TLShape[] | TLShapeId[], delta: number): this;
|
|
screenToPage(point: VecLike): {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
readonly scribbles: ScribbleManager;
|
|
select(...shapes: TLShape[] | TLShapeId[]): this;
|
|
selectAll(): this;
|
|
selectNone(): this;
|
|
sendBackward(shapes: TLShape[] | TLShapeId[]): this;
|
|
sendToBack(shapes: TLShape[] | TLShapeId[]): this;
|
|
setCamera(point: VecLike, animation?: TLAnimationOptions): this;
|
|
setCroppingShape(shape: null | TLShape | TLShapeId): this;
|
|
setCurrentPage(page: TLPage | TLPageId): this;
|
|
setCurrentTool(id: string, info?: {}): this;
|
|
setCursor: (cursor: Partial<TLCursor>) => this;
|
|
setEditingShape(shape: null | TLShape | TLShapeId): this;
|
|
setErasingShapes(shapes: TLShape[] | TLShapeId[]): this;
|
|
setFocusedGroup(shape: null | TLGroupShape | TLShapeId): this;
|
|
setHintingShapes(shapes: TLShape[] | TLShapeId[]): this;
|
|
setHoveredShape(shape: null | TLShape | TLShapeId): this;
|
|
setOpacityForNextShapes(opacity: number, historyOptions?: TLHistoryBatchOptions): this;
|
|
setOpacityForSelectedShapes(opacity: number): this;
|
|
setSelectedShapes(shapes: TLShape[] | TLShapeId[]): this;
|
|
setStyleForNextShapes<T>(style: StyleProp<T>, value: T, historyOptions?: TLHistoryBatchOptions): this;
|
|
setStyleForSelectedShapes<S extends StyleProp<any>>(style: S, value: StylePropValue<S>): this;
|
|
shapeUtils: {
|
|
readonly [K in string]?: ShapeUtil<TLUnknownShape>;
|
|
};
|
|
readonly sideEffects: SideEffectManager<this>;
|
|
slideCamera(opts?: {
|
|
direction: VecLike;
|
|
friction: number;
|
|
speed: number;
|
|
speedThreshold?: number | undefined;
|
|
}): this;
|
|
readonly snaps: SnapManager;
|
|
stackShapes(shapes: TLShape[] | TLShapeId[], operation: 'horizontal' | 'vertical', gap: number): this;
|
|
startFollowingUser(userId: string): this;
|
|
stopCameraAnimation(): this;
|
|
stopFollowingUser(): this;
|
|
readonly store: TLStore;
|
|
stretchShapes(shapes: TLShape[] | TLShapeId[], operation: 'horizontal' | 'vertical'): this;
|
|
// (undocumented)
|
|
styleProps: {
|
|
[key: string]: Map<StyleProp<any>, string>;
|
|
};
|
|
readonly textMeasure: TextManager;
|
|
toggleLock(shapes: TLShape[] | TLShapeId[]): this;
|
|
undo(): this;
|
|
ungroupShapes(ids: TLShapeId[]): this;
|
|
// (undocumented)
|
|
ungroupShapes(ids: TLShape[]): this;
|
|
updateAssets(assets: TLAssetPartial[]): this;
|
|
updateCurrentPageState(partial: Partial<Omit<TLInstancePageState, 'editingShapeId' | 'focusedGroupId' | 'pageId' | 'selectedShapeIds'>>, historyOptions?: TLHistoryBatchOptions): this;
|
|
// (undocumented)
|
|
_updateCurrentPageState: (partial: Partial<Omit<TLInstancePageState, 'selectedShapeIds'>>, historyOptions?: TLHistoryBatchOptions) => void;
|
|
updateDocumentSettings(settings: Partial<TLDocument>): this;
|
|
updateInstanceState(partial: Partial<Omit<TLInstance, 'currentPageId'>>, historyOptions?: TLHistoryBatchOptions): this;
|
|
updatePage(partial: RequiredKeys<TLPage, 'id'>): this;
|
|
// @internal
|
|
updateRenderingBounds(): this;
|
|
updateShape<T extends TLUnknownShape>(partial: null | TLShapePartial<T> | undefined): this;
|
|
updateShapes<T extends TLUnknownShape>(partials: (null | TLShapePartial<T> | undefined)[]): this;
|
|
updateViewportScreenBounds(screenBounds: Box, center?: boolean): this;
|
|
readonly user: UserPreferencesManager;
|
|
visitDescendants(parent: TLPage | TLParentId | TLShape, visitor: (id: TLShapeId) => false | void): this;
|
|
zoomIn(point?: Vec, animation?: TLAnimationOptions): this;
|
|
zoomOut(point?: Vec, animation?: TLAnimationOptions): this;
|
|
zoomToBounds(bounds: Box, opts?: {
|
|
inset?: number;
|
|
targetZoom?: number;
|
|
} & TLAnimationOptions): this;
|
|
zoomToContent(opts?: TLAnimationOptions): this;
|
|
zoomToFit(animation?: TLAnimationOptions): this;
|
|
zoomToSelection(animation?: TLAnimationOptions): this;
|
|
}
|
|
|
|
// @internal (undocumented)
|
|
export const EditorContext: React_2.Context<Editor>;
|
|
|
|
// @public (undocumented)
|
|
export class Ellipse2d extends Geometry2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
height: number;
|
|
width: number;
|
|
});
|
|
// (undocumented)
|
|
config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
height: number;
|
|
width: number;
|
|
};
|
|
// (undocumented)
|
|
get edges(): Edge2d[];
|
|
// (undocumented)
|
|
_edges?: Edge2d[];
|
|
// (undocumented)
|
|
getBounds(): Box;
|
|
// (undocumented)
|
|
getVertices(): any[];
|
|
// (undocumented)
|
|
h: number;
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec): boolean;
|
|
// (undocumented)
|
|
nearestPoint(A: Vec): Vec;
|
|
// (undocumented)
|
|
w: number;
|
|
}
|
|
|
|
export { EMPTY_ARRAY }
|
|
|
|
// @public (undocumented)
|
|
export class ErrorBoundary extends React_3.Component<React_3.PropsWithRef<React_3.PropsWithChildren<TLErrorBoundaryProps>>, TLErrorBoundaryState> {
|
|
// (undocumented)
|
|
componentDidCatch(error: unknown): void;
|
|
// (undocumented)
|
|
static getDerivedStateFromError(error: Error): {
|
|
error: Error;
|
|
};
|
|
// (undocumented)
|
|
render(): boolean | JSX_2.Element | Iterable<React_3.ReactNode> | null | number | string | undefined;
|
|
// (undocumented)
|
|
state: TLErrorBoundaryState;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function ErrorScreen({ children }: {
|
|
children: ReactNode;
|
|
}): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export const EVENT_NAME_MAP: Record<Exclude<TLEventName, TLPinchEventName>, keyof TLEventHandlers>;
|
|
|
|
// @internal (undocumented)
|
|
export function extractSessionStateFromLegacySnapshot(store: Record<string, UnknownRecord>): null | TLSessionStateSnapshot;
|
|
|
|
// @internal (undocumented)
|
|
export const featureFlags: Record<string, DebugFlag<boolean>>;
|
|
|
|
// @public (undocumented)
|
|
export type GapsSnapIndicator = {
|
|
direction: 'horizontal' | 'vertical';
|
|
gaps: Array<{
|
|
endEdge: [VecLike, VecLike];
|
|
startEdge: [VecLike, VecLike];
|
|
}>;
|
|
id: string;
|
|
type: 'gaps';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export abstract class Geometry2d {
|
|
constructor(opts: Geometry2dOptions);
|
|
// (undocumented)
|
|
get area(): number;
|
|
// (undocumented)
|
|
get bounds(): Box;
|
|
// (undocumented)
|
|
get center(): Vec;
|
|
// (undocumented)
|
|
debugColor?: string;
|
|
// (undocumented)
|
|
distanceToLineSegment(A: Vec, B: Vec): number;
|
|
// (undocumented)
|
|
distanceToPoint(point: Vec, hitInside?: boolean): number;
|
|
// (undocumented)
|
|
getArea(): number;
|
|
// (undocumented)
|
|
getBounds(): Box;
|
|
// (undocumented)
|
|
abstract getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(point: Vec, margin?: number, hitInside?: boolean): boolean;
|
|
// (undocumented)
|
|
ignore?: boolean;
|
|
// (undocumented)
|
|
isClosed: boolean;
|
|
// (undocumented)
|
|
isFilled: boolean;
|
|
// (undocumented)
|
|
isLabel: boolean;
|
|
// (undocumented)
|
|
isPointInBounds(point: Vec, margin?: number): boolean;
|
|
// (undocumented)
|
|
abstract nearestPoint(point: Vec): Vec;
|
|
// (undocumented)
|
|
nearestPointOnLineSegment(A: Vec, B: Vec): Vec;
|
|
// (undocumented)
|
|
toSimpleSvgPath(): string;
|
|
// (undocumented)
|
|
get vertices(): Vec[];
|
|
}
|
|
|
|
// @public
|
|
export function getArcMeasure(A: number, B: number, sweepFlag: number, largeArcFlag: number): number;
|
|
|
|
// @public (undocumented)
|
|
export function getArrowTerminalsInArrowSpace(editor: Editor, shape: TLArrowShape): {
|
|
end: Vec;
|
|
start: Vec;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export function getCursor(cursor: TLCursorType, rotation?: number, color?: string): string;
|
|
|
|
// @public (undocumented)
|
|
export function getFreshUserPreferences(): TLUserPreferences;
|
|
|
|
// @public
|
|
export function getIncrementedName(name: string, others: string[]): string;
|
|
|
|
// @public (undocumented)
|
|
export function getPointerInfo(e: PointerEvent | React.PointerEvent): {
|
|
altKey: boolean;
|
|
button: number;
|
|
ctrlKey: boolean;
|
|
isPen: boolean;
|
|
point: {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
pointerId: number;
|
|
shiftKey: boolean;
|
|
};
|
|
|
|
// @public
|
|
export function getPointInArcT(mAB: number, A: number, B: number, P: number): number;
|
|
|
|
// @public
|
|
export function getPointOnCircle(center: VecLike, r: number, a: number): Vec;
|
|
|
|
// @public (undocumented)
|
|
export function getPolygonVertices(width: number, height: number, sides: number): Vec[];
|
|
|
|
// @internal (undocumented)
|
|
export function getRotationSnapshot({ editor }: {
|
|
editor: Editor;
|
|
}): null | TLRotationSnapshot;
|
|
|
|
// @public
|
|
export function getSvgPathFromPoints(points: VecLike[], closed?: boolean): string;
|
|
|
|
// @public (undocumented)
|
|
export function getUserPreferences(): TLUserPreferences;
|
|
|
|
// @public (undocumented)
|
|
export const GRID_STEPS: {
|
|
mid: number;
|
|
min: number;
|
|
step: number;
|
|
}[];
|
|
|
|
// @public (undocumented)
|
|
export class Group2d extends Geometry2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & {
|
|
children: Geometry2d[];
|
|
});
|
|
// (undocumented)
|
|
children: Geometry2d[];
|
|
// (undocumented)
|
|
distanceToPoint(point: Vec, hitInside?: boolean): number;
|
|
// (undocumented)
|
|
getArea(): number;
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec, zoom: number): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(point: Vec, margin: number, hitInside: boolean): boolean;
|
|
// (undocumented)
|
|
ignoredChildren: Geometry2d[];
|
|
// (undocumented)
|
|
nearestPoint(point: Vec): Vec;
|
|
// (undocumented)
|
|
toSimpleSvgPath(): string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class GroupShapeUtil extends ShapeUtil<TLGroupShape> {
|
|
// (undocumented)
|
|
canBind: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLGroupShape): JSX_2.Element | null;
|
|
// (undocumented)
|
|
getDefaultProps(): TLGroupShape['props'];
|
|
// (undocumented)
|
|
getGeometry(shape: TLGroupShape): Geometry2d;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: () => boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLGroupShape): JSX_2.Element;
|
|
// (undocumented)
|
|
static migrations: TLShapePropsMigrations;
|
|
// (undocumented)
|
|
onChildrenChange: TLOnChildrenChangeHandler<TLGroupShape>;
|
|
// (undocumented)
|
|
static props: ShapeProps<TLGroupShape>;
|
|
// (undocumented)
|
|
static type: "group";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const HALF_PI: number;
|
|
|
|
// @public
|
|
export interface HandleSnapGeometry {
|
|
getSelfSnapOutline?(handle: TLHandle): Geometry2d | null;
|
|
getSelfSnapPoints?(handle: TLHandle): VecModel[];
|
|
outline?: Geometry2d | null;
|
|
points?: VecModel[];
|
|
}
|
|
|
|
// @public
|
|
export function hardReset({ shouldReload }?: {
|
|
shouldReload?: boolean | undefined;
|
|
}): Promise<void>;
|
|
|
|
// @public (undocumented)
|
|
export function hardResetEditor(): void;
|
|
|
|
// @internal (undocumented)
|
|
export const HASH_PATTERN_ZOOM_NAMES: Record<string, string>;
|
|
|
|
// @public (undocumented)
|
|
export class HistoryManager<R extends UnknownRecord> {
|
|
constructor(opts: {
|
|
annotateError?: (error: unknown) => void;
|
|
store: Store<R>;
|
|
});
|
|
// (undocumented)
|
|
bail: () => this;
|
|
// (undocumented)
|
|
bailToMark: (id: string) => this;
|
|
// (undocumented)
|
|
batch: (fn: () => void, opts?: TLHistoryBatchOptions) => this;
|
|
// (undocumented)
|
|
clear(): void;
|
|
// @internal (undocumented)
|
|
debug(): {
|
|
pendingDiff: {
|
|
diff: RecordsDiff<R>;
|
|
isEmpty: boolean;
|
|
};
|
|
redos: (NonNullable<TLHistoryEntry<R>> | undefined)[];
|
|
state: HistoryRecorderState;
|
|
undos: (NonNullable<TLHistoryEntry<R>> | undefined)[];
|
|
};
|
|
// (undocumented)
|
|
readonly dispose: () => void;
|
|
// (undocumented)
|
|
getNumRedos(): number;
|
|
// (undocumented)
|
|
getNumUndos(): number;
|
|
// (undocumented)
|
|
ignore(fn: () => void): this;
|
|
// @internal (undocumented)
|
|
_isInBatch: boolean;
|
|
// (undocumented)
|
|
mark: (id?: string) => string;
|
|
// (undocumented)
|
|
onBatchComplete: () => void;
|
|
// (undocumented)
|
|
redo: () => this | undefined;
|
|
// @internal (undocumented)
|
|
stacks: Atom< {
|
|
redos: Stack<TLHistoryEntry<R>>;
|
|
undos: Stack<TLHistoryEntry<R>>;
|
|
}, unknown>;
|
|
// (undocumented)
|
|
undo: () => this;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const HIT_TEST_MARGIN = 8;
|
|
|
|
// @public (undocumented)
|
|
export function HTMLContainer({ children, className, ...rest }: HTMLContainerProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export type HTMLContainerProps = React_3.HTMLAttributes<HTMLDivElement>;
|
|
|
|
// @public
|
|
export function intersectCircleCircle(c1: VecLike, r1: number, c2: VecLike, r2: number): Vec[];
|
|
|
|
// @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 | Vec;
|
|
|
|
// @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: Box): null | VecLike[];
|
|
|
|
// @public
|
|
export function intersectPolygonPolygon(polygonA: VecLike[], polygonB: VecLike[]): null | VecLike[];
|
|
|
|
// @public
|
|
export const isSafeFloat: (n: number) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export function linesIntersect(A: VecLike, B: VecLike, C: VecLike, D: VecLike): boolean;
|
|
|
|
// @public (undocumented)
|
|
export function LoadingScreen({ children }: {
|
|
children: ReactNode;
|
|
}): JSX_2.Element;
|
|
|
|
// @public
|
|
export function loadSessionStateSnapshotIntoStore(store: TLStore, snapshot: TLSessionStateSnapshot): void;
|
|
|
|
// @public (undocumented)
|
|
export function loopToHtmlElement(elm: Element): HTMLElement;
|
|
|
|
// @public (undocumented)
|
|
export class Mat {
|
|
constructor(a: number, b: number, c: number, d: number, e: number, f: number);
|
|
// (undocumented)
|
|
a: number;
|
|
// (undocumented)
|
|
static Absolute(m: MatLike): MatModel;
|
|
// (undocumented)
|
|
static applyToBounds(m: MatLike, box: Box): Box;
|
|
// (undocumented)
|
|
applyToPoint(point: VecLike): Vec;
|
|
// (undocumented)
|
|
static applyToPoint(m: MatLike, point: VecLike): Vec;
|
|
// (undocumented)
|
|
applyToPoints(points: VecLike[]): Vec[];
|
|
// (undocumented)
|
|
static applyToPoints(m: MatLike, points: VecLike[]): Vec[];
|
|
// (undocumented)
|
|
static applyToXY(m: MatLike, x: number, y: number): number[];
|
|
// (undocumented)
|
|
b: number;
|
|
// (undocumented)
|
|
c: number;
|
|
// (undocumented)
|
|
static Cast(m: MatLike): Mat;
|
|
// (undocumented)
|
|
clone(): Mat;
|
|
// (undocumented)
|
|
static Compose(...matrices: MatLike[]): Mat;
|
|
// (undocumented)
|
|
d: number;
|
|
// (undocumented)
|
|
static Decompose(m: MatLike): {
|
|
rotation: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
x: number;
|
|
y: number;
|
|
};
|
|
// (undocumented)
|
|
decompose(): {
|
|
rotation: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
x: number;
|
|
y: number;
|
|
};
|
|
// (undocumented)
|
|
decomposed(): {
|
|
rotation: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
x: number;
|
|
y: number;
|
|
};
|
|
// (undocumented)
|
|
e: number;
|
|
// (undocumented)
|
|
equals(m: Mat | MatModel): boolean;
|
|
// (undocumented)
|
|
f: number;
|
|
// (undocumented)
|
|
static From(m: MatLike): Mat;
|
|
// (undocumented)
|
|
static Identity(): Mat;
|
|
// (undocumented)
|
|
identity(): this;
|
|
// (undocumented)
|
|
static Inverse(m: MatModel): MatModel;
|
|
// (undocumented)
|
|
invert(): this;
|
|
// (undocumented)
|
|
static Multiply(m1: MatModel, m2: MatModel): MatModel;
|
|
// (undocumented)
|
|
multiply(m: Mat | MatModel): this;
|
|
// (undocumented)
|
|
static Point(m: MatLike): Vec;
|
|
// (undocumented)
|
|
point(): Vec;
|
|
// (undocumented)
|
|
static Rotate(r: number, cx?: number, cy?: number): Mat;
|
|
// (undocumented)
|
|
rotate(r: number, cx?: number, cy?: number): Mat;
|
|
// (undocumented)
|
|
static Rotation(m: MatLike): number;
|
|
// (undocumented)
|
|
rotation(): number;
|
|
// (undocumented)
|
|
static Scale: {
|
|
(x: number, y: number, cx: number, cy: number): MatModel;
|
|
(x: number, y: number): MatModel;
|
|
};
|
|
// (undocumented)
|
|
scale(x: number, y: number): this;
|
|
// (undocumented)
|
|
setTo(model: MatModel): 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): Mat;
|
|
// (undocumented)
|
|
translate(x: number, y: number): Mat;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type MatLike = Mat | MatModel;
|
|
|
|
// @public (undocumented)
|
|
export interface MatModel {
|
|
// (undocumented)
|
|
a: number;
|
|
// (undocumented)
|
|
b: number;
|
|
// (undocumented)
|
|
c: number;
|
|
// (undocumented)
|
|
d: number;
|
|
// (undocumented)
|
|
e: number;
|
|
// (undocumented)
|
|
f: number;
|
|
}
|
|
|
|
// @internal (undocumented)
|
|
export const MAX_PAGES = 40;
|
|
|
|
// @internal (undocumented)
|
|
export const MAX_SHAPES_PER_PAGE = 2000;
|
|
|
|
// @internal (undocumented)
|
|
export const MAX_ZOOM = 8;
|
|
|
|
// @internal (undocumented)
|
|
export const MIN_ZOOM = 0.1;
|
|
|
|
// @public
|
|
export function moveCameraWhenCloseToEdge(editor: Editor): void;
|
|
|
|
// @internal (undocumented)
|
|
export const MULTI_CLICK_DURATION = 200;
|
|
|
|
// @internal (undocumented)
|
|
export function normalizeWheel(event: React.WheelEvent<HTMLElement> | WheelEvent): {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export function openWindow(url: string, target?: string): void;
|
|
|
|
// @internal (undocumented)
|
|
export function OptionalErrorBoundary({ children, fallback, ...props }: Omit<TLErrorBoundaryProps, 'fallback'> & {
|
|
fallback: TLErrorFallbackComponent;
|
|
}): JSX_2.Element;
|
|
|
|
// @public
|
|
export function perimeterOfEllipse(rx: number, ry: number): number;
|
|
|
|
// @public (undocumented)
|
|
export const PI: number;
|
|
|
|
// @public (undocumented)
|
|
export const PI2: number;
|
|
|
|
// @public (undocumented)
|
|
export class Point2d extends Geometry2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & {
|
|
margin: number;
|
|
point: Vec;
|
|
});
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec, margin: number): boolean;
|
|
// (undocumented)
|
|
nearestPoint(): Vec;
|
|
// (undocumented)
|
|
point: Vec;
|
|
}
|
|
|
|
// @public
|
|
export function pointInPolygon(A: VecLike, points: VecLike[]): boolean;
|
|
|
|
// @public (undocumented)
|
|
export type PointsSnapIndicator = {
|
|
id: string;
|
|
points: VecLike[];
|
|
type: 'points';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export class Polygon2d extends Polyline2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
points: Vec[];
|
|
});
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function polygonIntersectsPolyline(polygon: VecLike[], polyline: VecLike[]): boolean;
|
|
|
|
// @public (undocumented)
|
|
export function polygonsIntersect(a: VecLike[], b: VecLike[]): boolean;
|
|
|
|
// @public (undocumented)
|
|
export class Polyline2d extends Geometry2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & {
|
|
points: Vec[];
|
|
});
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
// (undocumented)
|
|
hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
|
|
// (undocumented)
|
|
get length(): number;
|
|
// (undocumented)
|
|
_length?: number;
|
|
// (undocumented)
|
|
nearestPoint(A: Vec): Vec;
|
|
// (undocumented)
|
|
points: Vec[];
|
|
// (undocumented)
|
|
get segments(): Edge2d[];
|
|
// (undocumented)
|
|
_segments?: Edge2d[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function precise(A: VecLike): string;
|
|
|
|
// @public
|
|
export function preventDefault(event: Event | React_2.BaseSyntheticEvent): void;
|
|
|
|
// @public
|
|
export function radiansToDegrees(r: number): number;
|
|
|
|
// @public
|
|
export function rangeIntersection(a0: number, a1: number, b0: number, b1: number): [number, number] | null;
|
|
|
|
export { react }
|
|
|
|
// @public
|
|
export class ReadonlySharedStyleMap {
|
|
// (undocumented)
|
|
[Symbol.iterator](): IterableIterator<[StyleProp<any>, SharedStyle<unknown>]>;
|
|
constructor(entries?: Iterable<[StyleProp<unknown>, SharedStyle<unknown>]>);
|
|
// (undocumented)
|
|
entries(): IterableIterator<[StyleProp<any>, SharedStyle<unknown>]>;
|
|
// (undocumented)
|
|
equals(other: ReadonlySharedStyleMap): boolean;
|
|
// (undocumented)
|
|
get<T>(prop: StyleProp<T>): SharedStyle<T> | undefined;
|
|
// (undocumented)
|
|
getAsKnownValue<T>(prop: StyleProp<T>): T | undefined;
|
|
// (undocumented)
|
|
keys(): IterableIterator<StyleProp<any>>;
|
|
// @internal (undocumented)
|
|
protected map: Map<StyleProp<any>, SharedStyle<unknown>>;
|
|
// (undocumented)
|
|
get size(): number;
|
|
// (undocumented)
|
|
values(): IterableIterator<SharedStyle<unknown>>;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class Rectangle2d extends Polygon2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
height: number;
|
|
width: number;
|
|
x?: number;
|
|
y?: number;
|
|
});
|
|
// (undocumented)
|
|
getBounds(): Box;
|
|
// (undocumented)
|
|
h: number;
|
|
// (undocumented)
|
|
w: number;
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function refreshPage(): void;
|
|
|
|
// @public (undocumented)
|
|
export function releasePointerCapture(element: Element, event: PointerEvent | React_2.PointerEvent<Element>): void;
|
|
|
|
// @public (undocumented)
|
|
export type RequiredKeys<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
|
|
|
|
// @public (undocumented)
|
|
export function resizeBox(shape: TLBaseBoxShape, info: {
|
|
handle: TLResizeHandle;
|
|
initialBounds: Box;
|
|
initialShape: TLBaseBoxShape;
|
|
mode: TLResizeMode;
|
|
newPoint: VecModel;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
}, opts?: Partial<{
|
|
maxHeight: number;
|
|
maxWidth: number;
|
|
minHeight: number;
|
|
minWidth: number;
|
|
}>): {
|
|
props: {
|
|
h: number;
|
|
w: number;
|
|
};
|
|
x: number;
|
|
y: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type ResizeBoxOptions = Partial<{
|
|
maxHeight: number;
|
|
maxWidth: number;
|
|
minHeight: number;
|
|
minWidth: number;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export const ROTATE_CORNER_TO_SELECTION_CORNER: {
|
|
readonly bottom_left_rotate: "bottom_left";
|
|
readonly bottom_right_rotate: "bottom_right";
|
|
readonly mobile_rotate: "top_left";
|
|
readonly top_left_rotate: "top_left";
|
|
readonly top_right_rotate: "top_right";
|
|
};
|
|
|
|
// @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 const runtime: {
|
|
hardReset: () => void;
|
|
openWindow: (url: string, target: string) => void;
|
|
refreshPage: () => void;
|
|
};
|
|
|
|
// @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 setPointerCapture(element: Element, event: PointerEvent | React_2.PointerEvent<Element>): void;
|
|
|
|
// @public (undocumented)
|
|
export function setRuntimeOverrides(input: Partial<typeof runtime>): void;
|
|
|
|
// @public (undocumented)
|
|
export function setUserPreferences(user: TLUserPreferences): void;
|
|
|
|
// @public (undocumented)
|
|
export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
|
|
constructor(editor: Editor);
|
|
// @internal
|
|
backgroundComponent?(shape: Shape): any;
|
|
canBind: <K>(_shape: Shape, _otherShape?: K) => boolean;
|
|
canCrop: TLShapeUtilFlag<Shape>;
|
|
canDropShapes(shape: Shape, shapes: TLShape[]): boolean;
|
|
canEdit: TLShapeUtilFlag<Shape>;
|
|
canEditInReadOnly: TLShapeUtilFlag<Shape>;
|
|
canReceiveNewChildrenOfType(shape: Shape, type: TLShape['type']): boolean;
|
|
canResize: TLShapeUtilFlag<Shape>;
|
|
canScroll: TLShapeUtilFlag<Shape>;
|
|
canSnap: TLShapeUtilFlag<Shape>;
|
|
abstract component(shape: Shape): any;
|
|
// (undocumented)
|
|
editor: Editor;
|
|
// @internal (undocumented)
|
|
expandSelectionOutlinePx(shape: Shape): number;
|
|
getBoundsSnapGeometry(shape: Shape): BoundsSnapGeometry;
|
|
getCanvasSvgDefs(): TLShapeUtilCanvasSvgDef[];
|
|
abstract getDefaultProps(): Shape['props'];
|
|
abstract getGeometry(shape: Shape): Geometry2d;
|
|
getHandles?(shape: Shape): TLHandle[];
|
|
getHandleSnapGeometry(shape: Shape): HandleSnapGeometry;
|
|
hideResizeHandles: TLShapeUtilFlag<Shape>;
|
|
hideRotateHandle: TLShapeUtilFlag<Shape>;
|
|
hideSelectionBoundsBg: TLShapeUtilFlag<Shape>;
|
|
hideSelectionBoundsFg: TLShapeUtilFlag<Shape>;
|
|
abstract indicator(shape: Shape): any;
|
|
isAspectRatioLocked: TLShapeUtilFlag<Shape>;
|
|
// (undocumented)
|
|
static migrations?: LegacyMigrations | TLShapePropsMigrations;
|
|
onBeforeCreate?: TLOnBeforeCreateHandler<Shape>;
|
|
onBeforeUpdate?: TLOnBeforeUpdateHandler<Shape>;
|
|
// @internal
|
|
onBindingChange?: TLOnBindingChangeHandler<Shape>;
|
|
onChildrenChange?: TLOnChildrenChangeHandler<Shape>;
|
|
onClick?: TLOnClickHandler<Shape>;
|
|
onDoubleClick?: TLOnDoubleClickHandler<Shape>;
|
|
onDoubleClickEdge?: TLOnDoubleClickHandler<Shape>;
|
|
onDoubleClickHandle?: TLOnDoubleClickHandleHandler<Shape>;
|
|
onDragShapesOut?: TLOnDragHandler<Shape>;
|
|
onDragShapesOver?: TLOnDragHandler<Shape>;
|
|
onDropShapesOver?: TLOnDragHandler<Shape>;
|
|
onEditEnd?: TLOnEditEndHandler<Shape>;
|
|
onHandleDrag?: TLOnHandleDragHandler<Shape>;
|
|
onResize?: TLOnResizeHandler<Shape>;
|
|
onResizeEnd?: TLOnResizeEndHandler<Shape>;
|
|
onResizeStart?: TLOnResizeStartHandler<Shape>;
|
|
onRotate?: TLOnRotateHandler<Shape>;
|
|
onRotateEnd?: TLOnRotateEndHandler<Shape>;
|
|
onRotateStart?: TLOnRotateStartHandler<Shape>;
|
|
onTranslate?: TLOnTranslateHandler<Shape>;
|
|
onTranslateEnd?: TLOnTranslateEndHandler<Shape>;
|
|
onTranslateStart?: TLOnTranslateStartHandler<Shape>;
|
|
// (undocumented)
|
|
static props?: ShapeProps<TLUnknownShape>;
|
|
// @internal
|
|
providesBackgroundForChildren(shape: Shape): boolean;
|
|
toBackgroundSvg?(shape: Shape, ctx: SvgExportContext): null | Promise<null | ReactElement> | ReactElement;
|
|
toSvg?(shape: Shape, ctx: SvgExportContext): null | Promise<null | ReactElement> | ReactElement;
|
|
static type: string;
|
|
}
|
|
|
|
// @public
|
|
export type SharedStyle<T> = {
|
|
readonly type: 'mixed';
|
|
} | {
|
|
readonly type: 'shared';
|
|
readonly value: T;
|
|
};
|
|
|
|
// @internal (undocumented)
|
|
export class SharedStyleMap extends ReadonlySharedStyleMap {
|
|
// (undocumented)
|
|
applyValue<T>(prop: StyleProp<T>, value: T): void;
|
|
// (undocumented)
|
|
set<T>(prop: StyleProp<T>, value: SharedStyle<T>): void;
|
|
}
|
|
|
|
// @public
|
|
export function shortAngleDist(a0: number, a1: number): number;
|
|
|
|
// @public
|
|
export class SideEffectManager<CTX extends {
|
|
history: {
|
|
onBatchComplete: () => void;
|
|
};
|
|
store: TLStore;
|
|
}> {
|
|
constructor(editor: CTX);
|
|
// (undocumented)
|
|
editor: CTX;
|
|
// @internal
|
|
register(handlersByType: {
|
|
[R in TLRecord as R['typeName']]?: {
|
|
afterChange?: TLAfterChangeHandler<R>;
|
|
afterCreate?: TLAfterCreateHandler<R>;
|
|
afterDelete?: TLAfterDeleteHandler<R>;
|
|
beforeChange?: TLBeforeChangeHandler<R>;
|
|
beforeCreate?: TLBeforeCreateHandler<R>;
|
|
beforeDelete?: TLBeforeDeleteHandler<R>;
|
|
};
|
|
}): () => void;
|
|
registerAfterChangeHandler<T extends TLRecord['typeName']>(typeName: T, handler: TLAfterChangeHandler<TLRecord & {
|
|
typeName: T;
|
|
}>): () => void;
|
|
registerAfterCreateHandler<T extends TLRecord['typeName']>(typeName: T, handler: TLAfterCreateHandler<TLRecord & {
|
|
typeName: T;
|
|
}>): () => void;
|
|
registerAfterDeleteHandler<T extends TLRecord['typeName']>(typeName: T, handler: TLAfterDeleteHandler<TLRecord & {
|
|
typeName: T;
|
|
}>): () => void;
|
|
registerBatchCompleteHandler(handler: TLBatchCompleteHandler): () => void;
|
|
registerBeforeChangeHandler<T extends TLRecord['typeName']>(typeName: T, handler: TLBeforeChangeHandler<TLRecord & {
|
|
typeName: T;
|
|
}>): () => void;
|
|
registerBeforeCreateHandler<T extends TLRecord['typeName']>(typeName: T, handler: TLBeforeCreateHandler<TLRecord & {
|
|
typeName: T;
|
|
}>): () => void;
|
|
registerBeforeDeleteHandler<T extends TLRecord['typeName']>(typeName: T, handler: TLBeforeDeleteHandler<TLRecord & {
|
|
typeName: T;
|
|
}>): () => void;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const SIDES: readonly ["top", "right", "bottom", "left"];
|
|
|
|
export { Signal }
|
|
|
|
// @public (undocumented)
|
|
export const SIN: (x: number) => number;
|
|
|
|
// @public
|
|
export function snapAngle(r: number, segments: number): number;
|
|
|
|
// @public (undocumented)
|
|
export type SnapIndicator = GapsSnapIndicator | PointsSnapIndicator;
|
|
|
|
// @public (undocumented)
|
|
export class SnapManager {
|
|
constructor(editor: Editor);
|
|
// (undocumented)
|
|
clearIndicators(): void;
|
|
// (undocumented)
|
|
readonly editor: Editor;
|
|
// (undocumented)
|
|
getCurrentCommonAncestor(): TLShapeId | undefined;
|
|
// (undocumented)
|
|
getIndicators(): SnapIndicator[];
|
|
// (undocumented)
|
|
getSnappableShapes(): Set<TLShapeId>;
|
|
// (undocumented)
|
|
getSnapThreshold(): number;
|
|
// (undocumented)
|
|
readonly handles: HandleSnaps;
|
|
// (undocumented)
|
|
setIndicators(indicators: SnapIndicator[]): void;
|
|
// (undocumented)
|
|
readonly shapeBounds: BoundsSnaps;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class Stadium2d extends Ellipse2d {
|
|
constructor(config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
height: number;
|
|
width: number;
|
|
});
|
|
// (undocumented)
|
|
config: Omit<Geometry2dOptions, 'isClosed'> & {
|
|
height: number;
|
|
width: number;
|
|
};
|
|
// (undocumented)
|
|
getVertices(): Vec[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export abstract class StateNode implements Partial<TLEventHandlers> {
|
|
constructor(editor: Editor, parent?: StateNode);
|
|
// (undocumented)
|
|
static children?: () => TLStateNodeConstructor[];
|
|
// (undocumented)
|
|
children?: Record<string, StateNode>;
|
|
_currentToolIdMask: Atom<string | undefined, unknown>;
|
|
// (undocumented)
|
|
editor: Editor;
|
|
// (undocumented)
|
|
enter: (info: any, from: string) => void;
|
|
// (undocumented)
|
|
exit: (info: any, from: string) => void;
|
|
getCurrent(): StateNode | undefined;
|
|
// (undocumented)
|
|
getCurrentToolIdMask(): string | undefined;
|
|
getIsActive(): boolean;
|
|
getPath(): string;
|
|
// (undocumented)
|
|
handleEvent: (info: Exclude<TLEventInfo, TLPinchEventInfo>) => void;
|
|
// (undocumented)
|
|
static id: string;
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
static initial?: string;
|
|
// (undocumented)
|
|
initial?: string;
|
|
// (undocumented)
|
|
onCancel?: TLEventHandlers['onCancel'];
|
|
// (undocumented)
|
|
onComplete?: TLEventHandlers['onComplete'];
|
|
// (undocumented)
|
|
onDoubleClick?: TLEventHandlers['onDoubleClick'];
|
|
// (undocumented)
|
|
onEnter?: TLEnterEventHandler;
|
|
// (undocumented)
|
|
onExit?: TLExitEventHandler;
|
|
// (undocumented)
|
|
onInterrupt?: TLEventHandlers['onInterrupt'];
|
|
// (undocumented)
|
|
onKeyDown?: TLEventHandlers['onKeyDown'];
|
|
// (undocumented)
|
|
onKeyRepeat?: TLEventHandlers['onKeyRepeat'];
|
|
// (undocumented)
|
|
onKeyUp?: TLEventHandlers['onKeyUp'];
|
|
// (undocumented)
|
|
onLongPress?: TLEventHandlers['onLongPress'];
|
|
// (undocumented)
|
|
onMiddleClick?: TLEventHandlers['onMiddleClick'];
|
|
// (undocumented)
|
|
onPointerDown?: TLEventHandlers['onPointerDown'];
|
|
// (undocumented)
|
|
onPointerMove?: TLEventHandlers['onPointerMove'];
|
|
// (undocumented)
|
|
onPointerUp?: TLEventHandlers['onPointerUp'];
|
|
// (undocumented)
|
|
onQuadrupleClick?: TLEventHandlers['onQuadrupleClick'];
|
|
// (undocumented)
|
|
onRightClick?: TLEventHandlers['onRightClick'];
|
|
// (undocumented)
|
|
onTick?: TLEventHandlers['onTick'];
|
|
// (undocumented)
|
|
onTripleClick?: TLEventHandlers['onTripleClick'];
|
|
// (undocumented)
|
|
onWheel?: TLEventHandlers['onWheel'];
|
|
// (undocumented)
|
|
parent: StateNode;
|
|
// (undocumented)
|
|
_path: Computed<string>;
|
|
// (undocumented)
|
|
setCurrentToolIdMask(id: string | undefined): void;
|
|
// (undocumented)
|
|
shapeType?: string;
|
|
transition: (id: string, info?: any) => this;
|
|
// (undocumented)
|
|
type: TLStateNodeType;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const stopEventPropagation: (e: any) => any;
|
|
|
|
// @internal (undocumented)
|
|
export const SVG_PADDING = 32;
|
|
|
|
// @public (undocumented)
|
|
export function SVGContainer({ children, className, ...rest }: SVGContainerProps): JSX_2.Element;
|
|
|
|
// @public (undocumented)
|
|
export type SVGContainerProps = React_3.HTMLAttributes<SVGElement>;
|
|
|
|
// @public (undocumented)
|
|
export interface SvgExportContext {
|
|
addExportDef(def: SvgExportDef): void;
|
|
readonly isDarkMode: boolean;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface SvgExportDef {
|
|
// (undocumented)
|
|
getElement: () => null | Promise<null | ReactElement> | ReactElement;
|
|
// (undocumented)
|
|
key: string;
|
|
}
|
|
|
|
// @public
|
|
export const TAB_ID: string;
|
|
|
|
// @public (undocumented)
|
|
export type TLAfterChangeHandler<R extends TLRecord> = (prev: R, next: R, source: 'remote' | 'user') => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLAfterCreateHandler<R extends TLRecord> = (record: R, source: 'remote' | 'user') => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLAfterDeleteHandler<R extends TLRecord> = (record: R, source: 'remote' | 'user') => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLAnimationOptions = Partial<{
|
|
duration: number;
|
|
easing: (t: number) => number;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export type TLAnyShapeUtilConstructor = TLShapeUtilConstructor<any>;
|
|
|
|
// @public (undocumented)
|
|
export interface TLArcInfo {
|
|
// (undocumented)
|
|
center: VecLike;
|
|
// (undocumented)
|
|
largeArcFlag: number;
|
|
// (undocumented)
|
|
length: number;
|
|
// (undocumented)
|
|
radius: number;
|
|
// (undocumented)
|
|
size: number;
|
|
// (undocumented)
|
|
sweepFlag: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLArrowInfo = {
|
|
bodyArc: TLArcInfo;
|
|
end: TLArrowPoint;
|
|
handleArc: TLArcInfo;
|
|
isStraight: false;
|
|
isValid: boolean;
|
|
middle: VecLike;
|
|
start: TLArrowPoint;
|
|
} | {
|
|
end: TLArrowPoint;
|
|
isStraight: true;
|
|
isValid: boolean;
|
|
length: number;
|
|
middle: VecLike;
|
|
start: TLArrowPoint;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLArrowPoint = {
|
|
arrowhead: TLArrowShapeArrowheadStyle;
|
|
handle: VecLike;
|
|
point: VecLike;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLBaseBoxShape = TLBaseShape<string, {
|
|
h: number;
|
|
w: number;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export interface TLBaseEventInfo {
|
|
// (undocumented)
|
|
altKey: boolean;
|
|
// (undocumented)
|
|
ctrlKey: boolean;
|
|
// (undocumented)
|
|
shiftKey: boolean;
|
|
// (undocumented)
|
|
type: UiEventType;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLBatchCompleteHandler = () => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLBeforeChangeHandler<R extends TLRecord> = (prev: R, next: R, source: 'remote' | 'user') => R;
|
|
|
|
// @public (undocumented)
|
|
export type TLBeforeCreateHandler<R extends TLRecord> = (record: R, source: 'remote' | 'user') => R;
|
|
|
|
// @public (undocumented)
|
|
export type TLBeforeDeleteHandler<R extends TLRecord> = (record: R, source: 'remote' | 'user') => false | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLBrushProps = {
|
|
brush: BoxModel;
|
|
className?: string;
|
|
color?: string;
|
|
opacity?: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLCancelEvent = (info: TLCancelEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLCancelEventInfo = {
|
|
name: 'cancel';
|
|
type: 'misc';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLClickEvent = (info: TLClickEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLClickEventInfo = TLBaseEventInfo & {
|
|
button: number;
|
|
name: TLCLickEventName;
|
|
phase: 'down' | 'settle' | 'up';
|
|
point: VecLike;
|
|
pointerId: number;
|
|
type: 'click';
|
|
} & TLPointerEventTarget;
|
|
|
|
// @public (undocumented)
|
|
export type TLCLickEventName = 'double_click' | 'quadruple_click' | 'triple_click';
|
|
|
|
// @public (undocumented)
|
|
export type TLCollaboratorHintProps = {
|
|
className?: string;
|
|
color: string;
|
|
opacity?: number;
|
|
point: VecModel;
|
|
viewport: Box;
|
|
zoom: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLCompleteEvent = (info: TLCompleteEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLCompleteEventInfo = {
|
|
name: 'complete';
|
|
type: 'misc';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export interface TLContent {
|
|
// (undocumented)
|
|
assets: TLAsset[];
|
|
// (undocumented)
|
|
rootShapeIds: TLShapeId[];
|
|
// (undocumented)
|
|
schema: SerializedSchema;
|
|
// (undocumented)
|
|
shapes: TLShape[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLCursorProps = {
|
|
chatMessage: string;
|
|
className?: string;
|
|
color?: string;
|
|
name: null | string;
|
|
point: null | VecModel;
|
|
zoom: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export const TldrawEditor: React_2.NamedExoticComponent<TldrawEditorProps>;
|
|
|
|
// @public
|
|
export interface TldrawEditorBaseProps {
|
|
autoFocus?: boolean;
|
|
children?: ReactNode;
|
|
className?: string;
|
|
components?: TLEditorComponents;
|
|
inferDarkMode?: boolean;
|
|
initialState?: string;
|
|
onMount?: TLOnMountHandler;
|
|
shapeUtils?: readonly TLAnyShapeUtilConstructor[];
|
|
tools?: readonly TLStateNodeConstructor[];
|
|
user?: TLUser;
|
|
}
|
|
|
|
// @public
|
|
export type TldrawEditorProps = Expand<TldrawEditorBaseProps & ({
|
|
defaultName?: string;
|
|
initialData?: SerializedStore<TLRecord>;
|
|
migrations?: readonly MigrationSequence[];
|
|
persistenceKey?: string;
|
|
sessionId?: string;
|
|
snapshot?: StoreSnapshot<TLRecord>;
|
|
store?: undefined;
|
|
} | {
|
|
store: TLStore | TLStoreWithStatus;
|
|
})>;
|
|
|
|
// @public (undocumented)
|
|
export type TLEditorComponents = Partial<{
|
|
[K in keyof BaseEditorComponents]: BaseEditorComponents[K] | null;
|
|
} & ErrorComponents>;
|
|
|
|
// @public (undocumented)
|
|
export interface TLEditorOptions {
|
|
getContainer: () => HTMLElement;
|
|
inferDarkMode?: boolean;
|
|
initialState?: string;
|
|
shapeUtils: readonly TLShapeUtilConstructor<TLUnknownShape>[];
|
|
store: TLStore;
|
|
tools: readonly TLStateNodeConstructor[];
|
|
user?: TLUser;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLEnterEventHandler = (info: any, from: string) => void;
|
|
|
|
// @public (undocumented)
|
|
export interface TLErrorBoundaryProps {
|
|
// (undocumented)
|
|
children: React_3.ReactNode;
|
|
// (undocumented)
|
|
fallback: TLErrorFallbackComponent;
|
|
// (undocumented)
|
|
onError?: ((error: unknown) => void) | null;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface TLEventHandlers {
|
|
// (undocumented)
|
|
onCancel: TLCancelEvent;
|
|
// (undocumented)
|
|
onComplete: TLCompleteEvent;
|
|
// (undocumented)
|
|
onDoubleClick: TLClickEvent;
|
|
// (undocumented)
|
|
onInterrupt: TLInterruptEvent;
|
|
// (undocumented)
|
|
onKeyDown: TLKeyboardEvent;
|
|
// (undocumented)
|
|
onKeyRepeat: TLKeyboardEvent;
|
|
// (undocumented)
|
|
onKeyUp: TLKeyboardEvent;
|
|
// (undocumented)
|
|
onLongPress: TLPointerEvent;
|
|
// (undocumented)
|
|
onMiddleClick: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerDown: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerMove: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerUp: TLPointerEvent;
|
|
// (undocumented)
|
|
onQuadrupleClick: TLClickEvent;
|
|
// (undocumented)
|
|
onRightClick: TLPointerEvent;
|
|
// (undocumented)
|
|
onTick: TLTickEvent;
|
|
// (undocumented)
|
|
onTripleClick: TLClickEvent;
|
|
// (undocumented)
|
|
onWheel: TLWheelEvent;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLEventInfo = TLCancelEventInfo | TLClickEventInfo | TLCompleteEventInfo | TLInterruptEventInfo | TLKeyboardEventInfo | TLPinchEventInfo | TLPointerEventInfo | TLTickEventInfo | TLWheelEventInfo;
|
|
|
|
// @public (undocumented)
|
|
export interface TLEventMap {
|
|
// (undocumented)
|
|
'max-shapes': [{
|
|
count: number;
|
|
name: string;
|
|
pageId: TLPageId;
|
|
}];
|
|
// (undocumented)
|
|
'select-all-text': [{
|
|
shapeId: TLShapeId;
|
|
}];
|
|
// (undocumented)
|
|
'stop-camera-animation': [];
|
|
// (undocumented)
|
|
'stop-following': [];
|
|
// (undocumented)
|
|
change: [HistoryEntry<TLRecord>];
|
|
// (undocumented)
|
|
crash: [{
|
|
error: unknown;
|
|
}];
|
|
// (undocumented)
|
|
event: [TLEventInfo];
|
|
// (undocumented)
|
|
frame: [number];
|
|
// (undocumented)
|
|
mount: [];
|
|
// (undocumented)
|
|
tick: [number];
|
|
// (undocumented)
|
|
update: [];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLEventMapHandler<T extends keyof TLEventMap> = (...args: TLEventMap[T]) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLEventName = 'cancel' | 'complete' | 'interrupt' | 'tick' | 'wheel' | TLCLickEventName | TLKeyboardEventName | TLPinchEventName | TLPointerEventName;
|
|
|
|
// @public (undocumented)
|
|
export type TLExitEventHandler = (info: any, to: string) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLExternalAssetContent = {
|
|
file: File;
|
|
type: 'file';
|
|
} | {
|
|
type: 'url';
|
|
url: string;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLExternalContent = {
|
|
point?: VecLike;
|
|
sources?: TLExternalContentSource[];
|
|
} & ({
|
|
embed: EmbedDefinition;
|
|
type: 'embed';
|
|
url: string;
|
|
} | {
|
|
files: File[];
|
|
ignoreParent: boolean;
|
|
type: 'files';
|
|
} | {
|
|
text: string;
|
|
type: 'svg-text';
|
|
} | {
|
|
text: string;
|
|
type: 'text';
|
|
} | {
|
|
type: 'url';
|
|
url: string;
|
|
});
|
|
|
|
// @public (undocumented)
|
|
export type TLExternalContentSource = {
|
|
data: any;
|
|
type: 'excalidraw';
|
|
} | {
|
|
data: null | string;
|
|
reason: string;
|
|
type: 'error';
|
|
} | {
|
|
data: string;
|
|
subtype: 'html' | 'json' | 'text' | 'url';
|
|
type: 'text';
|
|
} | {
|
|
data: TLContent;
|
|
type: 'tldraw';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLGridProps = {
|
|
size: number;
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLHandleProps = {
|
|
className?: string;
|
|
handle: TLHandle;
|
|
isCoarse: boolean;
|
|
shapeId: TLShapeId;
|
|
zoom: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLHandlesProps = {
|
|
children: ReactNode;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLInterruptEvent = (info: TLInterruptEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLInterruptEventInfo = {
|
|
name: 'interrupt';
|
|
type: 'misc';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLKeyboardEvent = (info: TLKeyboardEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLKeyboardEventInfo = TLBaseEventInfo & {
|
|
code: string;
|
|
key: string;
|
|
name: TLKeyboardEventName;
|
|
type: 'keyboard';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLKeyboardEventName = 'key_down' | 'key_repeat' | 'key_up';
|
|
|
|
// @public (undocumented)
|
|
export type TLOnBeforeCreateHandler<T extends TLShape> = (next: T) => T | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnBeforeUpdateHandler<T extends TLShape> = (prev: T, next: T) => T | void;
|
|
|
|
// @internal (undocumented)
|
|
export type TLOnBindingChangeHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnChildrenChangeHandler<T extends TLShape> = (shape: T) => TLShapePartial[] | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnClickHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnDoubleClickHandleHandler<T extends TLShape> = (shape: T, handle: TLHandle) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnDoubleClickHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnDragHandler<T extends TLShape, R = void> = (shape: T, shapes: TLShape[]) => R;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnEditEndHandler<T extends TLShape> = (shape: T) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnHandleDragHandler<T extends TLShape> = (shape: T, info: {
|
|
handle: TLHandle;
|
|
initial?: T | undefined;
|
|
isPrecise: boolean;
|
|
}) => TLShapePartial<T> | void;
|
|
|
|
// @public
|
|
export type TLOnMountHandler = (editor: Editor) => (() => undefined | void) | undefined | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnResizeEndHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnResizeHandler<T extends TLShape> = (shape: T, info: TLResizeInfo<T>) => Omit<TLShapePartial<T>, 'id' | 'type'> | undefined | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnResizeStartHandler<T extends TLShape> = TLEventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnRotateEndHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnRotateHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnRotateStartHandler<T extends TLShape> = TLEventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnTranslateEndHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnTranslateHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnTranslateStartHandler<T extends TLShape> = TLEventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEvent = (info: TLPinchEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEventInfo = TLBaseEventInfo & {
|
|
delta: VecModel;
|
|
name: TLPinchEventName;
|
|
point: VecModel;
|
|
type: 'pinch';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEventName = 'pinch_end' | 'pinch_start' | 'pinch';
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEvent = (info: TLPointerEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEventInfo = TLBaseEventInfo & {
|
|
button: number;
|
|
isPen: boolean;
|
|
name: TLPointerEventName;
|
|
point: VecLike;
|
|
pointerId: number;
|
|
type: 'pointer';
|
|
} & TLPointerEventTarget;
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEventName = 'long_press' | 'middle_click' | 'pointer_down' | 'pointer_move' | 'pointer_up' | 'right_click';
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEventTarget = {
|
|
handle: TLHandle;
|
|
shape: TLShape;
|
|
target: 'handle';
|
|
} | {
|
|
handle?: TLSelectionHandle;
|
|
shape?: undefined;
|
|
target: 'selection';
|
|
} | {
|
|
shape: TLShape;
|
|
target: 'shape';
|
|
} | {
|
|
shape?: undefined;
|
|
target: 'canvas';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLResizeHandle = SelectionCorner | SelectionEdge;
|
|
|
|
// @public
|
|
export type TLResizeInfo<T extends TLShape> = {
|
|
handle: TLResizeHandle;
|
|
initialBounds: Box;
|
|
initialShape: T;
|
|
mode: TLResizeMode;
|
|
newPoint: Vec;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
};
|
|
|
|
// @public
|
|
export type TLResizeMode = 'resize_bounds' | 'scale_shape';
|
|
|
|
// @public (undocumented)
|
|
export type TLResizeShapeOptions = Partial<{
|
|
dragHandle: TLResizeHandle;
|
|
initialBounds: Box;
|
|
initialPageTransform: MatLike;
|
|
initialShape: TLShape;
|
|
isAspectRatioLocked: boolean;
|
|
mode: TLResizeMode;
|
|
scaleAxisRotation: number;
|
|
scaleOrigin: VecLike;
|
|
}>;
|
|
|
|
// @public
|
|
export type TLRotationSnapshot = {
|
|
initialCursorAngle: number;
|
|
initialSelectionRotation: number;
|
|
selectionPageCenter: Vec;
|
|
shapeSnapshots: {
|
|
initialPagePoint: Vec;
|
|
shape: TLShape;
|
|
}[];
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLScribbleProps = {
|
|
className?: string;
|
|
color?: string;
|
|
opacity?: number;
|
|
scribble: TLScribble;
|
|
zoom: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLSelectionBackgroundProps = {
|
|
bounds: Box;
|
|
rotation: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLSelectionForegroundProps = {
|
|
bounds: Box;
|
|
rotation: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLSelectionHandle = RotateCorner | SelectionCorner | SelectionEdge;
|
|
|
|
// @public
|
|
export interface TLSessionStateSnapshot {
|
|
// (undocumented)
|
|
currentPageId: TLPageId;
|
|
// (undocumented)
|
|
exportBackground: boolean;
|
|
// (undocumented)
|
|
isDebugMode: boolean;
|
|
// (undocumented)
|
|
isFocusMode: boolean;
|
|
// (undocumented)
|
|
isGridMode: boolean;
|
|
// (undocumented)
|
|
isToolLocked: boolean;
|
|
// (undocumented)
|
|
pageStates: Array<{
|
|
camera: {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
focusedGroupId: null | TLShapeId;
|
|
pageId: TLPageId;
|
|
selectedShapeIds: TLShapeId[];
|
|
}>;
|
|
// (undocumented)
|
|
version: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLShapeIndicatorProps = {
|
|
className?: string;
|
|
color?: string | undefined;
|
|
hidden?: boolean;
|
|
opacity?: number;
|
|
shapeId: TLShapeId;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export interface TLShapeUtilCanvasSvgDef {
|
|
// (undocumented)
|
|
component: React.ComponentType;
|
|
// (undocumented)
|
|
key: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface TLShapeUtilConstructor<T extends TLUnknownShape, U extends ShapeUtil<T> = ShapeUtil<T>> {
|
|
// (undocumented)
|
|
new (editor: Editor): U;
|
|
// (undocumented)
|
|
migrations?: LegacyMigrations | MigrationSequence | TLShapePropsMigrations;
|
|
// (undocumented)
|
|
props?: ShapeProps<T>;
|
|
// (undocumented)
|
|
type: T['type'];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLShapeUtilFlag<T> = (shape: T) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export type TLSnapIndicatorProps = {
|
|
className?: string;
|
|
line: SnapIndicator;
|
|
zoom: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export interface TLStateNodeConstructor {
|
|
// (undocumented)
|
|
new (editor: Editor, parent?: StateNode): StateNode;
|
|
// (undocumented)
|
|
children?: () => TLStateNodeConstructor[];
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
initial?: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLStoreEventInfo = HistoryEntry<TLRecord>;
|
|
|
|
// @public (undocumented)
|
|
export type TLStoreOptions = {
|
|
defaultName?: string;
|
|
id?: string;
|
|
initialData?: SerializedStore<TLRecord>;
|
|
} & ({
|
|
migrations?: readonly MigrationSequence[];
|
|
shapeUtils?: readonly TLAnyShapeUtilConstructor[];
|
|
} | {
|
|
schema?: StoreSchema<TLRecord, TLStoreProps>;
|
|
});
|
|
|
|
// @public (undocumented)
|
|
export type TLStoreWithStatus = {
|
|
readonly connectionStatus: 'offline' | 'online';
|
|
readonly error?: undefined;
|
|
readonly status: 'synced-remote';
|
|
readonly store: TLStore;
|
|
} | {
|
|
readonly error: Error;
|
|
readonly status: 'error';
|
|
readonly store?: undefined;
|
|
} | {
|
|
readonly error?: undefined;
|
|
readonly status: 'loading';
|
|
readonly store?: undefined;
|
|
} | {
|
|
readonly error?: undefined;
|
|
readonly status: 'not-synced';
|
|
readonly store: TLStore;
|
|
} | {
|
|
readonly error?: undefined;
|
|
readonly status: 'synced-local';
|
|
readonly store: TLStore;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLSvgOptions = {
|
|
background: boolean;
|
|
bounds: Box;
|
|
darkMode?: boolean;
|
|
padding: number;
|
|
preserveAspectRatio: React.SVGAttributes<SVGSVGElement>['preserveAspectRatio'];
|
|
scale: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLTickEvent = (info: TLTickEventInfo) => void;
|
|
|
|
// @public
|
|
export interface TLUserPreferences {
|
|
// (undocumented)
|
|
animationSpeed?: null | number;
|
|
// (undocumented)
|
|
color?: null | string;
|
|
// (undocumented)
|
|
edgeScrollSpeed?: null | number;
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
isDarkMode?: boolean | null;
|
|
// (undocumented)
|
|
isSnapMode?: boolean | null;
|
|
// (undocumented)
|
|
isWrapMode?: boolean | null;
|
|
// (undocumented)
|
|
locale?: null | string;
|
|
// (undocumented)
|
|
name?: null | string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLWheelEvent = (info: TLWheelEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLWheelEventInfo = TLBaseEventInfo & {
|
|
delta: VecModel;
|
|
name: 'wheel';
|
|
point: VecModel;
|
|
type: 'wheel';
|
|
};
|
|
|
|
// @public
|
|
export function toDomPrecision(v: number): number;
|
|
|
|
// @public (undocumented)
|
|
export function toFixed(v: number): number;
|
|
|
|
// @public
|
|
export function toPrecision(n: number, precision?: number): number;
|
|
|
|
export { track }
|
|
|
|
export { transact }
|
|
|
|
export { transaction }
|
|
|
|
// @public (undocumented)
|
|
export type UiEvent = TLCancelEvent | TLClickEvent | TLCompleteEvent | TLKeyboardEvent | TLPinchEvent | TLPointerEvent;
|
|
|
|
// @public (undocumented)
|
|
export type UiEventType = 'click' | 'keyboard' | 'pinch' | 'pointer' | 'wheel' | 'zoom';
|
|
|
|
// @public (undocumented)
|
|
export function uniq<T>(array: {
|
|
readonly [n: number]: T;
|
|
readonly length: number;
|
|
} | null | undefined): T[];
|
|
|
|
// @public
|
|
export function uniqueId(): string;
|
|
|
|
export { useComputed }
|
|
|
|
// @public (undocumented)
|
|
export function useContainer(): HTMLDivElement;
|
|
|
|
// @public (undocumented)
|
|
export function useEditor(): Editor;
|
|
|
|
// @public (undocumented)
|
|
export function useEditorComponents(): Partial<{
|
|
Background: ComponentType | null;
|
|
Brush: ComponentType<TLBrushProps> | null;
|
|
Canvas: ComponentType<TLCanvasComponentProps> | null;
|
|
CollaboratorBrush: ComponentType<TLBrushProps> | null;
|
|
CollaboratorCursor: ComponentType<TLCursorProps> | null;
|
|
CollaboratorHint: ComponentType<TLCollaboratorHintProps> | null;
|
|
CollaboratorScribble: ComponentType<TLScribbleProps> | null;
|
|
CollaboratorShapeIndicator: ComponentType<TLShapeIndicatorProps> | null;
|
|
Cursor: ComponentType<TLCursorProps> | null;
|
|
Grid: ComponentType<TLGridProps> | null;
|
|
Handle: ComponentType<TLHandleProps> | null;
|
|
Handles: ComponentType<TLHandlesProps> | null;
|
|
InFrontOfTheCanvas: ComponentType | null;
|
|
LoadingScreen: ComponentType | null;
|
|
OnTheCanvas: ComponentType | null;
|
|
Scribble: ComponentType<TLScribbleProps> | null;
|
|
SelectionBackground: ComponentType<TLSelectionBackgroundProps> | null;
|
|
SelectionForeground: ComponentType<TLSelectionForegroundProps> | null;
|
|
ShapeIndicator: ComponentType<TLShapeIndicatorProps> | null;
|
|
SnapIndicator: ComponentType<TLSnapIndicatorProps> | null;
|
|
Spinner: ComponentType | null;
|
|
SvgDefs: ComponentType | null;
|
|
ZoomBrush: ComponentType<TLBrushProps> | null;
|
|
} & ErrorComponents> & ErrorComponents;
|
|
|
|
// @internal
|
|
export function useEvent<Args extends Array<unknown>, Result>(handler: (...args: Args) => Result): (...args: Args) => Result;
|
|
|
|
// @public (undocumented)
|
|
export function useIsCropping(shapeId: TLShapeId): boolean;
|
|
|
|
// @public (undocumented)
|
|
export function useIsDarkMode(): boolean;
|
|
|
|
// @public (undocumented)
|
|
export function useIsEditing(shapeId: TLShapeId): boolean;
|
|
|
|
// @internal (undocumented)
|
|
export function useLocalStore({ persistenceKey, sessionId, ...rest }: {
|
|
persistenceKey?: string;
|
|
sessionId?: string;
|
|
snapshot?: StoreSnapshot<TLRecord>;
|
|
} & TLStoreOptions): TLStoreWithStatus;
|
|
|
|
// @internal (undocumented)
|
|
export function usePeerIds(): string[];
|
|
|
|
// @internal (undocumented)
|
|
export function usePresence(userId: string): null | TLInstancePresence;
|
|
|
|
export { useQuickReactor }
|
|
|
|
// @internal (undocumented)
|
|
export const USER_COLORS: readonly ["#FF802B", "#EC5E41", "#F2555A", "#F04F88", "#E34BA9", "#BD54C6", "#9D5BD2", "#7B66DC", "#02B1CC", "#11B3A3", "#39B178", "#55B467"];
|
|
|
|
export { useReactor }
|
|
|
|
// @internal
|
|
export function useSafeId(): string;
|
|
|
|
// @public (undocumented)
|
|
export function useSelectionEvents(handle: TLSelectionHandle): {
|
|
onPointerDown: PointerEventHandler<Element>;
|
|
onPointerMove: (e: React.PointerEvent) => void;
|
|
onPointerUp: PointerEventHandler<Element>;
|
|
};
|
|
|
|
// @internal (undocumented)
|
|
export function useShallowArrayIdentity<T>(arr: readonly T[]): readonly T[];
|
|
|
|
// @internal (undocumented)
|
|
export function useShallowObjectIdentity<T extends Record<string, unknown>>(arr: T): T;
|
|
|
|
// @public
|
|
export function useSvgExportContext(): {
|
|
isDarkMode: boolean;
|
|
} | null;
|
|
|
|
// @public (undocumented)
|
|
export function useTLStore(opts: TLStoreOptions & {
|
|
snapshot?: StoreSnapshot<TLRecord>;
|
|
}): TLStore;
|
|
|
|
// @public (undocumented)
|
|
export function useTransform(ref: React.RefObject<HTMLElement | SVGElement>, x?: number, y?: number, scale?: number, rotate?: number, additionalOffset?: VecLike): void;
|
|
|
|
export { useValue }
|
|
|
|
// @public (undocumented)
|
|
export class Vec {
|
|
constructor(x?: number, y?: number, z?: number);
|
|
// (undocumented)
|
|
static Abs(A: VecLike): Vec;
|
|
// (undocumented)
|
|
abs(): this;
|
|
// (undocumented)
|
|
static Add(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
add(V: VecLike): this;
|
|
// (undocumented)
|
|
static AddScalar(A: VecLike, n: number): Vec;
|
|
// (undocumented)
|
|
addScalar(n: number): this;
|
|
// (undocumented)
|
|
static AddXY(A: VecLike, x: number, y: number): Vec;
|
|
// (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[]): Vec;
|
|
// (undocumented)
|
|
static Cast(A: VecLike): Vec;
|
|
// (undocumented)
|
|
static Clamp(A: Vec, min: number, max?: number): Vec;
|
|
// (undocumented)
|
|
clamp(min: number, max?: number): this;
|
|
// (undocumented)
|
|
static Clockwise(A: VecLike, B: VecLike, C: VecLike): boolean;
|
|
// (undocumented)
|
|
clone(): Vec;
|
|
static Cpr(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
cpr(V: VecLike): number;
|
|
// (undocumented)
|
|
static Cross(A: VecLike, V: VecLike): Vec;
|
|
// (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 DistMin(A: VecLike, B: VecLike, n: number): boolean;
|
|
// (undocumented)
|
|
static Div(A: VecLike, t: number): Vec;
|
|
// (undocumented)
|
|
div(t: number): this;
|
|
// (undocumented)
|
|
static DivV(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
divV(V: VecLike): this;
|
|
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 }: VecModel): Vec;
|
|
// (undocumented)
|
|
static FromAngle(r: number, length?: number): Vec;
|
|
// (undocumented)
|
|
static FromArray(v: number[]): Vec;
|
|
// (undocumented)
|
|
static IsNaN(A: VecLike): boolean;
|
|
// (undocumented)
|
|
static Len(A: VecLike): number;
|
|
// (undocumented)
|
|
len(): number;
|
|
// (undocumented)
|
|
static Len2(A: VecLike): number;
|
|
// (undocumented)
|
|
len2(): number;
|
|
static Lrp(A: VecLike, B: VecLike, t: number): Vec;
|
|
// (undocumented)
|
|
lrp(B: VecLike, t: number): Vec;
|
|
// (undocumented)
|
|
static Max(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
static Med(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
static Min(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
static Mul(A: VecLike, t: number): Vec;
|
|
// (undocumented)
|
|
mul(t: number): this;
|
|
// (undocumented)
|
|
static MulV(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
mulV(V: VecLike): this;
|
|
// (undocumented)
|
|
static NearestPointOnLineSegment(A: VecLike, B: VecLike, P: VecLike, clamp?: boolean): Vec;
|
|
static NearestPointOnLineThroughPoint(A: VecLike, u: VecLike, P: VecLike): Vec;
|
|
// (undocumented)
|
|
static Neg(A: VecLike): Vec;
|
|
// (undocumented)
|
|
neg(): this;
|
|
// (undocumented)
|
|
norm(): this;
|
|
// (undocumented)
|
|
static Nudge(A: VecLike, B: VecLike, distance: number): Vec;
|
|
// (undocumented)
|
|
nudge(B: VecLike, distance: number): this;
|
|
static Per(A: VecLike): Vec;
|
|
// (undocumented)
|
|
per(): this;
|
|
static PointsBetween(A: VecModel, B: VecModel, steps?: number): Vec[];
|
|
// (undocumented)
|
|
get pressure(): number;
|
|
static Pry(A: VecLike, B: VecLike): number;
|
|
// (undocumented)
|
|
pry(V: VecLike): number;
|
|
// (undocumented)
|
|
static Rescale(A: VecLike, n: number): Vec;
|
|
// (undocumented)
|
|
static Rot(A: VecLike, r?: number): Vec;
|
|
// (undocumented)
|
|
rot(r: number): this;
|
|
// (undocumented)
|
|
static RotWith(A: VecLike, C: VecLike, r: number): Vec;
|
|
// (undocumented)
|
|
rotWith(C: VecLike, r: number): this;
|
|
// (undocumented)
|
|
static ScaleWithOrigin(A: VecLike, scale: number, origin: VecLike): Vec;
|
|
// (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): Vec;
|
|
// (undocumented)
|
|
static SnapToGrid(A: VecLike, gridSize?: number): Vec;
|
|
// (undocumented)
|
|
snapToGrid(gridSize: number): this;
|
|
// (undocumented)
|
|
static Sub(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
sub(V: VecLike): this;
|
|
// (undocumented)
|
|
static SubScalar(A: VecLike, n: number): Vec;
|
|
// (undocumented)
|
|
subScalar(n: number): this;
|
|
// (undocumented)
|
|
static SubXY(A: VecLike, x: number, y: number): Vec;
|
|
// (undocumented)
|
|
subXY(x: number, y: number): this;
|
|
// (undocumented)
|
|
static Tan(A: VecLike, B: VecLike): Vec;
|
|
// (undocumented)
|
|
tan(V: VecLike): Vec;
|
|
// (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): Vec;
|
|
// (undocumented)
|
|
toFixed(): Vec;
|
|
// (undocumented)
|
|
static ToJson(A: VecLike): {
|
|
x: number;
|
|
y: number;
|
|
z: number | undefined;
|
|
};
|
|
// (undocumented)
|
|
toJson(): VecModel;
|
|
// (undocumented)
|
|
static ToString(A: VecLike): string;
|
|
// (undocumented)
|
|
toString(): string;
|
|
static Uni(A: VecLike): Vec;
|
|
// (undocumented)
|
|
uni(): Vec;
|
|
// (undocumented)
|
|
x: number;
|
|
// (undocumented)
|
|
y: number;
|
|
// (undocumented)
|
|
z: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type VecLike = Vec | VecModel;
|
|
|
|
// @public (undocumented)
|
|
export class WeakMapCache<T extends object, K> {
|
|
// (undocumented)
|
|
access(item: T): K | undefined;
|
|
// (undocumented)
|
|
bust(): void;
|
|
// (undocumented)
|
|
get<P extends T>(item: P, cb: (item: P) => K): NonNullable<K>;
|
|
// (undocumented)
|
|
has(item: T): boolean;
|
|
// (undocumented)
|
|
invalidate(item: T): void;
|
|
// (undocumented)
|
|
items: WeakMap<T, K>;
|
|
// (undocumented)
|
|
set(item: T, value: K): void;
|
|
}
|
|
|
|
export { whyAmIRunning }
|
|
|
|
// @internal (undocumented)
|
|
export const ZOOMS: number[];
|
|
|
|
|
|
export * from "@tldraw/store";
|
|
export * from "@tldraw/tlschema";
|
|
export * from "@tldraw/utils";
|
|
export * from "@tldraw/validate";
|
|
|
|
// (No @packageDocumentation comment for this package)
|
|
|
|
```
|