b63e871420
- fixes an invalid usage of process.env in the editor package - fixes some bublic paths in the publishing infra code
2701 lines
90 KiB
Markdown
2701 lines
90 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 'signia';
|
|
import { Box2d } from '@tldraw/primitives';
|
|
import { Box2dModel } from '@tldraw/tlschema';
|
|
import { Computed } from 'signia';
|
|
import { ComputedCache } from '@tldraw/tlstore';
|
|
import { CubicSpline2d } from '@tldraw/primitives';
|
|
import { EASINGS } from '@tldraw/primitives';
|
|
import { EmbedDefinition } from '@tldraw/tlschema';
|
|
import { EventEmitter } from 'eventemitter3';
|
|
import { getHashForString } from '@tldraw/utils';
|
|
import { HistoryEntry } from '@tldraw/tlstore';
|
|
import { ID } from '@tldraw/tlstore';
|
|
import { MatLike } from '@tldraw/primitives';
|
|
import { Matrix2d } from '@tldraw/primitives';
|
|
import { Matrix2dModel } from '@tldraw/primitives';
|
|
import { Migrations } from '@tldraw/tlstore';
|
|
import { Polyline2d } from '@tldraw/primitives';
|
|
import * as React_2 from 'react';
|
|
import { default as React_3 } from 'react';
|
|
import { RecordType } from '@tldraw/tlstore';
|
|
import { RotateCorner } from '@tldraw/primitives';
|
|
import { SelectionCorner } from '@tldraw/primitives';
|
|
import { SelectionEdge } from '@tldraw/primitives';
|
|
import { SelectionHandle } from '@tldraw/primitives';
|
|
import { SerializedSchema } from '@tldraw/tlstore';
|
|
import { Signal } from 'signia';
|
|
import { StoreSchema } from '@tldraw/tlstore';
|
|
import { StoreSnapshot } from '@tldraw/tlstore';
|
|
import { StoreValidator } from '@tldraw/tlstore';
|
|
import { StrokePoint } from '@tldraw/primitives';
|
|
import { TLAlignType } from '@tldraw/tlschema';
|
|
import { TLArrowheadType } from '@tldraw/tlschema';
|
|
import { TLArrowShape } 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 { TLBookmarkShape } from '@tldraw/tlschema';
|
|
import { TLCamera } from '@tldraw/tlschema';
|
|
import { TLColorStyle } from '@tldraw/tlschema';
|
|
import { TLColorType } from '@tldraw/tlschema';
|
|
import { TLCursor } from '@tldraw/tlschema';
|
|
import { TLDocument } from '@tldraw/tlschema';
|
|
import { TLDrawShape } from '@tldraw/tlschema';
|
|
import { TLDrawShapeSegment } from '@tldraw/tlschema';
|
|
import { TLEmbedShape } from '@tldraw/tlschema';
|
|
import { TLFontType } from '@tldraw/tlschema';
|
|
import { TLFrameShape } from '@tldraw/tlschema';
|
|
import { TLGeoShape } from '@tldraw/tlschema';
|
|
import { TLGroupShape } from '@tldraw/tlschema';
|
|
import { TLHandle } from '@tldraw/tlschema';
|
|
import { TLImageAsset } from '@tldraw/tlschema';
|
|
import { TLImageShape } from '@tldraw/tlschema';
|
|
import { TLInstance } from '@tldraw/tlschema';
|
|
import { TLInstanceId } from '@tldraw/tlschema';
|
|
import { TLInstancePageState } from '@tldraw/tlschema';
|
|
import { TLInstancePresence } from '@tldraw/tlschema';
|
|
import { TLInstancePropsForNextShape } from '@tldraw/tlschema';
|
|
import { TLLineShape } from '@tldraw/tlschema';
|
|
import { TLNoteShape } from '@tldraw/tlschema';
|
|
import { TLNullableShapeProps } 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 { TLShapeProp } from '@tldraw/tlschema';
|
|
import { TLShapeProps } from '@tldraw/tlschema';
|
|
import { TLShapeType } from '@tldraw/tlschema';
|
|
import { TLSizeStyle } from '@tldraw/tlschema';
|
|
import { TLSizeType } from '@tldraw/tlschema';
|
|
import { TLStore } from '@tldraw/tlschema';
|
|
import { TLStoreProps } from '@tldraw/tlschema';
|
|
import { TLStyleCollections } from '@tldraw/tlschema';
|
|
import { TLStyleType } from '@tldraw/tlschema';
|
|
import { TLTextShape } from '@tldraw/tlschema';
|
|
import { TLTextShapeProps } from '@tldraw/tlschema';
|
|
import { TLUnknownShape } from '@tldraw/tlschema';
|
|
import { TLUser } from '@tldraw/tlschema';
|
|
import { TLUserDocument } from '@tldraw/tlschema';
|
|
import { TLUserId } from '@tldraw/tlschema';
|
|
import { TLUserPresence } from '@tldraw/tlschema';
|
|
import { TLVideoAsset } from '@tldraw/tlschema';
|
|
import { TLVideoShape } from '@tldraw/tlschema';
|
|
import { Vec2d } from '@tldraw/primitives';
|
|
import { Vec2dModel } from '@tldraw/tlschema';
|
|
import { VecLike } from '@tldraw/primitives';
|
|
|
|
// @public (undocumented)
|
|
export const ACCEPTED_ASSET_TYPE: string;
|
|
|
|
// @public (undocumented)
|
|
export const ACCEPTED_IMG_TYPE: string[];
|
|
|
|
// @public (undocumented)
|
|
export const ACCEPTED_VID_TYPE: string[];
|
|
|
|
// @internal (undocumented)
|
|
export const ANIMATION_MEDIUM_MS = 320;
|
|
|
|
// @internal (undocumented)
|
|
export const ANIMATION_SHORT_MS = 80;
|
|
|
|
// @public (undocumented)
|
|
export type AnimationOptions = Partial<{
|
|
duration: number;
|
|
easing: typeof EASINGS.easeInOutCubic;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export class App extends EventEmitter {
|
|
constructor({ config, store, getContainer }: AppOptions);
|
|
alignShapes(operation: 'bottom' | 'center-horizontal' | 'center-vertical' | 'left' | 'right' | 'top', ids?: TLShapeId[]): this;
|
|
get allShapesCommonBounds(): Box2d | null;
|
|
animateCamera(x: number, y: number, z?: number, opts?: AnimationOptions): this;
|
|
animateShapes(partials: (null | TLShapePartial | undefined)[], options?: {
|
|
duration?: number;
|
|
ease?: (t: number) => number;
|
|
}): this;
|
|
// (undocumented)
|
|
animateToShape(shapeId: TLShapeId, opts?: AnimationOptions): this;
|
|
// @internal (undocumented)
|
|
annotateError(error: unknown, { origin, willCrashApp, tags, extras, }: {
|
|
origin: string;
|
|
willCrashApp: boolean;
|
|
tags?: Record<string, boolean | number | string>;
|
|
extras?: Record<string, unknown>;
|
|
}): void;
|
|
get assets(): (TLBookmarkAsset | TLImageAsset | TLVideoAsset)[];
|
|
bail(): this;
|
|
bailToMark(id: string): this;
|
|
batch(fn: () => void): this;
|
|
blur(): this;
|
|
bringForward(ids?: TLShapeId[]): this;
|
|
bringToFront(ids?: TLShapeId[]): this;
|
|
// (undocumented)
|
|
get brush(): Box2dModel | null;
|
|
get camera(): TLCamera;
|
|
cancel(): this;
|
|
cancelDoubleClick(): void;
|
|
get canMoveCamera(): boolean;
|
|
set canMoveCamera(canMove: boolean);
|
|
get canRedo(): boolean;
|
|
get canUndo(): boolean;
|
|
centerOnPoint(x: number, y: number, opts?: AnimationOptions): this;
|
|
// @internal
|
|
protected _clickManager: ClickManager;
|
|
complete(): this;
|
|
readonly config: TldrawEditorConfig;
|
|
// @internal (undocumented)
|
|
crash(error: unknown): void;
|
|
// @internal
|
|
get crashingError(): unknown;
|
|
createAssets(assets: TLAsset[]): this;
|
|
// @internal (undocumented)
|
|
createErrorAnnotations(origin: string, willCrashApp: 'unknown' | boolean): {
|
|
tags: {
|
|
origin: string;
|
|
willCrashApp: 'unknown' | boolean;
|
|
};
|
|
extras: {
|
|
activeStateNode?: string;
|
|
selectedShapes?: TLUnknownShape[];
|
|
editingShape?: TLUnknownShape;
|
|
inputs?: Record<string, unknown>;
|
|
};
|
|
};
|
|
createPage(title: string, id?: TLPageId, belowPageIndex?: string): this;
|
|
createShapeId(id?: string): TLShapeId;
|
|
createShapes(partials: TLShapePartial[], select?: boolean): this;
|
|
get croppingId(): null | TLShapeId;
|
|
get cullingBounds(): Box2d;
|
|
// @internal (undocumented)
|
|
readonly _cullingBounds: Atom<Box2d, unknown>;
|
|
get cullingBoundsExpanded(): Box2d;
|
|
// @internal (undocumented)
|
|
readonly _cullingBoundsExpanded: Atom<Box2d, unknown>;
|
|
get currentPage(): TLPage;
|
|
get currentPageId(): TLPageId;
|
|
get currentToolId(): string;
|
|
// (undocumented)
|
|
get cursor(): TLCursor;
|
|
deleteAssets(ids: TLAssetId[]): this;
|
|
deletePage(id: TLPageId): void;
|
|
deleteShapes(ids?: TLShapeId[]): this;
|
|
deselect(...ids: TLShapeId[]): this;
|
|
// (undocumented)
|
|
get devicePixelRatio(): number;
|
|
dispatch: (info: TLEventInfo) => this;
|
|
readonly disposables: Set<() => void>;
|
|
dispose(): void;
|
|
distributeShapes(operation: 'horizontal' | 'vertical', ids?: TLShapeId[]): this;
|
|
get documentSettings(): TLDocument;
|
|
// (undocumented)
|
|
duplicatePage(id?: TLPageId, createId?: TLPageId): void;
|
|
duplicateShapes(ids?: TLShapeId[], offset?: VecLike): this;
|
|
get editingId(): null | TLShapeId;
|
|
// (undocumented)
|
|
get editingShape(): null | TLUnknownShape;
|
|
get erasingIds(): TLShapeId[];
|
|
get erasingIdsSet(): Set<TLShapeId>;
|
|
findAncestor(shape: TLShape, predicate: (parent: TLShape) => boolean): TLShape | undefined;
|
|
findCommonAncestor(shapes: TLShape[], predicate?: (shape: TLShape) => boolean): TLShapeId | undefined;
|
|
flipShapes(operation: 'horizontal' | 'vertical', ids?: TLShapeId[]): this;
|
|
focus(): this;
|
|
// (undocumented)
|
|
get focusLayerId(): TLPageId | TLShapeId;
|
|
// (undocumented)
|
|
get focusLayerShape(): TLShape | undefined;
|
|
getAncestors(shape: TLShape, acc?: TLShape[]): TLShape[];
|
|
getAncestorsById(id: TLShapeId, acc?: TLShape[]): TLShape[];
|
|
getArrowsBoundTo(shapeId: TLShapeId): {
|
|
arrowId: TLShapeId;
|
|
handleId: "end" | "start";
|
|
}[];
|
|
getAssetById(id: TLAssetId): TLAsset | undefined;
|
|
getAssetBySrc(src: string): TLBookmarkAsset | TLImageAsset | TLVideoAsset | undefined;
|
|
getBounds(shape: TLShape): Box2d;
|
|
getBoundsById(id: TLShapeId): Box2d | undefined;
|
|
getClipPathById(id: TLShapeId): string | undefined;
|
|
getContainer: () => HTMLElement;
|
|
// (undocumented)
|
|
getContent(ids?: TLShapeId[]): TLClipboardModel | undefined;
|
|
getCssColor(id: TLColorStyle['id']): string;
|
|
getDeltaInParentSpace(shape: TLShape, delta: VecLike): Vec2d;
|
|
getDeltaInShapeSpace(shape: TLShape, delta: VecLike): Vec2d;
|
|
// (undocumented)
|
|
getDroppingShape(point: VecLike, droppingShapes?: TLShape[]): TLUnknownShape | undefined;
|
|
// (undocumented)
|
|
getHighestIndexForParent(parentId: TLPageId | TLShapeId): string;
|
|
getMaskedPageBounds(shape: TLShape): Box2d | undefined;
|
|
getMaskedPageBoundsById(id: TLShapeId): Box2d | undefined;
|
|
// (undocumented)
|
|
getOutermostSelectableShape(shape: TLShape, filter?: (shape: TLShape) => boolean): TLShape;
|
|
getOutline(shape: TLShape): Vec2dModel[];
|
|
getOutlineById(id: TLShapeId): Vec2dModel[];
|
|
getPageBounds(shape: TLShape): Box2d | undefined;
|
|
getPageBoundsById(id: TLShapeId): Box2d | undefined;
|
|
getPageById(id: TLPage['id']): TLPage | undefined;
|
|
getPageCenter(shape: TLShape): null | Vec2d;
|
|
getPageCenterById(id: TLShapeId): null | Vec2d;
|
|
getPageCorners(shape: TLShape): Vec2d[];
|
|
getPageInfoById(id: TLPage['id']): TLPage | undefined;
|
|
getPageMaskById(id: TLShapeId): undefined | VecLike[];
|
|
getPagePointById(id: TLShapeId): undefined | Vec2d;
|
|
getPageRotation(shape: TLShape): number;
|
|
getPageRotationById(id: TLShapeId): number;
|
|
getPageStateByPageId(id: TLPageId): TLInstancePageState | undefined;
|
|
getPageTransform(shape: TLShape): Matrix2d | undefined;
|
|
getPageTransformById(id: TLShapeId): Matrix2d | undefined;
|
|
// (undocumented)
|
|
getParentIdForNewShapeAtPoint(point: VecLike, shapeType: TLShapeType): TLPageId | TLShapeId;
|
|
getParentPageId(shape?: TLShape): TLPageId | undefined;
|
|
getParentShape(shape?: TLShape): TLShape | undefined;
|
|
getParentsMappedToChildren(ids: TLShapeId[]): Map<TLParentId, Set<TLShape>>;
|
|
getParentTransform(shape: TLShape): Matrix2d;
|
|
getPointInParentSpace(shapeId: TLShapeId, point: VecLike): Vec2d;
|
|
getPointInShapeSpace(shape: TLShape, point: VecLike): Vec2d;
|
|
getShapeById<T extends TLShape = TLShape>(id: TLParentId): T | undefined;
|
|
// (undocumented)
|
|
getShapesAndDescendantsInOrder(ids: TLShapeId[]): TLShape[];
|
|
getShapesAtPoint(point: VecLike): TLShape[];
|
|
getShapesInPage(pageId: TLPageId): TLShape[];
|
|
getShapeUtil<T extends TLShape = TLShape>(shape: T): TLShapeUtil<T>;
|
|
getShapeUtilByDef<Def extends TLShapeDef<any, any>>(def: Def): ReturnType<Def['createShapeUtils']>;
|
|
getSortedChildIds(parentId: TLParentId): TLShapeId[];
|
|
getStateDescendant(path: string): StateNode | undefined;
|
|
getStrokeWidth(id: TLSizeStyle['id']): number;
|
|
// (undocumented)
|
|
getSvg(ids?: TLShapeId[], opts?: Partial<{
|
|
scale: number;
|
|
background: boolean;
|
|
padding: number;
|
|
darkMode?: boolean | undefined;
|
|
preserveAspectRatio: React.SVGAttributes<SVGSVGElement>['preserveAspectRatio'];
|
|
}>): Promise<SVGSVGElement | undefined>;
|
|
getTransform(shape: TLShape): Matrix2d;
|
|
// (undocumented)
|
|
get gridSize(): number;
|
|
// (undocumented)
|
|
groupShapes(ids?: TLShapeId[], groupId?: TLShapeId): this;
|
|
hasAncestor(shape: TLShape | undefined, ancestorId: TLShapeId): boolean;
|
|
get hintingIds(): TLShapeId[];
|
|
readonly history: HistoryManager<this>;
|
|
// (undocumented)
|
|
get hoveredId(): null | TLShapeId;
|
|
// (undocumented)
|
|
get hoveredShape(): null | TLUnknownShape;
|
|
inputs: {
|
|
originPagePoint: Vec2d;
|
|
originScreenPoint: Vec2d;
|
|
previousPagePoint: Vec2d;
|
|
previousScreenPoint: Vec2d;
|
|
currentPagePoint: Vec2d;
|
|
currentScreenPoint: Vec2d;
|
|
keys: Set<string>;
|
|
buttons: Set<number>;
|
|
isPen: boolean;
|
|
shiftKey: boolean;
|
|
ctrlKey: boolean;
|
|
altKey: boolean;
|
|
isDragging: boolean;
|
|
isPointing: boolean;
|
|
isPinching: boolean;
|
|
isEditing: boolean;
|
|
isPanning: boolean;
|
|
pointerVelocity: Vec2d;
|
|
};
|
|
get instanceId(): TLInstanceId;
|
|
get instanceState(): TLInstance;
|
|
interrupt(): this;
|
|
get isChangingStyle(): boolean;
|
|
set isChangingStyle(v: boolean);
|
|
readonly isChromeForIos: boolean;
|
|
get isCoarsePointer(): boolean;
|
|
set isCoarsePointer(v: boolean);
|
|
get isFocused(): boolean;
|
|
// (undocumented)
|
|
get isGridMode(): boolean;
|
|
isIn(path: string): boolean;
|
|
isInAny(...paths: string[]): boolean;
|
|
readonly isIos: boolean;
|
|
get isMenuOpen(): boolean;
|
|
// (undocumented)
|
|
get isPenMode(): boolean;
|
|
isPointInShape(point: VecLike, shape: TLShape): boolean;
|
|
// (undocumented)
|
|
get isReadOnly(): boolean;
|
|
readonly isSafari: boolean;
|
|
isSelected(id: TLShapeId): boolean;
|
|
isShapeInPage(shape: TLShape, pageId?: TLPageId): boolean;
|
|
isShapeInViewport(id: TLShapeId): boolean;
|
|
isWithinSelection(id: TLShapeId): boolean;
|
|
// (undocumented)
|
|
lockShapes(_ids?: TLShapeId[]): this;
|
|
mark(reason?: string, onUndo?: boolean, onRedo?: boolean): string;
|
|
moveShapesToPage(ids: TLShapeId[], pageId: TLPageId): this;
|
|
nudgeShapes(ids: TLShapeId[], direction: Vec2dModel, major?: boolean, ephemeral?: boolean): this;
|
|
onCreateAssetFromFile(file: File): Promise<TLAsset>;
|
|
onCreateBookmarkFromUrl(url: string): Promise<{
|
|
image: string;
|
|
title: string;
|
|
description: string;
|
|
}>;
|
|
get onlySelectedShape(): TLBaseShape<any, any> | null;
|
|
openMenus: Set<string>;
|
|
packShapes(ids?: TLShapeId[], padding?: number): this;
|
|
get pages(): TLPage[];
|
|
get pageState(): TLInstancePageState;
|
|
pageToScreen(x: number, y: number, z?: number, camera?: Vec2dModel): {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
pan(dx: number, dy: number, opts?: AnimationOptions): this;
|
|
panZoomIntoView(ids: TLShapeId[], opts?: AnimationOptions): this;
|
|
// (undocumented)
|
|
popFocusLayer(): this;
|
|
// @internal
|
|
get props(): null | TLNullableShapeProps;
|
|
// (undocumented)
|
|
putContent(content: TLClipboardModel, options?: {
|
|
point?: VecLike;
|
|
select?: boolean;
|
|
preservePosition?: boolean;
|
|
preserveIds?: boolean;
|
|
}): this;
|
|
redo(): this;
|
|
renamePage(id: TLPageId, name: string, squashing?: boolean): this;
|
|
get renderingShapes(): {
|
|
id: TLShapeId;
|
|
index: number;
|
|
opacity: number;
|
|
isCulled: boolean;
|
|
isInViewport: boolean;
|
|
}[];
|
|
reorderShapes(operation: TLReorderOperation, ids: TLShapeId[]): this;
|
|
reparentShapesById(ids: TLShapeId[], parentId: TLParentId, insertIndex?: string): this;
|
|
// (undocumented)
|
|
replaceStoreContentsWithRecordsForOtherDocument(records: TLRecord[]): void;
|
|
resetZoom(point?: Vec2d, opts?: AnimationOptions): this;
|
|
// (undocumented)
|
|
resizeShape(id: TLShapeId, scale: VecLike, options?: {
|
|
initialBounds?: Box2d;
|
|
scaleOrigin?: VecLike;
|
|
scaleAxisRotation?: number;
|
|
initialShape?: TLShape;
|
|
initialPageTransform?: MatLike;
|
|
dragHandle?: TLResizeHandle;
|
|
mode?: TLResizeMode;
|
|
}): this;
|
|
readonly root: RootState;
|
|
rotateShapesBy(ids: TLShapeId[], delta: number): this;
|
|
screenToPage(x: number, y: number, z?: number, camera?: Vec2dModel): {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
// (undocumented)
|
|
get scribble(): null | TLScribble;
|
|
select(...ids: TLShapeId[]): this;
|
|
selectAll(): this;
|
|
get selectedIds(): TLShapeId[];
|
|
get selectedIdsSet(): ReadonlySet<TLShapeId>;
|
|
get selectedPageBounds(): Box2d | null;
|
|
get selectedShapes(): TLBaseShape<any, any>[];
|
|
// (undocumented)
|
|
get selectionBounds(): Box2d | undefined;
|
|
// (undocumented)
|
|
get selectionPageCenter(): null | Vec2d;
|
|
get selectionRotation(): number;
|
|
selectNone(): this;
|
|
sendBackward(ids?: TLShapeId[]): this;
|
|
sendToBack(ids?: TLShapeId[]): this;
|
|
setBrush(brush?: Box2dModel | null): this;
|
|
setCamera(x: number, y: number, z?: number, { stopFollowing }?: ViewportOptions): this;
|
|
// (undocumented)
|
|
setCroppingId(id: null | TLShapeId): this;
|
|
setCurrentPageId(pageId: TLPageId, { stopFollowing }?: ViewportOptions): this;
|
|
setCursor(cursor: Partial<TLCursor>): this;
|
|
// (undocumented)
|
|
setDarkMode(isDarkMode: boolean): void;
|
|
setEditingId(id: null | TLShapeId): this;
|
|
setErasingIds(ids?: TLShapeId[]): this;
|
|
setFocusLayer(next: null | TLShapeId): this;
|
|
// (undocumented)
|
|
setGridMode(isGridMode: boolean): void;
|
|
setHintingIds(ids: TLShapeId[]): this;
|
|
setHoveredId(id?: null | TLShapeId): this;
|
|
setInstancePageState(partial: Partial<TLInstancePageState>, ephemeral?: boolean): void;
|
|
// (undocumented)
|
|
setPenMode(isPenMode: boolean): void;
|
|
setProp(key: TLShapeProp, value: any, ephemeral?: boolean, squashing?: boolean): this;
|
|
// (undocumented)
|
|
setReadOnly(isReadOnly: boolean): void;
|
|
setScribble(scribble?: null | TLScribble): this;
|
|
setSelectedIds(ids: TLShapeId[], squashing?: boolean): this;
|
|
setSelectedTool(id: string, info?: {}): this;
|
|
setZoomBrush(zoomBrush?: Box2dModel | null): this;
|
|
get shapeIds(): Set<TLShapeId>;
|
|
get shapesArray(): TLShape[];
|
|
shapeUtils: {
|
|
readonly [K in string]?: TLShapeUtil<TLUnknownShape>;
|
|
};
|
|
// (undocumented)
|
|
slideCamera(opts?: {
|
|
speed: number;
|
|
direction: Vec2d;
|
|
friction: number;
|
|
speedThreshold?: number | undefined;
|
|
}): this;
|
|
readonly snaps: SnapManager;
|
|
get sortedShapesArray(): TLShape[];
|
|
stackShapes(operation: 'horizontal' | 'vertical', ids?: TLShapeId[], gap?: number): this;
|
|
startFollowingUser: (userId: TLUserId) => this | undefined;
|
|
stopCameraAnimation(): this;
|
|
stopFollowingUser: () => this;
|
|
readonly store: TLStore;
|
|
stretchShapes(operation: 'horizontal' | 'vertical', ids?: TLShapeId[]): this;
|
|
static styles: TLStyleCollections;
|
|
textMeasure: TextManager;
|
|
undo(): HistoryManager<this>;
|
|
// (undocumented)
|
|
ungroupShapes(ids?: TLShapeId[]): this;
|
|
updateAssets(assets: TLAssetPartial[]): this;
|
|
// @internal
|
|
updateCullingBounds(): this;
|
|
updateInstanceState(partial: Partial<Omit<TLInstance, 'currentPageId' | 'documentId' | 'userId'>>, ephemeral?: boolean, squashing?: boolean): this;
|
|
updatePage(partial: RequiredKeys<TLPage, 'id'>, squashing?: boolean): this;
|
|
updateShapes(partials: (null | TLShapePartial | undefined)[], squashing?: boolean): this;
|
|
updateUser(partial: Partial<TLUser>): void;
|
|
updateUserDocumentSettings(partial: Partial<TLUserDocument>, ephemeral?: boolean): this;
|
|
// (undocumented)
|
|
updateUserPresence: ({ cursor, color, viewportPageBounds, }?: {
|
|
cursor?: undefined | Vec2dModel;
|
|
color?: string | undefined;
|
|
viewportPageBounds?: Box2dModel | undefined;
|
|
}) => void;
|
|
updateViewportScreenBounds(center?: boolean): this;
|
|
get user(): TLUser;
|
|
// (undocumented)
|
|
get userDocumentSettings(): TLUserDocument;
|
|
get userId(): TLUserId;
|
|
// (undocumented)
|
|
get userPresence(): TLUserPresence | undefined;
|
|
get userSettings(): TLUser;
|
|
get viewportPageBounds(): Box2d;
|
|
get viewportPageCenter(): Vec2d;
|
|
get viewportScreenBounds(): Box2d;
|
|
get viewportScreenCenter(): Vec2d;
|
|
visitDescendants(parentId: TLParentId, visitor: (id: TLShapeId) => false | void): void;
|
|
// (undocumented)
|
|
get zoomBrush(): Box2dModel | null;
|
|
zoomIn(point?: Vec2d, opts?: AnimationOptions): this;
|
|
get zoomLevel(): number;
|
|
zoomOut(point?: Vec2d, opts?: AnimationOptions): this;
|
|
zoomToBounds(x: number, y: number, width: number, height: number, targetZoom?: number, opts?: AnimationOptions): this;
|
|
zoomToFit(opts?: AnimationOptions): this;
|
|
zoomToSelection(opts?: AnimationOptions): this;
|
|
}
|
|
|
|
// @internal (undocumented)
|
|
export function applyRotationToSnapshotShapes({ delta, app, snapshot, stage, }: {
|
|
delta: number;
|
|
snapshot: RotationSnapshot;
|
|
app: App;
|
|
stage: 'end' | 'one-off' | 'start' | 'update';
|
|
}): void;
|
|
|
|
// @public (undocumented)
|
|
export interface AppOptions {
|
|
config?: TldrawEditorConfig;
|
|
getContainer: () => HTMLElement;
|
|
instanceId?: TLInstanceId;
|
|
store: TLStore;
|
|
userId?: TLUserId;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const ARROW_LABEL_FONT_SIZES: Record<TLSizeType, number>;
|
|
|
|
// @public (undocumented)
|
|
export function blobAsString(blob: Blob): Promise<string>;
|
|
|
|
// @internal (undocumented)
|
|
export const BOUND_ARROW_OFFSET = 10;
|
|
|
|
// @internal (undocumented)
|
|
export function buildFromV1Document(app: App, document: LegacyTldrawDocument): void;
|
|
|
|
// @public (undocumented)
|
|
export const Canvas: React_2.MemoExoticComponent<({ onDropOverride, }: {
|
|
onDropOverride?: ((defaultOnDrop: (e: React_2.DragEvent<Element>) => Promise<void>) => (e: React_2.DragEvent<Element>) => Promise<void>) | undefined;
|
|
}) => JSX.Element>;
|
|
|
|
// @public (undocumented)
|
|
export const checkFlag: (flag: (() => boolean) | boolean | undefined) => boolean | undefined;
|
|
|
|
// @public (undocumented)
|
|
export type ClipboardPayload = {
|
|
data: string;
|
|
kind: 'file';
|
|
type: 'application/tldraw';
|
|
} | {
|
|
data: string;
|
|
kind: 'text';
|
|
type: 'application/tldraw';
|
|
} | {
|
|
data: TLClipboardModel;
|
|
kind: 'content';
|
|
type: 'application/tldraw';
|
|
};
|
|
|
|
// @public
|
|
export function containBoxSize(originalSize: BoxWidthHeight, containBoxSize: BoxWidthHeight): BoxWidthHeight;
|
|
|
|
// @public (undocumented)
|
|
export function correctSpacesToNbsp(input: string): string;
|
|
|
|
// @public (undocumented)
|
|
export function createAssetShapeAtPoint(app: App, svgString: string, point: Vec2dModel): Promise<void>;
|
|
|
|
// @public
|
|
export function createBookmarkShapeAtPoint(app: App, url: string, point: Vec2dModel): Promise<void>;
|
|
|
|
// @public (undocumented)
|
|
export function createEmbedShapeAtPoint(app: App, url: string, point: Vec2dModel, props: {
|
|
width?: number;
|
|
height?: number;
|
|
doesResize?: boolean;
|
|
}): void;
|
|
|
|
// @public (undocumented)
|
|
export function createShapesFromFiles(app: App, files: File[], position: VecLike, _ignoreParent?: boolean): Promise<void>;
|
|
|
|
// @public (undocumented)
|
|
export function dataTransferItemAsString(item: DataTransferItem): Promise<string>;
|
|
|
|
// @public (undocumented)
|
|
export function dataUrlToFile(url: string, filename: string, mimeType: string): Promise<File>;
|
|
|
|
// @internal (undocumented)
|
|
export const debugFlags: {
|
|
preventDefaultLogging: Atom<boolean, unknown>;
|
|
pointerCaptureLogging: Atom<boolean, unknown>;
|
|
pointerCaptureTracking: Atom<boolean, unknown>;
|
|
pointerCaptureTrackingObject: Atom<Map<Element, number>, unknown>;
|
|
elementRemovalLogging: Atom<boolean, unknown>;
|
|
debugSvg: Atom<boolean, unknown>;
|
|
throwToBlob: Atom<boolean, unknown>;
|
|
peopleMenu: Atom<boolean, unknown>;
|
|
logMessages: Atom<never[], unknown>;
|
|
resetConnectionEveryPing: Atom<boolean, unknown>;
|
|
newLiveCollaborators: Atom<boolean, unknown>;
|
|
};
|
|
|
|
// @internal (undocumented)
|
|
export const DEFAULT_ANIMATION_OPTIONS: {
|
|
duration: number;
|
|
easing: (t: number) => number;
|
|
};
|
|
|
|
// @internal (undocumented)
|
|
export const DEFAULT_BOOKMARK_HEIGHT = 320;
|
|
|
|
// @internal (undocumented)
|
|
export const DEFAULT_BOOKMARK_WIDTH = 300;
|
|
|
|
// @public (undocumented)
|
|
export const defaultEditorAssetUrls: EditorAssetUrls;
|
|
|
|
// @public (undocumented)
|
|
export function defaultEmptyAs(str: string, dflt: string): string;
|
|
|
|
// @internal (undocumented)
|
|
export const DefaultErrorFallback: TLErrorFallback;
|
|
|
|
// @public (undocumented)
|
|
export function defineShape<ShapeType extends TLUnknownShape, ShapeUtil extends TLShapeUtil<ShapeType> = TLShapeUtil<ShapeType>>({ type, getShapeUtil, validator, migrations, }: {
|
|
type: ShapeType['type'];
|
|
getShapeUtil: () => TLShapeUtilConstructor<ShapeType, ShapeUtil>;
|
|
validator?: StoreValidator<ShapeType>;
|
|
migrations?: Migrations;
|
|
}): TLShapeDef<ShapeType, ShapeUtil>;
|
|
|
|
// @internal (undocumented)
|
|
export const DOUBLE_CLICK_DURATION = 450;
|
|
|
|
// @public (undocumented)
|
|
export function downloadDataURLAsFile(dataUrl: string, filename: string): void;
|
|
|
|
// @internal (undocumented)
|
|
export const DRAG_DISTANCE = 4;
|
|
|
|
// @public (undocumented)
|
|
export type EditorAssetUrls = {
|
|
fonts: {
|
|
monospace: string;
|
|
serif: string;
|
|
sansSerif: string;
|
|
draw: string;
|
|
};
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type EmbedResult = {
|
|
definition: EmbedDefinition;
|
|
url: string;
|
|
embedUrl: string;
|
|
} | undefined;
|
|
|
|
// @public (undocumented)
|
|
export class ErrorBoundary extends React_2.Component<React_2.PropsWithRef<React_2.PropsWithChildren<ErrorBoundaryProps>>, ErrorBoundaryState> {
|
|
// (undocumented)
|
|
componentDidCatch(error: unknown): void;
|
|
// (undocumented)
|
|
static getDerivedStateFromError(error: Error): {
|
|
error: Error;
|
|
};
|
|
// (undocumented)
|
|
render(): React_2.ReactNode;
|
|
// (undocumented)
|
|
state: ErrorBoundaryState;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface ErrorBoundaryProps {
|
|
// (undocumented)
|
|
children: React_2.ReactNode;
|
|
// (undocumented)
|
|
fallback: (error: unknown) => React_2.ReactNode;
|
|
// (undocumented)
|
|
onError?: ((error: unknown) => void) | null;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function ErrorScreen({ children }: {
|
|
children: any;
|
|
}): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export interface ErrorSyncedStore {
|
|
// (undocumented)
|
|
readonly error: Error;
|
|
// (undocumented)
|
|
readonly status: 'error';
|
|
// (undocumented)
|
|
readonly store?: undefined;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const EVENT_NAME_MAP: Record<Exclude<TLEventName, TLPinchEventName>, keyof TLEventHandlers>;
|
|
|
|
// @public
|
|
export function fileToBase64(file: Blob): Promise<string>;
|
|
|
|
// @public (undocumented)
|
|
export const FONT_ALIGNMENT: Record<TLAlignType, string>;
|
|
|
|
// @public (undocumented)
|
|
export const FONT_FAMILIES: Record<TLFontType, string>;
|
|
|
|
// @public (undocumented)
|
|
export const FONT_SIZES: Record<TLSizeType, number>;
|
|
|
|
// @public
|
|
export function getEmbedInfo(inputUrl: string): EmbedResult;
|
|
|
|
// @public
|
|
export function getEmbedInfoUnsafely(inputUrl: string): EmbedResult;
|
|
|
|
// @public
|
|
export function getFileMetaData(file: File): Promise<{
|
|
isAnimated: boolean;
|
|
}>;
|
|
|
|
export { getHashForString }
|
|
|
|
// @public
|
|
export function getImageSizeFromSrc(dataURL: string): Promise<{
|
|
w: number;
|
|
h: number;
|
|
}>;
|
|
|
|
// @public
|
|
export function getIncrementedName(name: string, others: string[]): string;
|
|
|
|
// @public (undocumented)
|
|
export function getIndexAbove(below: string): string;
|
|
|
|
// @public (undocumented)
|
|
export function getIndexBelow(above: string): string;
|
|
|
|
// @public (undocumented)
|
|
export function getIndexBetween(below: string, above?: string): string;
|
|
|
|
// @public (undocumented)
|
|
export function getIndexGenerator(): () => string;
|
|
|
|
// @public (undocumented)
|
|
export function getIndices(n: number): string[];
|
|
|
|
// @public (undocumented)
|
|
export function getIndicesAbove(below: string, n: number): string[];
|
|
|
|
// @public (undocumented)
|
|
export function getIndicesBelow(above: string, n: number): string[];
|
|
|
|
// @public (undocumented)
|
|
export function getIndicesBetween(below: string | undefined, above: string | undefined, n: number): string[];
|
|
|
|
// @public (undocumented)
|
|
export function getMaxIndex(...indices: (string | undefined)[]): string;
|
|
|
|
// @public
|
|
export function getMediaAssetFromFile(file: File): Promise<TLAsset>;
|
|
|
|
// @internal (undocumented)
|
|
export function getPointerInfo(e: PointerEvent | React.PointerEvent, container: HTMLElement): {
|
|
point: {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
shiftKey: boolean;
|
|
altKey: boolean;
|
|
ctrlKey: boolean;
|
|
pointerId: number;
|
|
button: number;
|
|
isPen: boolean;
|
|
};
|
|
|
|
// @public
|
|
export function getResizedImageDataUrl(dataURLForImage: string, width: number, height: number): Promise<string>;
|
|
|
|
// @internal (undocumented)
|
|
export function getRotationSnapshot({ app }: {
|
|
app: App;
|
|
}): {
|
|
selectionPageCenter: Vec2d;
|
|
initialCursorAngle: number;
|
|
initialSelectionRotation: number;
|
|
shapeSnapshots: {
|
|
shape: TLBaseShape<any, any>;
|
|
initialPagePoint: Vec2d;
|
|
}[];
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export function getSplineForLineShape(shape: TLLineShape): NonNullable<CubicSpline2d | Polyline2d>;
|
|
|
|
// @public (undocumented)
|
|
export function getSvgAsDataUrl(svg: SVGElement): Promise<string>;
|
|
|
|
// @public (undocumented)
|
|
export function getSvgAsDataUrlSync(node: SVGElement): string;
|
|
|
|
// @public (undocumented)
|
|
export function getSvgAsImage(svg: SVGElement, options: {
|
|
type: TLCopyType | TLExportType;
|
|
quality: number;
|
|
scale: number;
|
|
}): Promise<Blob | null>;
|
|
|
|
// @public (undocumented)
|
|
export function getSvgAsString(svg: SVGElement): string;
|
|
|
|
// @public
|
|
export function getSvgPathFromStroke(points: Vec2d[], closed?: boolean): string;
|
|
|
|
// @public
|
|
export function getSvgPathFromStrokePoints(points: StrokePoint[], closed?: boolean): string;
|
|
|
|
// @public (undocumented)
|
|
export function getTextBoundingBox(text: SVGTextElement): DOMRect;
|
|
|
|
// @public (undocumented)
|
|
export const getValidHttpURLList: (url: string) => string[] | undefined;
|
|
|
|
// @public
|
|
export function getVideoSizeFromSrc(src: string): Promise<{
|
|
w: number;
|
|
h: number;
|
|
}>;
|
|
|
|
// @internal (undocumented)
|
|
export const GRID_INCREMENT = 5;
|
|
|
|
// @public (undocumented)
|
|
export const GRID_STEPS: {
|
|
min: number;
|
|
mid: number;
|
|
step: number;
|
|
}[];
|
|
|
|
// @internal (undocumented)
|
|
export const HAND_TOOL_FRICTION = 0.09;
|
|
|
|
// @public (undocumented)
|
|
export function hardResetApp(): void;
|
|
|
|
// @internal (undocumented)
|
|
export const HASH_PATERN_ZOOM_NAMES: Record<string, string>;
|
|
|
|
// @public (undocumented)
|
|
export function HTMLContainer({ children, className, ...rest }: HTMLContainerProps): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export type HTMLContainerProps = React_2.HTMLAttributes<HTMLDivElement>;
|
|
|
|
// @public (undocumented)
|
|
export const ICON_SIZES: Record<TLSizeType, number>;
|
|
|
|
// @public (undocumented)
|
|
export function indexGenerator(n?: number): Generator<string, void, unknown>;
|
|
|
|
// @public (undocumented)
|
|
export interface InitializingSyncedStore {
|
|
// (undocumented)
|
|
readonly error?: undefined;
|
|
// (undocumented)
|
|
readonly status: 'loading';
|
|
// (undocumented)
|
|
readonly store?: undefined;
|
|
}
|
|
|
|
// @public
|
|
export function isAnimated(buffer: ArrayBuffer): boolean;
|
|
|
|
// @public (undocumented)
|
|
export function isGeoShape(shape: TLShape): shape is TLGeoShape;
|
|
|
|
// @public
|
|
export function isGIF(buffer: ArrayBuffer): boolean;
|
|
|
|
// @public (undocumented)
|
|
export const isImage: (ext: string) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export function isNoteShape(shape: TLShape): shape is TLNoteShape;
|
|
|
|
// @public
|
|
export function isSerializable(value: any): boolean;
|
|
|
|
// @public (undocumented)
|
|
export function isShapeWithHandles(shape: TLShape): boolean;
|
|
|
|
// @public (undocumented)
|
|
export const isSvgText: (text: string) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export const isValidHttpURL: (url: string) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export const LABEL_FONT_SIZES: Record<TLSizeType, number>;
|
|
|
|
// @internal (undocumented)
|
|
export interface LegacyTldrawDocument {
|
|
// (undocumented)
|
|
assets: TDAssets;
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
name: string;
|
|
// (undocumented)
|
|
pages: Record<string, TDPage>;
|
|
// (undocumented)
|
|
pageStates: Record<string, TLV1PageState>;
|
|
// (undocumented)
|
|
version: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function LoadingScreen({ children }: {
|
|
children: any;
|
|
}): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export function loopToHtmlElement(elm: Element): HTMLElement;
|
|
|
|
// @internal (undocumented)
|
|
export const MAJOR_NUDGE_FACTOR = 10;
|
|
|
|
// @public (undocumented)
|
|
export function matchEmbedUrl(url: string): {
|
|
definition: {
|
|
readonly type: "codepen";
|
|
readonly title: "Codepen";
|
|
readonly hostnames: readonly ["codepen.io"];
|
|
readonly minWidth: 300;
|
|
readonly minHeight: 300;
|
|
readonly width: 520;
|
|
readonly height: 400;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "codesandbox";
|
|
readonly title: "CodeSandbox";
|
|
readonly hostnames: readonly ["codesandbox.io"];
|
|
readonly minWidth: 300;
|
|
readonly minHeight: 300;
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "excalidraw";
|
|
readonly title: "Excalidraw";
|
|
readonly hostnames: readonly ["excalidraw.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly isAspectRatioLocked: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "felt";
|
|
readonly title: "Felt";
|
|
readonly hostnames: readonly ["felt.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "figma";
|
|
readonly title: "Figma";
|
|
readonly hostnames: readonly ["figma.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "github_gist";
|
|
readonly title: "GitHub Gist";
|
|
readonly hostnames: readonly ["gist.github.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "google_calendar";
|
|
readonly title: "Google Calendar";
|
|
readonly hostnames: readonly ["calendar.google.*"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly minWidth: 460;
|
|
readonly minHeight: 360;
|
|
readonly doesResize: true;
|
|
readonly instructionLink: "https://support.google.com/calendar/answer/41207?hl=en";
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "google_maps";
|
|
readonly title: "Google Maps";
|
|
readonly hostnames: readonly ["google.*"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "google_slides";
|
|
readonly title: "Google Slides";
|
|
readonly hostnames: readonly ["docs.google.*"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly minWidth: 460;
|
|
readonly minHeight: 360;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "observable";
|
|
readonly title: "Observable";
|
|
readonly hostnames: readonly ["observablehq.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly isAspectRatioLocked: false;
|
|
readonly backgroundColor: "#fff";
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "replit";
|
|
readonly title: "Replit";
|
|
readonly hostnames: readonly ["replit.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "scratch";
|
|
readonly title: "Scratch";
|
|
readonly hostnames: readonly ["scratch.mit.edu"];
|
|
readonly width: 520;
|
|
readonly height: 400;
|
|
readonly doesResize: false;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "spotify";
|
|
readonly title: "Spotify";
|
|
readonly hostnames: readonly ["open.spotify.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly minHeight: 500;
|
|
readonly overrideOutlineRadius: 12;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "tldraw";
|
|
readonly title: "tldraw";
|
|
readonly hostnames: readonly ["beta.tldraw.com", "lite.tldraw.com", "www.tldraw.com"];
|
|
readonly minWidth: 300;
|
|
readonly minHeight: 300;
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "vimeo";
|
|
readonly title: "Vimeo";
|
|
readonly hostnames: readonly ["vimeo.com", "player.vimeo.com"];
|
|
readonly width: 640;
|
|
readonly height: 360;
|
|
readonly doesResize: true;
|
|
readonly isAspectRatioLocked: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "youtube";
|
|
readonly title: "YouTube";
|
|
readonly hostnames: readonly ["*.youtube.com", "youtube.com", "youtu.be"];
|
|
readonly width: 800;
|
|
readonly height: 450;
|
|
readonly doesResize: true;
|
|
readonly overridePermissions: {
|
|
readonly 'allow-presentation': true;
|
|
};
|
|
readonly isAspectRatioLocked: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
};
|
|
url: string;
|
|
embedUrl: string;
|
|
} | undefined;
|
|
|
|
// @public (undocumented)
|
|
export function matchUrl(url: string): {
|
|
definition: {
|
|
readonly type: "codepen";
|
|
readonly title: "Codepen";
|
|
readonly hostnames: readonly ["codepen.io"];
|
|
readonly minWidth: 300;
|
|
readonly minHeight: 300;
|
|
readonly width: 520;
|
|
readonly height: 400;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "codesandbox";
|
|
readonly title: "CodeSandbox";
|
|
readonly hostnames: readonly ["codesandbox.io"];
|
|
readonly minWidth: 300;
|
|
readonly minHeight: 300;
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "excalidraw";
|
|
readonly title: "Excalidraw";
|
|
readonly hostnames: readonly ["excalidraw.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly isAspectRatioLocked: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "felt";
|
|
readonly title: "Felt";
|
|
readonly hostnames: readonly ["felt.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "figma";
|
|
readonly title: "Figma";
|
|
readonly hostnames: readonly ["figma.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "github_gist";
|
|
readonly title: "GitHub Gist";
|
|
readonly hostnames: readonly ["gist.github.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "google_calendar";
|
|
readonly title: "Google Calendar";
|
|
readonly hostnames: readonly ["calendar.google.*"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly minWidth: 460;
|
|
readonly minHeight: 360;
|
|
readonly doesResize: true;
|
|
readonly instructionLink: "https://support.google.com/calendar/answer/41207?hl=en";
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "google_maps";
|
|
readonly title: "Google Maps";
|
|
readonly hostnames: readonly ["google.*"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "google_slides";
|
|
readonly title: "Google Slides";
|
|
readonly hostnames: readonly ["docs.google.*"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly minWidth: 460;
|
|
readonly minHeight: 360;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "observable";
|
|
readonly title: "Observable";
|
|
readonly hostnames: readonly ["observablehq.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly isAspectRatioLocked: false;
|
|
readonly backgroundColor: "#fff";
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "replit";
|
|
readonly title: "Replit";
|
|
readonly hostnames: readonly ["replit.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "scratch";
|
|
readonly title: "Scratch";
|
|
readonly hostnames: readonly ["scratch.mit.edu"];
|
|
readonly width: 520;
|
|
readonly height: 400;
|
|
readonly doesResize: false;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "spotify";
|
|
readonly title: "Spotify";
|
|
readonly hostnames: readonly ["open.spotify.com"];
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly minHeight: 500;
|
|
readonly overrideOutlineRadius: 12;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "tldraw";
|
|
readonly title: "tldraw";
|
|
readonly hostnames: readonly ["beta.tldraw.com", "lite.tldraw.com", "www.tldraw.com"];
|
|
readonly minWidth: 300;
|
|
readonly minHeight: 300;
|
|
readonly width: 720;
|
|
readonly height: 500;
|
|
readonly doesResize: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "vimeo";
|
|
readonly title: "Vimeo";
|
|
readonly hostnames: readonly ["vimeo.com", "player.vimeo.com"];
|
|
readonly width: 640;
|
|
readonly height: 360;
|
|
readonly doesResize: true;
|
|
readonly isAspectRatioLocked: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
} | {
|
|
readonly type: "youtube";
|
|
readonly title: "YouTube";
|
|
readonly hostnames: readonly ["*.youtube.com", "youtube.com", "youtu.be"];
|
|
readonly width: 800;
|
|
readonly height: 450;
|
|
readonly doesResize: true;
|
|
readonly overridePermissions: {
|
|
readonly 'allow-presentation': true;
|
|
};
|
|
readonly isAspectRatioLocked: true;
|
|
readonly toEmbedUrl: (url: string) => string | undefined;
|
|
readonly fromEmbedUrl: (url: string) => string | undefined;
|
|
};
|
|
embedUrl: string;
|
|
url: string;
|
|
} | undefined;
|
|
|
|
// @internal (undocumented)
|
|
export const MAX_ASSET_HEIGHT = 1000;
|
|
|
|
// @internal (undocumented)
|
|
export const MAX_ASSET_WIDTH = 1000;
|
|
|
|
// @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_ARROW_LENGTH = 48;
|
|
|
|
// @internal (undocumented)
|
|
export const MIN_ZOOM = 0.1;
|
|
|
|
// @internal (undocumented)
|
|
export const MINOR_NUDGE_FACTOR = 1;
|
|
|
|
// @internal (undocumented)
|
|
export const MULTI_CLICK_DURATION = 200;
|
|
|
|
// @public (undocumented)
|
|
export function normalizeWheel(event: React.WheelEvent<HTMLElement> | WheelEvent): {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type OnBeforeCreateHandler<T extends TLShape> = (next: T) => T | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnBeforeUpdateHandler<T extends TLShape> = (prev: T, next: T) => T | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnBindingChangeHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnChildrenChangeHandler<T extends TLShape> = (shape: T) => TLShapePartial[] | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnClickHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnDoubleClickHandleHandler<T extends TLShape> = (shape: T, handle: TLHandle) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnDoubleClickHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnDragHandler<T extends TLShape, R = void> = (shape: T, shapes: TLShape[]) => R;
|
|
|
|
// @public (undocumented)
|
|
export type OnEditEndHandler<T extends TLShape> = (shape: T) => void;
|
|
|
|
// @public (undocumented)
|
|
export type OnHandleChangeHandler<T extends TLShape> = (shape: T, info: {
|
|
handle: TLHandle;
|
|
isPrecise: boolean;
|
|
}) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnResizeEndHandler<T extends TLShape> = EventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type OnResizeHandler<T extends TLShape> = (shape: T, info: {
|
|
newPoint: Vec2dModel;
|
|
handle: TLResizeHandle;
|
|
mode: TLResizeMode;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
initialBounds: Box2d;
|
|
initialShape: T;
|
|
}) => Partial<TLShapePartial<T>> | undefined | void;
|
|
|
|
// @public (undocumented)
|
|
export type OnResizeStartHandler<T extends TLShape> = EventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type OnRotateEndHandler<T extends TLShape> = EventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type OnRotateHandler<T extends TLShape> = EventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type OnRotateStartHandler<T extends TLShape> = EventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type OnTranslateEndHandler<T extends TLShape> = EventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type OnTranslateHandler<T extends TLShape> = EventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type OnTranslateStartHandler<T extends TLShape> = EventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export function openWindow(url: string, target?: string): void;
|
|
|
|
// @internal (undocumented)
|
|
export function OptionalErrorBoundary({ children, fallback, ...props }: Omit<ErrorBoundaryProps, 'fallback'> & {
|
|
fallback: ((error: unknown) => React_2.ReactNode) | null;
|
|
}): JSX.Element;
|
|
|
|
// @public
|
|
export function preventDefault(event: Event | React_3.BaseSyntheticEvent): void;
|
|
|
|
// @public (undocumented)
|
|
export interface ReadySyncedStore {
|
|
// (undocumented)
|
|
readonly error?: undefined;
|
|
// (undocumented)
|
|
readonly status: 'synced';
|
|
// (undocumented)
|
|
readonly store: TLStore;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function refreshPage(): void;
|
|
|
|
// @public (undocumented)
|
|
export function releasePointerCapture(element: Element, event: PointerEvent | React_3.PointerEvent<Element>): void;
|
|
|
|
// @internal (undocumented)
|
|
export const REMOVE_SYMBOL: unique symbol;
|
|
|
|
// @public (undocumented)
|
|
export type RequiredKeys<T, K extends keyof T> = Pick<T, K> & Partial<T>;
|
|
|
|
// @internal (undocumented)
|
|
export const RICH_TYPES: Record<string, boolean>;
|
|
|
|
// @public (undocumented)
|
|
export function rotateBoxShadow(rotation: number, shadows: {
|
|
offsetX: number;
|
|
offsetY: number;
|
|
blur: number;
|
|
spread: number;
|
|
color: string;
|
|
}[]): string;
|
|
|
|
// @public (undocumented)
|
|
export const ROTATING_SHADOWS: {
|
|
offsetX: number;
|
|
offsetY: number;
|
|
blur: number;
|
|
spread: number;
|
|
color: string;
|
|
}[];
|
|
|
|
// @internal (undocumented)
|
|
export type RotationSnapshot = ReturnType<typeof getRotationSnapshot>;
|
|
|
|
// @public (undocumented)
|
|
export const runtime: {
|
|
openWindow: (url: string, target: string) => void;
|
|
refreshPage: () => void;
|
|
hardReset: () => void;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export function setPointerCapture(element: Element, event: PointerEvent | React_3.PointerEvent<Element>): void;
|
|
|
|
// @public (undocumented)
|
|
export function setPropsForNextShape(previousProps: TLInstancePropsForNextShape, newProps: Partial<TLShapeProps>): TLInstancePropsForNextShape;
|
|
|
|
// @public (undocumented)
|
|
export function setRuntimeOverrides(input: Partial<typeof runtime>): void;
|
|
|
|
// @public (undocumented)
|
|
export function snapToGrid(n: number, gridSize: number): number;
|
|
|
|
// @public (undocumented)
|
|
export function sortById<T extends {
|
|
id: string;
|
|
}>(a: T, b: T): -1 | 0 | 1;
|
|
|
|
// @public (undocumented)
|
|
export function sortByIndex<T extends {
|
|
index: string;
|
|
}>(a: T, b: T): -1 | 0 | 1;
|
|
|
|
// @public (undocumented)
|
|
export abstract class StateNode implements Partial<TLEventHandlers> {
|
|
constructor(app: App, parent?: StateNode);
|
|
// (undocumented)
|
|
app: App;
|
|
// (undocumented)
|
|
static children?: () => StateNodeConstructor[];
|
|
// (undocumented)
|
|
children?: Record<string, StateNode>;
|
|
// (undocumented)
|
|
current: Atom<StateNode | undefined>;
|
|
// (undocumented)
|
|
enter(info: any, from: string): void;
|
|
// (undocumented)
|
|
exit(info: any, from: string): void;
|
|
// (undocumented)
|
|
handleEvent(info: Exclude<TLEventInfo, TLPinchEventInfo>): void;
|
|
// (undocumented)
|
|
static id: string;
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
static initial?: string;
|
|
// (undocumented)
|
|
initial?: string;
|
|
// (undocumented)
|
|
isActive: boolean;
|
|
// (undocumented)
|
|
onCancel?: TLEventHandlers['onCancel'];
|
|
// (undocumented)
|
|
onComplete?: TLEventHandlers['onComplete'];
|
|
// (undocumented)
|
|
onDoubleClick?: TLEventHandlers['onDoubleClick'];
|
|
// (undocumented)
|
|
onEnter?: UiEnterHandler;
|
|
// (undocumented)
|
|
onExit?: UiExitHandler;
|
|
// (undocumented)
|
|
onInterrupt?: TLEventHandlers['onInterrupt'];
|
|
// (undocumented)
|
|
onKeyDown?: TLEventHandlers['onKeyDown'];
|
|
// (undocumented)
|
|
onKeyRepeat?: TLEventHandlers['onKeyRepeat'];
|
|
// (undocumented)
|
|
onKeyUp?: TLEventHandlers['onKeyUp'];
|
|
// (undocumented)
|
|
onMiddleClick?: TLEventHandlers['onMiddleClick'];
|
|
// (undocumented)
|
|
onPointerDown?: TLEventHandlers['onPointerDown'];
|
|
// (undocumented)
|
|
onPointerEnter?: TLEventHandlers['onPointerEnter'];
|
|
// (undocumented)
|
|
onPointerLeave?: TLEventHandlers['onPointerLeave'];
|
|
// (undocumented)
|
|
onPointerMove?: TLEventHandlers['onPointerMove'];
|
|
// (undocumented)
|
|
onPointerUp?: TLEventHandlers['onPointerUp'];
|
|
// (undocumented)
|
|
onQuadrupleClick?: TLEventHandlers['onQuadrupleClick'];
|
|
// (undocumented)
|
|
onRightClick?: TLEventHandlers['onRightClick'];
|
|
// (undocumented)
|
|
onTripleClick?: TLEventHandlers['onTripleClick'];
|
|
// (undocumented)
|
|
onWheel?: TLEventHandlers['onWheel'];
|
|
// (undocumented)
|
|
parent: StateNode;
|
|
// (undocumented)
|
|
path: Computed<string>;
|
|
// (undocumented)
|
|
readonly styles: TLStyleType[];
|
|
// (undocumented)
|
|
transition(id: string, info: any): this;
|
|
// (undocumented)
|
|
type: StateNodeType;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface StateNodeConstructor {
|
|
// (undocumented)
|
|
new (app: App, parent?: StateNode): StateNode;
|
|
// (undocumented)
|
|
children?: () => StateNodeConstructor[];
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
initial?: string;
|
|
// (undocumented)
|
|
styles?: TLStyleType[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const STYLES: TLStyleCollections;
|
|
|
|
// @internal (undocumented)
|
|
export const SVG_PADDING = 32;
|
|
|
|
// @public (undocumented)
|
|
export function SVGContainer({ children, className, ...rest }: SVGContainerProps): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export type SVGContainerProps = React_2.HTMLAttributes<SVGElement>;
|
|
|
|
// @public (undocumented)
|
|
export type SyncedStore = ErrorSyncedStore | InitializingSyncedStore | ReadySyncedStore;
|
|
|
|
// @public (undocumented)
|
|
export const TEXT_PROPS: {
|
|
lineHeight: number;
|
|
fontWeight: string;
|
|
fontVariant: string;
|
|
fontStyle: string;
|
|
padding: string;
|
|
maxWidth: string;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export const TLArrowShapeDef: TLShapeDef<TLArrowShape, TLArrowUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLArrowUtil extends TLShapeUtil<TLArrowShape> {
|
|
// (undocumented)
|
|
canBind: () => boolean;
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLArrowShape['props'];
|
|
// (undocumented)
|
|
getArrowInfo(shape: TLArrowShape): ArrowInfo | undefined;
|
|
// (undocumented)
|
|
getBounds(shape: TLArrowShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLArrowShape): Vec2d;
|
|
// (undocumented)
|
|
getEditingBounds: (shape: TLArrowShape) => Box2d;
|
|
// (undocumented)
|
|
getHandles(shape: TLArrowShape): TLHandle[];
|
|
// (undocumented)
|
|
getLabelBounds(shape: TLArrowShape): Box2d | null;
|
|
// (undocumented)
|
|
getOutline(shape: TLArrowShape): Vec2dModel[];
|
|
// (undocumented)
|
|
getOutlineWithoutLabel(shape: TLArrowShape): VecLike[];
|
|
// (undocumented)
|
|
hideResizeHandles: TLShapeUtilFlag<TLArrowShape>;
|
|
// (undocumented)
|
|
hideRotateHandle: TLShapeUtilFlag<TLArrowShape>;
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: TLShapeUtilFlag<TLArrowShape>;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: TLShapeUtilFlag<TLArrowShape>;
|
|
// (undocumented)
|
|
hitTestLineSegment(shape: TLArrowShape, A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(shape: TLArrowShape, point: VecLike): boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLArrowShape): JSX.Element | null;
|
|
// (undocumented)
|
|
isClosed: () => boolean;
|
|
// (undocumented)
|
|
get labelBoundsCache(): ComputedCache<Box2d | null, TLArrowShape>;
|
|
// (undocumented)
|
|
onDoubleClickHandle: (shape: TLArrowShape, handle: TLHandle) => TLShapePartial<TLArrowShape> | void;
|
|
// (undocumented)
|
|
onEditEnd: OnEditEndHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
onHandleChange: OnHandleChangeHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
onResize: OnResizeHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
onTranslateStart: OnTranslateStartHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
render(shape: TLArrowShape): JSX.Element | null;
|
|
// (undocumented)
|
|
snapPoints(_shape: TLArrowShape): Vec2d[];
|
|
// (undocumented)
|
|
toSvg(shape: TLArrowShape, font: string, colors: TLExportColors): SVGGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface TLBaseEventInfo {
|
|
// (undocumented)
|
|
altKey: boolean;
|
|
// (undocumented)
|
|
ctrlKey: boolean;
|
|
// (undocumented)
|
|
shiftKey: boolean;
|
|
// (undocumented)
|
|
type: UiEventType;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const TLBookmarkShapeDef: TLShapeDef<TLBookmarkShape, TLBookmarkUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLBookmarkUtil extends TLBoxUtil<TLBookmarkShape> {
|
|
// (undocumented)
|
|
canResize: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLBookmarkShape['props'];
|
|
// (undocumented)
|
|
getHumanReadableAddress(shape: TLBookmarkShape): string;
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: () => boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLBookmarkShape): JSX.Element;
|
|
// (undocumented)
|
|
onBeforeCreate?: OnBeforeCreateHandler<TLBookmarkShape>;
|
|
// (undocumented)
|
|
onBeforeUpdate?: OnBeforeUpdateHandler<TLBookmarkShape>;
|
|
// (undocumented)
|
|
render(shape: TLBookmarkShape): JSX.Element;
|
|
// (undocumented)
|
|
static type: string;
|
|
// (undocumented)
|
|
protected updateBookmarkAsset: {
|
|
(shape: TLBookmarkShape): Promise<void>;
|
|
cancel(): void;
|
|
};
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLBoxLike = TLBaseShape<string, {
|
|
w: number;
|
|
h: number;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export abstract class TLBoxTool extends StateNode {
|
|
// (undocumented)
|
|
static children: () => (typeof Idle_4 | typeof Pointing_3)[];
|
|
// (undocumented)
|
|
static id: string;
|
|
// (undocumented)
|
|
static initial: string;
|
|
// (undocumented)
|
|
abstract shapeType: string;
|
|
// (undocumented)
|
|
styles: ("align" | "arrowheadEnd" | "arrowheadStart" | "color" | "dash" | "fill" | "font" | "geo" | "icon" | "labelColor" | "opacity" | "size" | "spline")[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export abstract class TLBoxUtil<Shape extends TLBoxLike> extends TLShapeUtil<Shape> {
|
|
// (undocumented)
|
|
getBounds(shape: Shape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: Shape): Vec2d;
|
|
// (undocumented)
|
|
getOutline(shape: Shape): Vec2d[];
|
|
// (undocumented)
|
|
hitTestLineSegment(shape: Shape, A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(shape: Shape, point: VecLike): boolean;
|
|
// (undocumented)
|
|
onResize: OnResizeHandler<any>;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLCancelEvent = (info: TLCancelEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLCancelEventInfo = {
|
|
type: 'misc';
|
|
name: 'cancel';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLChange = HistoryEntry<any>;
|
|
|
|
// @public (undocumented)
|
|
export type TLClickEvent = (info: TLClickEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLClickEventInfo = TLBaseEventInfo & {
|
|
type: 'click';
|
|
name: TLCLickEventName;
|
|
point: VecLike;
|
|
pointerId: number;
|
|
button: number;
|
|
phase: 'down' | 'settle' | 'up';
|
|
} & TLPointerEventTarget;
|
|
|
|
// @public (undocumented)
|
|
export type TLCLickEventName = 'double_click' | 'quadruple_click' | 'triple_click';
|
|
|
|
// @public (undocumented)
|
|
export interface TLClipboardModel {
|
|
// (undocumented)
|
|
assets: TLAsset[];
|
|
// (undocumented)
|
|
rootShapeIds: TLShapeId[];
|
|
// (undocumented)
|
|
schema: SerializedSchema;
|
|
// (undocumented)
|
|
shapes: TLShape[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLCommand<Name extends string = any, Data = any> = {
|
|
type: 'command';
|
|
id: string;
|
|
data: Data;
|
|
name: Name;
|
|
preservesRedoStack?: boolean;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLCommandHandler<Data> = {
|
|
do: (data: Data) => void;
|
|
undo: (data: Data) => void;
|
|
redo?: (data: Data) => void;
|
|
squash?: (prevData: Data, nextData: Data) => Data;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLCompleteEvent = (info: TLCompleteEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLCompleteEventInfo = {
|
|
type: 'misc';
|
|
name: 'complete';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLCopyType = 'jpeg' | 'json' | 'png' | 'svg';
|
|
|
|
// @public (undocumented)
|
|
export function TldrawEditor(props: TldrawEditorProps): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export class TldrawEditorConfig {
|
|
constructor(args: {
|
|
shapes?: readonly TLShapeDef<any, any>[];
|
|
tools?: readonly StateNodeConstructor[];
|
|
allowUnknownShapes?: boolean;
|
|
derivePresenceState?: (store: TLStore) => Signal<null | TLInstancePresence>;
|
|
});
|
|
// (undocumented)
|
|
createStore(config: {
|
|
initialData?: StoreSnapshot<TLRecord>;
|
|
userId: TLUserId;
|
|
instanceId: TLInstanceId;
|
|
}): TLStore;
|
|
// (undocumented)
|
|
static readonly default: TldrawEditorConfig;
|
|
// (undocumented)
|
|
readonly shapes: readonly TLUnknownShapeDef[];
|
|
// (undocumented)
|
|
readonly storeSchema: StoreSchema<TLRecord, TLStoreProps>;
|
|
// (undocumented)
|
|
readonly TLShape: RecordType<TLShape, 'index' | 'parentId' | 'props' | 'type'>;
|
|
// (undocumented)
|
|
readonly tools: readonly StateNodeConstructor[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface TldrawEditorProps {
|
|
assetUrls?: EditorAssetUrls;
|
|
autoFocus?: boolean;
|
|
// (undocumented)
|
|
children?: any;
|
|
components?: Partial<TLEditorComponents>;
|
|
config?: TldrawEditorConfig;
|
|
instanceId?: TLInstanceId;
|
|
isDarkMode?: boolean;
|
|
onCreateAssetFromFile?: (file: File) => Promise<TLAsset>;
|
|
onCreateBookmarkFromUrl?: (url: string) => Promise<{
|
|
image: string;
|
|
title: string;
|
|
description: string;
|
|
}>;
|
|
onMount?: (app: App) => void;
|
|
store?: SyncedStore | TLStore;
|
|
userId?: TLUserId;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const TLDrawShapeDef: TLShapeDef<TLDrawShape, TLDrawUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLDrawUtil extends TLShapeUtil<TLDrawShape> {
|
|
// (undocumented)
|
|
defaultProps(): TLDrawShape['props'];
|
|
// (undocumented)
|
|
getBounds(shape: TLDrawShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLDrawShape): Vec2d;
|
|
// (undocumented)
|
|
getOutline(shape: TLDrawShape): Vec2d[];
|
|
// (undocumented)
|
|
hideResizeHandles: (shape: TLDrawShape) => boolean;
|
|
// (undocumented)
|
|
hideRotateHandle: (shape: TLDrawShape) => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: (shape: TLDrawShape) => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: (shape: TLDrawShape) => boolean;
|
|
// (undocumented)
|
|
hitTestLineSegment(shape: TLDrawShape, A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(shape: TLDrawShape, point: VecLike): boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLDrawShape): JSX.Element;
|
|
// (undocumented)
|
|
isClosed: (shape: TLDrawShape) => boolean;
|
|
// (undocumented)
|
|
onResize: OnResizeHandler<TLDrawShape>;
|
|
// (undocumented)
|
|
render(shape: TLDrawShape): JSX.Element;
|
|
// (undocumented)
|
|
toSvg(shape: TLDrawShape, _font: string | undefined, colors: TLExportColors): SVGGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLEasingType = 'easeInCubic' | 'easeInExpo' | 'easeInOutCubic' | 'easeInOutExpo' | 'easeInOutQuad' | 'easeInOutQuart' | 'easeInOutQuint' | 'easeInOutSine' | 'easeInQuad' | 'easeInQuart' | 'easeInQuint' | 'easeInSine' | 'easeOutCubic' | 'easeOutExpo' | 'easeOutQuad' | 'easeOutQuart' | 'easeOutQuint' | 'easeOutSine' | 'linear';
|
|
|
|
// @public (undocumented)
|
|
export interface TLEditorComponents {
|
|
// (undocumented)
|
|
Background: null | TLBackgroundComponent;
|
|
// (undocumented)
|
|
Brush: null | TLBrushComponent;
|
|
// (undocumented)
|
|
CollaboratorBrush: null | TLBrushComponent;
|
|
// (undocumented)
|
|
CollaboratorCursor: null | TLCursorComponent;
|
|
// (undocumented)
|
|
CollaboratorHint: null | TLCollaboratorHintComponent;
|
|
// (undocumented)
|
|
CollaboratorScribble: null | TLScribbleComponent;
|
|
// (undocumented)
|
|
CollaboratorShapeIndicator: null | TLShapeIndicatorComponent;
|
|
// (undocumented)
|
|
Cursor: null | TLCursorComponent;
|
|
// (undocumented)
|
|
ErrorFallback: null | TLErrorFallback;
|
|
// (undocumented)
|
|
Grid: null | TLGridComponent;
|
|
// (undocumented)
|
|
Handle: null | TLHandleComponent;
|
|
// (undocumented)
|
|
Scribble: null | TLScribbleComponent;
|
|
// (undocumented)
|
|
ShapeErrorFallback: null | TLShapeErrorFallback;
|
|
// (undocumented)
|
|
ShapeIndicatorErrorFallback: null | TLShapeIndicatorErrorFallback;
|
|
// (undocumented)
|
|
SnapLine: null | TLSnapLineComponent;
|
|
// (undocumented)
|
|
Spinner: null | TLSpinnerComponent;
|
|
// (undocumented)
|
|
SvgDefs: null | TLSvgDefsComponent;
|
|
// (undocumented)
|
|
ZoomBrush: null | TLBrushComponent;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const TLEmbedShapeDef: TLShapeDef<TLEmbedShape, TLEmbedUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLEmbedUtil extends TLBoxUtil<TLEmbedShape> {
|
|
// (undocumented)
|
|
canEdit: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
canResize: (shape: TLEmbedShape) => boolean;
|
|
// (undocumented)
|
|
canUnmount: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
defaultProps(): TLEmbedShape['props'];
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
indicator(shape: TLEmbedShape): JSX.Element;
|
|
// (undocumented)
|
|
isAspectRatioLocked: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
onResize: OnResizeHandler<TLEmbedShape>;
|
|
// (undocumented)
|
|
render(shape: TLEmbedShape): JSX.Element;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @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)
|
|
onMiddleClick: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerDown: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerEnter: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerLeave: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerMove: TLPointerEvent;
|
|
// (undocumented)
|
|
onPointerUp: TLPointerEvent;
|
|
// (undocumented)
|
|
onQuadrupleClick: TLClickEvent;
|
|
// (undocumented)
|
|
onRightClick: TLPointerEvent;
|
|
// (undocumented)
|
|
onTripleClick: TLClickEvent;
|
|
// (undocumented)
|
|
onWheel: TLWheelEvent;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLEventInfo = TLCancelEventInfo | TLClickEventInfo | TLCompleteEventInfo | TLInterruptEventInfo | TLKeyboardEventInfo | TLPinchEventInfo | TLPointerEventInfo | TLWheelEventInfo;
|
|
|
|
// @public (undocumented)
|
|
export type TLEventName = 'cancel' | 'complete' | 'interrupt' | 'wheel' | TLCLickEventName | TLKeyboardEventName | TLPinchEventName | TLPointerEventName;
|
|
|
|
// @public (undocumented)
|
|
export type TLExportType = 'jpeg' | 'json' | 'png' | 'svg' | 'webp';
|
|
|
|
// @public (undocumented)
|
|
export const TLFrameShapeDef: TLShapeDef<TLFrameShape, TLFrameUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLFrameUtil extends TLBoxUtil<TLFrameShape> {
|
|
// (undocumented)
|
|
canBind: () => boolean;
|
|
// (undocumented)
|
|
canDropShapes: (_shape: TLFrameShape, _shapes: TLShape[]) => boolean;
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
canReceiveNewChildrenOfType: (_type: TLShapeType) => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLFrameShape['props'];
|
|
// (undocumented)
|
|
indicator(shape: TLFrameShape): JSX.Element;
|
|
// (undocumented)
|
|
onDragShapesOut: (_shape: TLFrameShape, shapes: TLShape[]) => void;
|
|
// (undocumented)
|
|
onDragShapesOver: (frame: TLFrameShape, shapes: TLShape[]) => {
|
|
shouldHint: boolean;
|
|
};
|
|
// (undocumented)
|
|
onResizeEnd: OnResizeEndHandler<TLFrameShape>;
|
|
// (undocumented)
|
|
render(shape: TLFrameShape): JSX.Element;
|
|
// (undocumented)
|
|
toSvg(shape: TLFrameShape, font: string, colors: TLExportColors): Promise<SVGElement> | SVGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const TLGeoShapeDef: TLShapeDef<TLGeoShape, TLGeoUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLGeoUtil extends TLBoxUtil<TLGeoShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLGeoShape['props'];
|
|
// (undocumented)
|
|
getBounds(shape: TLGeoShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLGeoShape): Vec2d;
|
|
// (undocumented)
|
|
getOutline(shape: TLGeoShape): Vec2d[];
|
|
// (undocumented)
|
|
hitTestLineSegment(shape: TLGeoShape, A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLGeoShape): JSX.Element;
|
|
// (undocumented)
|
|
onBeforeCreate: (shape: TLGeoShape) => {
|
|
props: {
|
|
growY: number;
|
|
geo: "arrow-down" | "arrow-left" | "arrow-right" | "arrow-up" | "diamond" | "ellipse" | "hexagon" | "octagon" | "oval" | "pentagon" | "rectangle" | "rhombus-2" | "rhombus" | "star" | "trapezoid" | "triangle" | "x-box";
|
|
labelColor: "black" | "blue" | "green" | "grey" | "light-blue" | "light-green" | "light-red" | "light-violet" | "orange" | "red" | "violet" | "yellow";
|
|
color: "black" | "blue" | "green" | "grey" | "light-blue" | "light-green" | "light-red" | "light-violet" | "orange" | "red" | "violet" | "yellow";
|
|
fill: "none" | "pattern" | "semi" | "solid";
|
|
dash: "dashed" | "dotted" | "draw" | "solid";
|
|
size: "l" | "m" | "s" | "xl";
|
|
opacity: "0.1" | "0.25" | "0.5" | "0.75" | "1";
|
|
font: "draw" | "mono" | "sans" | "serif";
|
|
align: "end" | "middle" | "start";
|
|
url: string;
|
|
w: number;
|
|
h: number;
|
|
text: string;
|
|
};
|
|
type: "geo";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
id: ID<TLGeoShape>;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onBeforeUpdate: (prev: TLGeoShape, next: TLGeoShape) => {
|
|
props: {
|
|
growY: number;
|
|
geo: "arrow-down" | "arrow-left" | "arrow-right" | "arrow-up" | "diamond" | "ellipse" | "hexagon" | "octagon" | "oval" | "pentagon" | "rectangle" | "rhombus-2" | "rhombus" | "star" | "trapezoid" | "triangle" | "x-box";
|
|
labelColor: "black" | "blue" | "green" | "grey" | "light-blue" | "light-green" | "light-red" | "light-violet" | "orange" | "red" | "violet" | "yellow";
|
|
color: "black" | "blue" | "green" | "grey" | "light-blue" | "light-green" | "light-red" | "light-violet" | "orange" | "red" | "violet" | "yellow";
|
|
fill: "none" | "pattern" | "semi" | "solid";
|
|
dash: "dashed" | "dotted" | "draw" | "solid";
|
|
size: "l" | "m" | "s" | "xl";
|
|
opacity: "0.1" | "0.25" | "0.5" | "0.75" | "1";
|
|
font: "draw" | "mono" | "sans" | "serif";
|
|
align: "end" | "middle" | "start";
|
|
url: string;
|
|
w: number;
|
|
h: number;
|
|
text: string;
|
|
};
|
|
type: "geo";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
id: ID<TLGeoShape>;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onEditEnd: OnEditEndHandler<TLGeoShape>;
|
|
// (undocumented)
|
|
onResize: OnResizeHandler<TLGeoShape>;
|
|
// (undocumented)
|
|
render(shape: TLGeoShape): JSX.Element;
|
|
// (undocumented)
|
|
toSvg(shape: TLGeoShape, font: string, colors: TLExportColors): SVGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const TLGroupShapeDef: TLShapeDef<TLGroupShape, TLGroupUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLGroupUtil extends TLShapeUtil<TLGroupShape> {
|
|
// (undocumented)
|
|
canBind: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLGroupShape['props'];
|
|
// (undocumented)
|
|
getBounds(shape: TLGroupShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLGroupShape): Vec2dModel;
|
|
// (undocumented)
|
|
getOutline(shape: TLGroupShape): Vec2dModel[];
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: () => boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLGroupShape): JSX.Element;
|
|
// (undocumented)
|
|
onChildrenChange: OnChildrenChangeHandler<TLGroupShape>;
|
|
// (undocumented)
|
|
render(shape: TLGroupShape): JSX.Element | null;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLHistoryEntry = TLCommand | TLMark;
|
|
|
|
// @public (undocumented)
|
|
export const TLImageShapeDef: TLShapeDef<TLImageShape, TLImageUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLImageUtil extends TLBoxUtil<TLImageShape> {
|
|
// (undocumented)
|
|
canCrop: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLImageShape['props'];
|
|
// (undocumented)
|
|
indicator(shape: TLImageShape): JSX.Element | null;
|
|
// (undocumented)
|
|
isAspectRatioLocked: () => boolean;
|
|
// (undocumented)
|
|
onDoubleClick: (shape: TLImageShape) => void;
|
|
// (undocumented)
|
|
onDoubleClickEdge: OnDoubleClickHandler<TLImageShape>;
|
|
// (undocumented)
|
|
render(shape: TLImageShape): JSX.Element;
|
|
// (undocumented)
|
|
toSvg(shape: TLImageShape): Promise<SVGGElement>;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLInterruptEvent = (info: TLInterruptEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLInterruptEventInfo = {
|
|
type: 'misc';
|
|
name: 'interrupt';
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLKeyboardEvent = (info: TLKeyboardEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLKeyboardEventInfo = TLBaseEventInfo & {
|
|
type: 'keyboard';
|
|
name: TLKeyboardEventName;
|
|
key: string;
|
|
code: string;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLKeyboardEventName = 'key_down' | 'key_repeat' | 'key_up';
|
|
|
|
// @public (undocumented)
|
|
export const TLLineShapeDef: TLShapeDef<TLLineShape, TLLineUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLLineUtil extends TLShapeUtil<TLLineShape> {
|
|
// (undocumented)
|
|
defaultProps(): TLLineShape['props'];
|
|
// (undocumented)
|
|
getBounds(shape: TLLineShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLLineShape): Vec2d;
|
|
// (undocumented)
|
|
getHandles(shape: TLLineShape): TLHandle[];
|
|
// (undocumented)
|
|
getOutline(shape: TLLineShape): Vec2d[];
|
|
// (undocumented)
|
|
hideResizeHandles: () => boolean;
|
|
// (undocumented)
|
|
hideRotateHandle: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: () => boolean;
|
|
// (undocumented)
|
|
hitTestLineSegment(shape: TLLineShape, A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(shape: TLLineShape, point: Vec2d): boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLLineShape): JSX.Element;
|
|
// (undocumented)
|
|
isClosed: () => boolean;
|
|
// (undocumented)
|
|
onHandleChange: OnHandleChangeHandler<TLLineShape>;
|
|
// (undocumented)
|
|
onResize: OnResizeHandler<TLLineShape>;
|
|
// (undocumented)
|
|
render(shape: TLLineShape): JSX.Element | undefined;
|
|
// (undocumented)
|
|
toSvg(shape: TLLineShape, _font: string, colors: TLExportColors): SVGGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLMark = {
|
|
type: 'STOP';
|
|
id: string;
|
|
onUndo: boolean;
|
|
onRedo: boolean;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export const TLNoteShapeDef: TLShapeDef<TLNoteShape, TLNoteUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLNoteUtil extends TLShapeUtil<TLNoteShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLNoteShape['props'];
|
|
// (undocumented)
|
|
getBounds(shape: TLNoteShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(_shape: TLNoteShape): Vec2d;
|
|
// (undocumented)
|
|
getHeight(shape: TLNoteShape): number;
|
|
// (undocumented)
|
|
getOutline(shape: TLNoteShape): Vec2d[];
|
|
// (undocumented)
|
|
hideResizeHandles: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: () => boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLNoteShape): JSX.Element;
|
|
// (undocumented)
|
|
onBeforeCreate: (next: TLNoteShape) => {
|
|
props: {
|
|
growY: number;
|
|
color: "black" | "blue" | "green" | "grey" | "light-blue" | "light-green" | "light-red" | "light-violet" | "orange" | "red" | "violet" | "yellow";
|
|
size: "l" | "m" | "s" | "xl";
|
|
font: "draw" | "mono" | "sans" | "serif";
|
|
align: "end" | "middle" | "start";
|
|
opacity: "0.1" | "0.25" | "0.5" | "0.75" | "1";
|
|
url: string;
|
|
text: string;
|
|
};
|
|
type: "note";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
id: ID<TLNoteShape>;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onBeforeUpdate: (prev: TLNoteShape, next: TLNoteShape) => {
|
|
props: {
|
|
growY: number;
|
|
color: "black" | "blue" | "green" | "grey" | "light-blue" | "light-green" | "light-red" | "light-violet" | "orange" | "red" | "violet" | "yellow";
|
|
size: "l" | "m" | "s" | "xl";
|
|
font: "draw" | "mono" | "sans" | "serif";
|
|
align: "end" | "middle" | "start";
|
|
opacity: "0.1" | "0.25" | "0.5" | "0.75" | "1";
|
|
url: string;
|
|
text: string;
|
|
};
|
|
type: "note";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
id: ID<TLNoteShape>;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onEditEnd: OnEditEndHandler<TLNoteShape>;
|
|
// (undocumented)
|
|
render(shape: TLNoteShape): JSX.Element;
|
|
// (undocumented)
|
|
toSvg(shape: TLNoteShape, font: string, colors: TLExportColors): SVGGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEvent = (info: TLPinchEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEventInfo = TLBaseEventInfo & {
|
|
type: 'pinch';
|
|
name: TLPinchEventName;
|
|
point: Vec2dModel;
|
|
delta: Vec2dModel;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEventName = 'pinch_end' | 'pinch_start' | 'pinch';
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEvent = (info: TLPointerEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEventInfo = TLBaseEventInfo & {
|
|
type: 'pointer';
|
|
name: TLPointerEventName;
|
|
point: VecLike;
|
|
pointerId: number;
|
|
button: number;
|
|
isPen: boolean;
|
|
} & TLPointerEventTarget;
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEventName = 'middle_click' | 'pointer_down' | 'pointer_enter' | 'pointer_leave' | 'pointer_move' | 'pointer_up' | 'right_click';
|
|
|
|
// @public (undocumented)
|
|
export type TLPointerEventTarget = {
|
|
target: 'canvas';
|
|
shape?: undefined;
|
|
} | {
|
|
target: 'handle';
|
|
shape: TLShape;
|
|
handle: TLHandle;
|
|
} | {
|
|
target: 'selection';
|
|
handle?: TLSelectionHandle;
|
|
shape?: undefined;
|
|
} | {
|
|
target: 'shape';
|
|
shape: TLShape;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLReorderOperation = 'backward' | 'forward' | 'toBack' | 'toFront';
|
|
|
|
// @public (undocumented)
|
|
export type TLResizeHandle = SelectionCorner | SelectionEdge;
|
|
|
|
// @public
|
|
export type TLResizeMode = 'resize_bounds' | 'scale_shape';
|
|
|
|
// @public (undocumented)
|
|
export type TLSelectionHandle = RotateCorner | SelectionCorner | SelectionEdge;
|
|
|
|
// @public (undocumented)
|
|
export interface TLShapeDef<ShapeType extends TLUnknownShape, ShapeUtil extends TLShapeUtil<ShapeType> = TLShapeUtil<ShapeType>> {
|
|
// (undocumented)
|
|
readonly createShapeUtils: (app: App) => ShapeUtil;
|
|
// (undocumented)
|
|
readonly is: (shape: TLUnknownShape) => shape is ShapeType;
|
|
// (undocumented)
|
|
readonly migrations: Migrations;
|
|
// (undocumented)
|
|
readonly type: ShapeType['type'];
|
|
// (undocumented)
|
|
readonly validator?: StoreValidator<ShapeType>;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export abstract class TLShapeUtil<T extends TLUnknownShape> {
|
|
constructor(app: App, type: T['type']);
|
|
// (undocumented)
|
|
app: App;
|
|
bounds(shape: T): Box2d;
|
|
canBind: <K>(_shape: T, _otherShape?: K | undefined) => boolean;
|
|
canCrop: TLShapeUtilFlag<T>;
|
|
canDropShapes(shape: T, shapes: TLShape[]): boolean;
|
|
canEdit: TLShapeUtilFlag<T>;
|
|
canReceiveNewChildrenOfType(type: TLShapeType): boolean;
|
|
canResize: TLShapeUtilFlag<T>;
|
|
canScroll: TLShapeUtilFlag<T>;
|
|
canUnmount: TLShapeUtilFlag<T>;
|
|
center(shape: T): Vec2dModel;
|
|
abstract defaultProps(): T['props'];
|
|
protected abstract getBounds(shape: T): Box2d;
|
|
abstract getCenter(shape: T): Vec2dModel;
|
|
getEditingBounds: (shape: T) => Box2d;
|
|
protected getHandles?(shape: T): TLHandle[];
|
|
protected abstract getOutline(shape: T): Vec2dModel[];
|
|
handles(shape: T): TLHandle[];
|
|
hideResizeHandles: TLShapeUtilFlag<T>;
|
|
hideRotateHandle: TLShapeUtilFlag<T>;
|
|
hideSelectionBoundsBg: TLShapeUtilFlag<T>;
|
|
hideSelectionBoundsFg: TLShapeUtilFlag<T>;
|
|
hitTestLineSegment(shape: T, A: VecLike, B: VecLike): boolean;
|
|
hitTestPoint(shape: T, point: VecLike): boolean;
|
|
abstract indicator(shape: T): any;
|
|
// (undocumented)
|
|
is(shape: TLBaseShape<string, object>): shape is T;
|
|
isAspectRatioLocked: TLShapeUtilFlag<T>;
|
|
isClosed: TLShapeUtilFlag<T>;
|
|
onBeforeCreate?: OnBeforeCreateHandler<T>;
|
|
onBeforeUpdate?: OnBeforeUpdateHandler<T>;
|
|
// (undocumented)
|
|
onBindingChange?: OnBindingChangeHandler<T>;
|
|
// (undocumented)
|
|
onChildrenChange?: OnChildrenChangeHandler<T>;
|
|
// (undocumented)
|
|
onClick?: OnClickHandler<T>;
|
|
// (undocumented)
|
|
onDoubleClick?: OnDoubleClickHandler<T>;
|
|
// (undocumented)
|
|
onDoubleClickEdge?: OnDoubleClickHandler<T>;
|
|
// (undocumented)
|
|
onDoubleClickHandle?: OnDoubleClickHandleHandler<T>;
|
|
// (undocumented)
|
|
onDragShapesOut?: OnDragHandler<T>;
|
|
// (undocumented)
|
|
onDragShapesOver?: OnDragHandler<T, {
|
|
shouldHint: boolean;
|
|
}>;
|
|
// (undocumented)
|
|
onDropShapesOver?: OnDragHandler<T>;
|
|
// (undocumented)
|
|
onEditEnd?: OnEditEndHandler<T>;
|
|
// (undocumented)
|
|
onHandleChange?: OnHandleChangeHandler<T>;
|
|
// (undocumented)
|
|
onResize?: OnResizeHandler<T>;
|
|
// (undocumented)
|
|
onResizeEnd?: OnResizeEndHandler<T>;
|
|
// (undocumented)
|
|
onResizeStart?: OnResizeStartHandler<T>;
|
|
// (undocumented)
|
|
onRotate?: OnRotateHandler<T>;
|
|
// (undocumented)
|
|
onRotateEnd?: OnRotateEndHandler<T>;
|
|
// (undocumented)
|
|
onRotateStart?: OnRotateStartHandler<T>;
|
|
// (undocumented)
|
|
onTranslate?: OnTranslateHandler<T>;
|
|
// (undocumented)
|
|
onTranslateEnd?: OnTranslateEndHandler<T>;
|
|
// (undocumented)
|
|
onTranslateStart?: OnTranslateStartHandler<T>;
|
|
outline(shape: T): Vec2dModel[];
|
|
point(shape: T): Vec2dModel;
|
|
abstract render(shape: T): any;
|
|
snapPoints(shape: T): Vec2d[];
|
|
toSvg?(shape: T, font: string | undefined, colors: TLExportColors): Promise<SVGElement> | SVGElement;
|
|
transform(shape: T): Matrix2d;
|
|
// (undocumented)
|
|
readonly type: T['type'];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface TLShapeUtilConstructor<T extends TLUnknownShape, ShapeUtil extends TLShapeUtil<T> = TLShapeUtil<T>> {
|
|
// (undocumented)
|
|
new (app: App, type: T['type']): ShapeUtil;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLShapeUtilFlag<T> = (shape: T) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export const TLTextShapeDef: TLShapeDef<TLTextShape, TLTextUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLTextUtil extends TLShapeUtil<TLTextShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLTextShape['props'];
|
|
// (undocumented)
|
|
getBounds(shape: TLTextShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLTextShape): Vec2d;
|
|
// (undocumented)
|
|
getMinDimensions(shape: TLTextShape): {
|
|
height: number;
|
|
width: number;
|
|
};
|
|
// (undocumented)
|
|
getOutline(shape: TLTextShape): Vec2d[];
|
|
// (undocumented)
|
|
indicator(shape: TLTextShape): JSX.Element;
|
|
// (undocumented)
|
|
isAspectRatioLocked: TLShapeUtilFlag<TLTextShape>;
|
|
// (undocumented)
|
|
onBeforeCreate: (shape: TLTextShape) => {
|
|
x: number;
|
|
y: number;
|
|
type: "text";
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
props: TLTextShapeProps;
|
|
id: ID<TLTextShape>;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onBeforeUpdate: (prev: TLTextShape, next: TLTextShape) => {
|
|
x: number;
|
|
y: number;
|
|
props: {
|
|
w: number;
|
|
color: "black" | "blue" | "green" | "grey" | "light-blue" | "light-green" | "light-red" | "light-violet" | "orange" | "red" | "violet" | "yellow";
|
|
size: "l" | "m" | "s" | "xl";
|
|
font: "draw" | "mono" | "sans" | "serif";
|
|
align: "end" | "middle" | "start";
|
|
opacity: "0.1" | "0.25" | "0.5" | "0.75" | "1";
|
|
text: string;
|
|
scale: number;
|
|
autoSize: boolean;
|
|
};
|
|
type: "text";
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
id: ID<TLTextShape>;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onDoubleClickEdge: (shape: TLTextShape) => {
|
|
id: ID<TLTextShape>;
|
|
type: "text";
|
|
props: {
|
|
autoSize: boolean;
|
|
scale?: undefined;
|
|
};
|
|
} | {
|
|
id: ID<TLTextShape>;
|
|
type: "text";
|
|
props: {
|
|
scale: number;
|
|
autoSize?: undefined;
|
|
};
|
|
} | undefined;
|
|
// (undocumented)
|
|
onEditEnd: OnEditEndHandler<TLTextShape>;
|
|
// (undocumented)
|
|
onResize: OnResizeHandler<TLTextShape>;
|
|
// (undocumented)
|
|
render(shape: TLTextShape): JSX.Element;
|
|
// (undocumented)
|
|
toSvg(shape: TLTextShape, font: string | undefined, colors: TLExportColors): SVGGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLTickEvent = (elapsed: number) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLUnknownShapeDef = TLShapeDef<TLUnknownShape, TLShapeUtil<TLUnknownShape>>;
|
|
|
|
// @public (undocumented)
|
|
export const TLVideoShapeDef: TLShapeDef<TLVideoShape, TLVideoUtil>;
|
|
|
|
// @public (undocumented)
|
|
export class TLVideoUtil extends TLBoxUtil<TLVideoShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
defaultProps(): TLVideoShape['props'];
|
|
// (undocumented)
|
|
indicator(shape: TLVideoShape): JSX.Element;
|
|
// (undocumented)
|
|
isAspectRatioLocked: () => boolean;
|
|
// (undocumented)
|
|
render(shape: TLVideoShape): JSX.Element;
|
|
// (undocumented)
|
|
toSvg(shape: TLVideoShape): SVGGElement;
|
|
// (undocumented)
|
|
static type: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLWheelEvent = (info: TLWheelEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLWheelEventInfo = TLBaseEventInfo & {
|
|
type: 'wheel';
|
|
name: 'wheel';
|
|
delta: Vec2dModel;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export const truncateStringWithEllipsis: (str: string, maxLength: number) => string;
|
|
|
|
// @public (undocumented)
|
|
export type UiEnterHandler = (info: any, from: string) => void;
|
|
|
|
// @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 type UiExitHandler = (info: any, to: string) => void;
|
|
|
|
// @public
|
|
export function uniqueId(): string;
|
|
|
|
// @public (undocumented)
|
|
export const useApp: () => App;
|
|
|
|
// @public (undocumented)
|
|
export function useContainer(): HTMLDivElement;
|
|
|
|
// @internal (undocumented)
|
|
export function usePeerIds(): TLUserId[];
|
|
|
|
// @public (undocumented)
|
|
export function usePrefersReducedMotion(): boolean;
|
|
|
|
// @internal (undocumented)
|
|
export function usePresence(userId: TLUserId): null | TLInstancePresence;
|
|
|
|
// @public (undocumented)
|
|
export function useQuickReactor(name: string, reactFn: () => void, deps?: any[]): void;
|
|
|
|
// @public (undocumented)
|
|
export function useReactor(name: string, reactFn: () => void, deps?: any[] | undefined): void;
|
|
|
|
// @public (undocumented)
|
|
export function useUrlState(changeUrl: (params: Params) => void): void;
|
|
|
|
// @internal (undocumented)
|
|
export const WAY_TOO_BIG_ARROW_BEND_FACTOR = 10;
|
|
|
|
// @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;
|
|
}
|
|
|
|
// @internal (undocumented)
|
|
export const ZOOMS: number[];
|
|
|
|
|
|
export * from "@tldraw/tlschema";
|
|
|
|
// (No @packageDocumentation comment for this package)
|
|
|
|
```
|