6faef733b6
This PR adds the `ScribbleManager` to the exports from `@tldraw/editor`. ### Change Type - [x] `minor` — New feature ### Release Notes - [@tldraw/tldraw] Export `ScribbleManager`
2904 lines
97 KiB
Markdown
2904 lines
97 KiB
Markdown
## API Report File for "@tldraw/editor"
|
|
|
|
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
|
|
|
|
```ts
|
|
|
|
/// <reference types="react" />
|
|
|
|
import { Atom } from '@tldraw/state';
|
|
import { atom } from '@tldraw/state';
|
|
import { Box2d } from '@tldraw/primitives';
|
|
import { Box2dModel } from '@tldraw/tlschema';
|
|
import { Computed } from '@tldraw/state';
|
|
import { computed } from '@tldraw/state';
|
|
import { ComputedCache } from '@tldraw/store';
|
|
import { CubicSpline2d } from '@tldraw/primitives';
|
|
import { defineMigrations } from '@tldraw/store';
|
|
import { EASINGS } from '@tldraw/primitives';
|
|
import { EmbedDefinition } from '@tldraw/tlschema';
|
|
import { EventEmitter } from 'eventemitter3';
|
|
import { getHashForString } from '@tldraw/utils';
|
|
import { HistoryEntry } from '@tldraw/store';
|
|
import { JsonObject } from '@tldraw/utils';
|
|
import { MatLike } from '@tldraw/primitives';
|
|
import { Matrix2d } from '@tldraw/primitives';
|
|
import { Matrix2dModel } from '@tldraw/primitives';
|
|
import { Migrations } from '@tldraw/store';
|
|
import { Polyline2d } from '@tldraw/primitives';
|
|
import { react } from '@tldraw/state';
|
|
import { default as React_2 } from 'react';
|
|
import * as React_3 from 'react';
|
|
import { RecursivePartial } from '@tldraw/utils';
|
|
import { RotateCorner } from '@tldraw/primitives';
|
|
import { SelectionCorner } from '@tldraw/primitives';
|
|
import { SelectionEdge } from '@tldraw/primitives';
|
|
import { SelectionHandle } from '@tldraw/primitives';
|
|
import { SerializedSchema } from '@tldraw/store';
|
|
import { SerializedStore } from '@tldraw/store';
|
|
import { ShapeProps } from '@tldraw/tlschema';
|
|
import { Signal } from '@tldraw/state';
|
|
import { StoreSchema } from '@tldraw/store';
|
|
import { StrokePoint } from '@tldraw/primitives';
|
|
import { StyleProp } from '@tldraw/tlschema';
|
|
import { TLArrowShape } from '@tldraw/tlschema';
|
|
import { TLArrowShapeArrowheadStyle } from '@tldraw/tlschema';
|
|
import { TLAsset } from '@tldraw/tlschema';
|
|
import { TLAssetId } from '@tldraw/tlschema';
|
|
import { TLAssetPartial } from '@tldraw/tlschema';
|
|
import { TLBaseShape } from '@tldraw/tlschema';
|
|
import { TLBookmarkAsset } from '@tldraw/tlschema';
|
|
import { TLBookmarkShape } from '@tldraw/tlschema';
|
|
import { TLCamera } from '@tldraw/tlschema';
|
|
import { TLCursor } from '@tldraw/tlschema';
|
|
import { TLDefaultHorizontalAlignStyle } from '@tldraw/tlschema';
|
|
import { TLDocument } from '@tldraw/tlschema';
|
|
import { TLDrawShape } from '@tldraw/tlschema';
|
|
import { TLEmbedShape } from '@tldraw/tlschema';
|
|
import { TLFrameShape } from '@tldraw/tlschema';
|
|
import { TLGeoShape } from '@tldraw/tlschema';
|
|
import { TLGroupShape } from '@tldraw/tlschema';
|
|
import { TLHandle } from '@tldraw/tlschema';
|
|
import { TLHighlightShape } from '@tldraw/tlschema';
|
|
import { TLImageAsset } from '@tldraw/tlschema';
|
|
import { TLImageShape } from '@tldraw/tlschema';
|
|
import { TLInstance } from '@tldraw/tlschema';
|
|
import { TLInstancePageState } from '@tldraw/tlschema';
|
|
import { TLInstancePresence } from '@tldraw/tlschema';
|
|
import { TLLineShape } from '@tldraw/tlschema';
|
|
import { TLNoteShape } 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 { TLStore } from '@tldraw/tlschema';
|
|
import { TLStoreProps } from '@tldraw/tlschema';
|
|
import { TLTextShape } from '@tldraw/tlschema';
|
|
import { TLUnknownShape } from '@tldraw/tlschema';
|
|
import { TLVideoAsset } from '@tldraw/tlschema';
|
|
import { TLVideoShape } from '@tldraw/tlschema';
|
|
import { track } from '@tldraw/state';
|
|
import { UnknownRecord } from '@tldraw/store';
|
|
import { useComputed } from '@tldraw/state';
|
|
import { useQuickReactor } from '@tldraw/state';
|
|
import { useReactor } from '@tldraw/state';
|
|
import { useValue } from '@tldraw/state';
|
|
import { Vec2d } from '@tldraw/primitives';
|
|
import { Vec2dModel } from '@tldraw/tlschema';
|
|
import { VecLike } from '@tldraw/primitives';
|
|
import { whyAmIRunning } from '@tldraw/state';
|
|
|
|
// @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 const ArrowShape: TLShapeInfo<TLArrowShape>;
|
|
|
|
// @public (undocumented)
|
|
export class ArrowShapeUtil extends ShapeUtil<TLArrowShape> {
|
|
// (undocumented)
|
|
canBind: () => boolean;
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
canSnap: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLArrowShape): JSX.Element | null;
|
|
// (undocumented)
|
|
getArrowInfo(shape: TLArrowShape): ArrowInfo | undefined;
|
|
// (undocumented)
|
|
getBounds(shape: TLArrowShape): Box2d;
|
|
// (undocumented)
|
|
getCanvasSvgDefs(): TLShapeUtilCanvasSvgDef[];
|
|
// (undocumented)
|
|
getCenter(shape: TLArrowShape): Vec2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLArrowShape['props'];
|
|
// (undocumented)
|
|
getHandles(shape: TLArrowShape): TLHandle[];
|
|
// (undocumented)
|
|
getLabelBounds(shape: TLArrowShape): Box2d | null;
|
|
// (undocumented)
|
|
getOutline(shape: TLArrowShape): Vec2d[];
|
|
// (undocumented)
|
|
getOutlineWithoutLabel(shape: TLArrowShape): Vec2d[];
|
|
// (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: TLOnEditEndHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
onHandleChange: TLOnHandleChangeHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
onResize: TLOnResizeHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
onTranslateStart: TLOnTranslateStartHandler<TLArrowShape>;
|
|
// (undocumented)
|
|
snapPoints(_shape: TLArrowShape): Vec2d[];
|
|
// (undocumented)
|
|
toSvg(shape: TLArrowShape, ctx: SvgExportContext): SVGGElement;
|
|
// (undocumented)
|
|
static type: "arrow";
|
|
}
|
|
|
|
export { atom }
|
|
|
|
// @public (undocumented)
|
|
export abstract class BaseBoxShapeTool extends StateNode {
|
|
// (undocumented)
|
|
static children: () => (typeof Idle_4 | typeof Pointing_2)[];
|
|
// (undocumented)
|
|
static id: string;
|
|
// (undocumented)
|
|
static initial: string;
|
|
// (undocumented)
|
|
abstract shapeType: TLShapeUtilConstructor<any>;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export abstract class BaseBoxShapeUtil<Shape extends TLBaseBoxShape> extends ShapeUtil<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: TLOnResizeHandler<any>;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function blobAsString(blob: Blob): Promise<string>;
|
|
|
|
// @public (undocumented)
|
|
export const BookmarkShape: TLShapeInfo<TLBookmarkShape>;
|
|
|
|
// @public (undocumented)
|
|
export class BookmarkShapeUtil extends BaseBoxShapeUtil<TLBookmarkShape> {
|
|
// (undocumented)
|
|
canResize: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLBookmarkShape): JSX.Element;
|
|
// (undocumented)
|
|
getDefaultProps(): TLBookmarkShape['props'];
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: () => boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLBookmarkShape): JSX.Element;
|
|
// (undocumented)
|
|
onBeforeCreate?: TLOnBeforeCreateHandler<TLBookmarkShape>;
|
|
// (undocumented)
|
|
onBeforeUpdate?: TLOnBeforeUpdateHandler<TLBookmarkShape>;
|
|
// (undocumented)
|
|
static type: "bookmark";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const Canvas: React_2.MemoExoticComponent<() => JSX.Element>;
|
|
|
|
// @public (undocumented)
|
|
export const checkFlag: (flag: (() => boolean) | boolean | undefined) => boolean | undefined;
|
|
|
|
export { computed }
|
|
|
|
// @public
|
|
export function containBoxSize(originalSize: BoxWidthHeight, containBoxSize: BoxWidthHeight): BoxWidthHeight;
|
|
|
|
// @public (undocumented)
|
|
export const coreShapes: readonly [TLShapeInfo<TLGroupShape>, TLShapeInfo<TLEmbedShape>, TLShapeInfo<TLBookmarkShape>, TLShapeInfo<TLImageShape>, TLShapeInfo<TLTextShape>];
|
|
|
|
// @public (undocumented)
|
|
export function correctSpacesToNbsp(input: string): string;
|
|
|
|
// @public
|
|
export function createSessionStateSnapshotSignal(store: TLStore): Signal<null | TLSessionStateSnapshot>;
|
|
|
|
// @public
|
|
export function createTLStore({ initialData, defaultName, ...rest }: TLStoreOptions): TLStore;
|
|
|
|
// @public (undocumented)
|
|
export function createTLUser(opts?: {
|
|
derivePresenceState?: ((store: TLStore) => Signal<null | TLInstancePresence>) | undefined;
|
|
userPreferences?: Signal<TLUserPreferences, unknown> | undefined;
|
|
setUserPreferences?: ((userPreferences: TLUserPreferences) => void) | undefined;
|
|
}): TLUser;
|
|
|
|
// @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 type DebugFlag<T> = DebugFlagDef<T> & Atom<T>;
|
|
|
|
// @internal (undocumented)
|
|
export const debugFlags: {
|
|
preventDefaultLogging: DebugFlag<boolean>;
|
|
pointerCaptureLogging: DebugFlag<boolean>;
|
|
pointerCaptureTracking: DebugFlag<boolean>;
|
|
pointerCaptureTrackingObject: DebugFlag<Map<Element, number>>;
|
|
elementRemovalLogging: DebugFlag<boolean>;
|
|
debugSvg: DebugFlag<boolean>;
|
|
throwToBlob: DebugFlag<boolean>;
|
|
logMessages: DebugFlag<never[]>;
|
|
resetConnectionEveryPing: DebugFlag<boolean>;
|
|
debugCursors: DebugFlag<boolean>;
|
|
forceSrgb: DebugFlag<boolean>;
|
|
};
|
|
|
|
// @internal (undocumented)
|
|
export const DEFAULT_ANIMATION_OPTIONS: {
|
|
duration: number;
|
|
easing: (t: number) => number;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export let defaultEditorAssetUrls: TLEditorAssetUrls;
|
|
|
|
// @public (undocumented)
|
|
export function defaultEmptyAs(str: string, dflt: string): string;
|
|
|
|
// @internal (undocumented)
|
|
export const DefaultErrorFallback: TLErrorFallbackComponent;
|
|
|
|
// @public (undocumented)
|
|
export const defaultShapes: readonly [TLShapeInfo<TLDrawShape>, TLShapeInfo<TLGeoShape>, TLShapeInfo<TLLineShape>, TLShapeInfo<TLNoteShape>, TLShapeInfo<TLFrameShape>, TLShapeInfo<TLArrowShape>, TLShapeInfo<TLHighlightShape>, TLShapeInfo<TLVideoShape>];
|
|
|
|
// @public (undocumented)
|
|
export const defaultTools: TLStateNodeConstructor[];
|
|
|
|
export { defineMigrations }
|
|
|
|
// @public (undocumented)
|
|
export function defineShape<T extends TLUnknownShape>(type: T['type'], opts: Omit<TLShapeInfo<T>, 'type'>): TLShapeInfo<T>;
|
|
|
|
// @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 const DrawShape: TLShapeInfo<TLDrawShape>;
|
|
|
|
// @public (undocumented)
|
|
export class DrawShapeUtil extends ShapeUtil<TLDrawShape> {
|
|
// (undocumented)
|
|
component(shape: TLDrawShape): JSX.Element;
|
|
// (undocumented)
|
|
expandSelectionOutlinePx(shape: TLDrawShape): number;
|
|
// (undocumented)
|
|
getBounds(shape: TLDrawShape): Box2d;
|
|
// (undocumented)
|
|
getCanvasSvgDefs(): TLShapeUtilCanvasSvgDef[];
|
|
// (undocumented)
|
|
getCenter(shape: TLDrawShape): Vec2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLDrawShape['props'];
|
|
// (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: TLOnResizeHandler<TLDrawShape>;
|
|
// (undocumented)
|
|
toSvg(shape: TLDrawShape, ctx: SvgExportContext): SVGGElement;
|
|
// (undocumented)
|
|
static type: "draw";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class Editor extends EventEmitter<TLEventMap> {
|
|
constructor({ store, user, shapes, tools, getContainer }: TLEditorOptions);
|
|
addOpenMenu(id: string): this;
|
|
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?: TLAnimationOptions): this;
|
|
animateShapes(partials: (null | TLShapePartial | undefined)[], options?: {
|
|
duration?: number;
|
|
ease?: (t: number) => number;
|
|
}): this;
|
|
animateToShape(shapeId: TLShapeId, opts?: TLAnimationOptions): this;
|
|
animateToUser(userId: string): void;
|
|
get animationSpeed(): number;
|
|
// @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;
|
|
get brush(): Box2dModel | null;
|
|
get camera(): TLCamera;
|
|
get cameraState(): "idle" | "moving";
|
|
cancel(): this;
|
|
cancelDoubleClick(): void;
|
|
get canMoveCamera(): boolean;
|
|
set canMoveCamera(canMove: boolean);
|
|
get canRedo(): boolean;
|
|
get canUndo(): boolean;
|
|
// @internal (undocumented)
|
|
capturedPointerId: null | number;
|
|
centerOnPoint(x: number, y: number, opts?: TLAnimationOptions): this;
|
|
// @internal
|
|
protected _clickManager: ClickManager;
|
|
complete(): this;
|
|
// @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;
|
|
createShapes<T extends TLUnknownShape>(partials: TLShapePartial<T>[], select?: boolean): this;
|
|
get croppingId(): null | TLShapeId;
|
|
get currentPage(): TLPage;
|
|
get currentPageId(): TLPageId;
|
|
get currentPageShapeIds(): Set<TLShapeId>;
|
|
get currentToolId(): string;
|
|
get cursor(): TLCursor;
|
|
deleteAssets(ids: TLAssetId[]): this;
|
|
deleteOpenMenu(id: string): this;
|
|
deletePage(id: TLPageId): void;
|
|
deleteShapes(ids?: TLShapeId[]): this;
|
|
deselect(...ids: TLShapeId[]): this;
|
|
get devicePixelRatio(): number;
|
|
dispatch(info: TLEventInfo): this;
|
|
readonly disposables: Set<() => void>;
|
|
dispose(): void;
|
|
distributeShapes(operation: 'horizontal' | 'vertical', ids?: TLShapeId[]): this;
|
|
get documentSettings(): TLDocument;
|
|
duplicatePage(id?: TLPageId, createId?: TLPageId): this;
|
|
duplicateShapes(ids?: TLShapeId[], offset?: VecLike): this;
|
|
get editingId(): null | TLShapeId;
|
|
// (undocumented)
|
|
get editingShape(): null | TLUnknownShape;
|
|
get erasingIds(): TLShapeId[];
|
|
get erasingIdsSet(): Set<TLShapeId>;
|
|
// (undocumented)
|
|
externalContentManager: PlopManager;
|
|
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;
|
|
get focusLayerId(): TLPageId | TLShapeId;
|
|
get focusLayerShape(): TLShape | undefined;
|
|
getAncestorPageId(shape?: TLShape): TLPageId | 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<T extends TLShape>(shape: T): Box2d;
|
|
getBoundsById<T extends TLShape>(id: T['id']): Box2d | undefined;
|
|
getClipPathById(id: TLShapeId): string | undefined;
|
|
getContainer: () => HTMLElement;
|
|
getContent(ids?: TLShapeId[]): TLContent | undefined;
|
|
getDeltaInParentSpace(shape: TLShape, delta: VecLike): Vec2d;
|
|
getDeltaInShapeSpace(shape: TLShape, delta: VecLike): Vec2d;
|
|
getDroppingShape(point: VecLike, droppingShapes?: TLShape[]): TLUnknownShape | undefined;
|
|
getHandles<T extends TLShape>(shape: T): TLHandle[] | undefined;
|
|
getHandlesById<T extends TLShape>(id: T['id']): TLHandle[] | undefined;
|
|
getHighestIndexForParent(parentId: TLPageId | TLShapeId): string;
|
|
getInitialMetaForShape(_shape: TLShape): JsonObject;
|
|
getMaskedPageBounds(shape: TLShape): Box2d | undefined;
|
|
getMaskedPageBoundsById(id: TLShapeId): Box2d | undefined;
|
|
getOutermostSelectableShape(shape: TLShape, filter?: (shape: TLShape) => boolean): TLShape;
|
|
getOutline<T extends TLShape>(shape: T): Vec2d[];
|
|
getOutlineById(id: TLShapeId): Vec2d[];
|
|
getOutlineSegments<T extends TLShape>(shape: T): Vec2d[][];
|
|
getOutlineSegmentsById(id: TLShapeId): Vec2d[][];
|
|
getPageBounds(shape: TLShape): Box2d | undefined;
|
|
getPageBoundsById(id: TLShapeId): Box2d | undefined;
|
|
getPageById(id: TLPageId): 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;
|
|
getParentIdForNewShapeAtPoint(point: VecLike, shapeType: TLShape['type']): TLPageId | TLShapeId;
|
|
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;
|
|
getShapeAndDescendantIds(ids: TLShapeId[]): Set<TLShapeId>;
|
|
getShapeById<T extends TLShape = TLShape>(id: TLParentId): T | undefined;
|
|
getShapeIdsInPage(pageId: TLPageId): Set<TLShapeId>;
|
|
getShapesAtPoint(point: VecLike): TLShape[];
|
|
// (undocumented)
|
|
getShapeStyleIfExists<T>(shape: TLShape, style: StyleProp<T>): T | undefined;
|
|
getShapeUtil<C extends {
|
|
new (...args: any[]): ShapeUtil<any>;
|
|
type: string;
|
|
}>(util: C): InstanceType<C>;
|
|
getShapeUtil<S extends TLUnknownShape>(shape: S | TLShapePartial<S>): ShapeUtil<S>;
|
|
getSortedChildIds(parentId: TLParentId): TLShapeId[];
|
|
getStateDescendant(path: string): StateNode | undefined;
|
|
// @internal (undocumented)
|
|
getStyleForNextShape<T>(style: StyleProp<T>): T;
|
|
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;
|
|
get gridSize(): number;
|
|
groupShapes(ids?: TLShapeId[], groupId?: TLShapeId): this;
|
|
hasAncestor(shape: TLShape | undefined, ancestorId: TLShapeId): boolean;
|
|
get hintingIds(): TLShapeId[];
|
|
readonly history: HistoryManager<this>;
|
|
get hoveredId(): null | TLShapeId;
|
|
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 instanceState(): TLInstance;
|
|
interrupt(): this;
|
|
get isChangingStyle(): boolean;
|
|
set isChangingStyle(v: boolean);
|
|
readonly isChromeForIos: boolean;
|
|
get isCoarsePointer(): boolean;
|
|
set isCoarsePointer(v: boolean);
|
|
get isDarkMode(): boolean;
|
|
get isFocused(): boolean;
|
|
get isFocusMode(): boolean;
|
|
get isGridMode(): boolean;
|
|
isIn(path: string): boolean;
|
|
isInAny(...paths: string[]): boolean;
|
|
readonly isIos: boolean;
|
|
get isMenuOpen(): boolean;
|
|
get isPenMode(): boolean;
|
|
isPointInShape(point: VecLike, shape: TLShape): boolean;
|
|
get isReadOnly(): boolean;
|
|
readonly isSafari: boolean;
|
|
isSelected(id: TLShapeId): boolean;
|
|
isShapeInPage(shape: TLShape, pageId?: TLPageId): boolean;
|
|
isShapeOfType<T extends TLUnknownShape>(shape: TLUnknownShape, util: {
|
|
new (...args: any): ShapeUtil<T>;
|
|
type: string;
|
|
}): shape is T;
|
|
isShapeOrAncestorLocked(shape?: TLShape): boolean;
|
|
get isSnapMode(): boolean;
|
|
get isToolLocked(): boolean;
|
|
isWithinSelection(id: TLShapeId): boolean;
|
|
get locale(): string;
|
|
mark(reason?: string, onUndo?: boolean, onRedo?: boolean): string;
|
|
moveShapesToPage(ids: TLShapeId[], pageId: TLPageId): this;
|
|
nudgeShapes(ids: TLShapeId[], direction: Vec2dModel, major?: boolean, ephemeral?: boolean): this;
|
|
get onlySelectedShape(): null | TLShape;
|
|
get openMenus(): 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?: TLAnimationOptions): this;
|
|
panZoomIntoView(ids: TLShapeId[], opts?: TLAnimationOptions): this;
|
|
popFocusLayer(): this;
|
|
// @internal (undocumented)
|
|
get projectName(): string;
|
|
putContent(content: TLContent, options?: {
|
|
point?: VecLike;
|
|
select?: boolean;
|
|
preservePosition?: boolean;
|
|
preserveIds?: boolean;
|
|
}): this;
|
|
putExternalContent(info: TLExternalContent): Promise<void>;
|
|
redo(): this;
|
|
renamePage(id: TLPageId, name: string, squashing?: boolean): this;
|
|
get renderingBounds(): Box2d;
|
|
// @internal (undocumented)
|
|
readonly _renderingBounds: Atom<Box2d, unknown>;
|
|
get renderingBoundsExpanded(): Box2d;
|
|
// @internal (undocumented)
|
|
readonly _renderingBoundsExpanded: Atom<Box2d, unknown>;
|
|
get renderingShapes(): {
|
|
id: TLShapeId;
|
|
index: number;
|
|
backgroundIndex: number;
|
|
opacity: number;
|
|
isCulled: boolean;
|
|
isInViewport: boolean;
|
|
maskedPageBounds: Box2d | undefined;
|
|
}[];
|
|
reorderShapes(operation: 'backward' | 'forward' | 'toBack' | 'toFront', ids: TLShapeId[]): this;
|
|
reparentShapesById(ids: TLShapeId[], parentId: TLParentId, insertIndex?: string): this;
|
|
replaceStoreContentsWithRecordsForOtherDocument(records: TLRecord[]): void;
|
|
resetZoom(point?: Vec2d, opts?: TLAnimationOptions): this;
|
|
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;
|
|
};
|
|
get scribble(): null | TLScribble;
|
|
select(...ids: TLShapeId[]): this;
|
|
selectAll(): this;
|
|
get selectedIds(): TLShapeId[];
|
|
get selectedIdsSet(): ReadonlySet<TLShapeId>;
|
|
get selectedPageBounds(): Box2d | null;
|
|
get selectedShapes(): TLShape[];
|
|
get selectionBounds(): Box2d | undefined;
|
|
get selectionPageCenter(): null | Vec2d;
|
|
get selectionRotation(): number;
|
|
selectNone(): this;
|
|
sendBackward(ids?: TLShapeId[]): this;
|
|
sendToBack(ids?: TLShapeId[]): this;
|
|
setAnimationSpeed(animationSpeed: number): this;
|
|
setBrush(brush?: Box2dModel | null): this;
|
|
setCamera(x: number, y: number, z?: number, { stopFollowing }?: TLViewportOptions): this;
|
|
setCroppingId(id: null | TLShapeId): this;
|
|
setCurrentPageId(pageId: TLPageId, { stopFollowing }?: TLViewportOptions): this;
|
|
setCursor(cursor: Partial<TLCursor>): this;
|
|
setDarkMode(isDarkMode: boolean): this;
|
|
setDevicePixelRatio(dpr: number): this;
|
|
setEditingId(id: null | TLShapeId): this;
|
|
setErasingIds(ids?: TLShapeId[]): this;
|
|
setFocusLayer(next: null | TLShapeId): this;
|
|
setFocusMode(isFocusMode: boolean): this;
|
|
setGridMode(isGridMode: boolean): this;
|
|
setHintingIds(ids: TLShapeId[]): this;
|
|
setHoveredId(id?: null | TLShapeId): this;
|
|
setLocale(locale: string): void;
|
|
setOpacity(opacity: number, ephemeral?: boolean, squashing?: boolean): this;
|
|
setPageState(partial: Partial<TLInstancePageState>, ephemeral?: boolean): void;
|
|
setPenMode(isPenMode: boolean): this;
|
|
// @internal (undocumented)
|
|
setProjectName(name: string): void;
|
|
setReadOnly(isReadOnly: boolean): this;
|
|
setScribble(scribble?: null | TLScribble): this;
|
|
setSelectedIds(ids: TLShapeId[], squashing?: boolean): this;
|
|
setSelectedTool(id: string, info?: {}): this;
|
|
setSnapMode(isSnapMode: boolean): this;
|
|
setStyle<T>(style: StyleProp<T>, value: T, ephemeral?: boolean, squashing?: boolean): this;
|
|
setToolLocked(isToolLocked: boolean): this;
|
|
setZoomBrush(zoomBrush?: Box2dModel | null): this;
|
|
get shapesArray(): TLShape[];
|
|
shapeUtils: {
|
|
readonly [K in string]?: ShapeUtil<TLUnknownShape>;
|
|
};
|
|
get sharedOpacity(): SharedStyle<number>;
|
|
get sharedStyles(): ReadonlySharedStyleMap;
|
|
slideCamera(opts?: {
|
|
speed: number;
|
|
direction: Vec2d;
|
|
friction: number;
|
|
speedThreshold?: number | undefined;
|
|
}): this | undefined;
|
|
readonly snaps: SnapManager;
|
|
get sortedShapesArray(): TLShape[];
|
|
stackShapes(operation: 'horizontal' | 'vertical', ids?: TLShapeId[], gap?: number): this;
|
|
startFollowingUser(userId: string): this | undefined;
|
|
stopCameraAnimation(): this;
|
|
stopFollowingUser(): this;
|
|
readonly store: TLStore;
|
|
stretchShapes(operation: 'horizontal' | 'vertical', ids?: TLShapeId[]): this;
|
|
readonly textMeasure: TextManager;
|
|
toggleLock(ids?: TLShapeId[]): this;
|
|
undo(): HistoryManager<this>;
|
|
ungroupShapes(ids?: TLShapeId[]): this;
|
|
updateAssets(assets: TLAssetPartial[]): this;
|
|
updateDocumentSettings(settings: Partial<TLDocument>): void;
|
|
updateInstanceState(partial: Partial<Omit<TLInstance, 'currentPageId'>>, ephemeral?: boolean, squashing?: boolean): this;
|
|
updatePage(partial: RequiredKeys<TLPage, 'id'>, squashing?: boolean): this;
|
|
// @internal
|
|
updateRenderingBounds(): this;
|
|
updateShapes<T extends TLUnknownShape>(partials: (null | TLShapePartial<T> | undefined)[], squashing?: boolean): this;
|
|
updateViewportScreenBounds(center?: boolean): this;
|
|
readonly user: UserPreferencesManager;
|
|
get viewportPageBounds(): Box2d;
|
|
get viewportPageCenter(): Vec2d;
|
|
get viewportScreenBounds(): Box2d;
|
|
get viewportScreenCenter(): Vec2d;
|
|
visitDescendants(parentId: TLParentId, visitor: (id: TLShapeId) => false | void): void;
|
|
get zoomBrush(): Box2dModel | null;
|
|
zoomIn(point?: Vec2d, opts?: TLAnimationOptions): this;
|
|
get zoomLevel(): number;
|
|
zoomOut(point?: Vec2d, opts?: TLAnimationOptions): this;
|
|
zoomToBounds(x: number, y: number, width: number, height: number, targetZoom?: number, opts?: TLAnimationOptions): this;
|
|
zoomToContent(): this;
|
|
zoomToFit(opts?: TLAnimationOptions): this;
|
|
zoomToSelection(opts?: TLAnimationOptions): this;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const EmbedShape: TLShapeInfo<TLEmbedShape>;
|
|
|
|
// @public (undocumented)
|
|
export class EmbedShapeUtil extends BaseBoxShapeUtil<TLEmbedShape> {
|
|
// (undocumented)
|
|
canEdit: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
canResize: (shape: TLEmbedShape) => boolean;
|
|
// (undocumented)
|
|
canUnmount: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
component(shape: TLEmbedShape): JSX.Element;
|
|
// (undocumented)
|
|
getDefaultProps(): TLEmbedShape['props'];
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
indicator(shape: TLEmbedShape): JSX.Element;
|
|
// (undocumented)
|
|
isAspectRatioLocked: TLShapeUtilFlag<TLEmbedShape>;
|
|
// (undocumented)
|
|
onResize: TLOnResizeHandler<TLEmbedShape>;
|
|
// (undocumented)
|
|
static type: "embed";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class ErrorBoundary extends React_3.Component<React_3.PropsWithRef<React_3.PropsWithChildren<TLErrorBoundaryProps>>, TLErrorBoundaryState> {
|
|
// (undocumented)
|
|
componentDidCatch(error: unknown): void;
|
|
// (undocumented)
|
|
static getDerivedStateFromError(error: Error): {
|
|
error: Error;
|
|
};
|
|
// (undocumented)
|
|
render(): boolean | JSX.Element | null | number | React_3.ReactFragment | string | undefined;
|
|
// (undocumented)
|
|
state: TLErrorBoundaryState;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function ErrorScreen({ children }: {
|
|
children: any;
|
|
}): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export const EVENT_NAME_MAP: Record<Exclude<TLEventName, TLPinchEventName>, keyof TLEventHandlers>;
|
|
|
|
// @internal (undocumented)
|
|
export function extractSessionStateFromLegacySnapshot(store: Record<string, UnknownRecord>): null | TLSessionStateSnapshot;
|
|
|
|
// @internal (undocumented)
|
|
export const featureFlags: {
|
|
peopleMenu: DebugFlag<boolean>;
|
|
highlighterTool: DebugFlag<boolean>;
|
|
};
|
|
|
|
// @public
|
|
export function fileToBase64(file: Blob): Promise<string>;
|
|
|
|
// @public (undocumented)
|
|
export const FrameShape: TLShapeInfo<TLFrameShape>;
|
|
|
|
// @public (undocumented)
|
|
export class FrameShapeUtil extends BaseBoxShapeUtil<TLFrameShape> {
|
|
// (undocumented)
|
|
canBind: () => boolean;
|
|
// (undocumented)
|
|
canDropShapes: (shape: TLFrameShape, _shapes: TLShape[]) => boolean;
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
canReceiveNewChildrenOfType: (shape: TLShape, _type: TLShape['type']) => boolean;
|
|
// (undocumented)
|
|
component(shape: TLFrameShape): JSX.Element;
|
|
// (undocumented)
|
|
getDefaultProps(): 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: TLOnResizeEndHandler<TLFrameShape>;
|
|
// (undocumented)
|
|
providesBackgroundForChildren(): boolean;
|
|
// (undocumented)
|
|
toSvg(shape: TLFrameShape): Promise<SVGElement> | SVGElement;
|
|
// (undocumented)
|
|
static type: "frame";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const GeoShape: TLShapeInfo<TLGeoShape>;
|
|
|
|
// @public (undocumented)
|
|
export class GeoShapeUtil extends BaseBoxShapeUtil<TLGeoShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLGeoShape): JSX.Element;
|
|
// (undocumented)
|
|
getBounds(shape: TLGeoShape): Box2d;
|
|
// (undocumented)
|
|
getCanvasSvgDefs(): TLShapeUtilCanvasSvgDef[];
|
|
// (undocumented)
|
|
getCenter(shape: TLGeoShape): Vec2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLGeoShape['props'];
|
|
// (undocumented)
|
|
getOutline(shape: TLGeoShape): Vec2d[];
|
|
// (undocumented)
|
|
hitTestLineSegment(shape: TLGeoShape, A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(shape: TLGeoShape, point: VecLike): boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLGeoShape): JSX.Element;
|
|
// (undocumented)
|
|
onBeforeCreate: (shape: TLGeoShape) => {
|
|
props: {
|
|
growY: number;
|
|
geo: "arrow-down" | "arrow-left" | "arrow-right" | "arrow-up" | "check-box" | "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";
|
|
font: "draw" | "mono" | "sans" | "serif";
|
|
align: "end-legacy" | "end" | "middle-legacy" | "middle" | "start-legacy" | "start";
|
|
verticalAlign: "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;
|
|
opacity: number;
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onBeforeUpdate: (prev: TLGeoShape, next: TLGeoShape) => {
|
|
props: {
|
|
growY: number;
|
|
geo: "arrow-down" | "arrow-left" | "arrow-right" | "arrow-up" | "check-box" | "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";
|
|
font: "draw" | "mono" | "sans" | "serif";
|
|
align: "end-legacy" | "end" | "middle-legacy" | "middle" | "start-legacy" | "start";
|
|
verticalAlign: "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;
|
|
opacity: number;
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onDoubleClick: (shape: TLGeoShape) => {
|
|
props: {
|
|
geo: "check-box";
|
|
};
|
|
type: "geo";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
opacity: number;
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
typeName: "shape";
|
|
} | {
|
|
props: {
|
|
geo: "rectangle";
|
|
};
|
|
type: "geo";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
opacity: number;
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onEditEnd: TLOnEditEndHandler<TLGeoShape>;
|
|
// (undocumented)
|
|
onResize: TLOnResizeHandler<TLGeoShape>;
|
|
// (undocumented)
|
|
toSvg(shape: TLGeoShape, ctx: SvgExportContext): SVGElement;
|
|
// (undocumented)
|
|
static type: "geo";
|
|
}
|
|
|
|
// @public
|
|
export function getEmbedInfo(inputUrl: string): TLEmbedResult;
|
|
|
|
// @public
|
|
export function getEmbedInfoUnsafely(inputUrl: string): TLEmbedResult;
|
|
|
|
// @public
|
|
export function getFileMetaData(file: File): Promise<{
|
|
isAnimated: boolean;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export function getFreshUserPreferences(): TLUserPreferences;
|
|
|
|
export { getHashForString }
|
|
|
|
// @public
|
|
export function getImageSizeFromSrc(dataURL: string): Promise<{
|
|
w: number;
|
|
h: number;
|
|
}>;
|
|
|
|
// @public
|
|
export function getIncrementedName(name: string, others: string[]): 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>;
|
|
|
|
// @public (undocumented)
|
|
export function getRotatedBoxShadow(rotation: number): string;
|
|
|
|
// @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 function getUserPreferences(): TLUserPreferences;
|
|
|
|
// @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;
|
|
}[];
|
|
|
|
// @public (undocumented)
|
|
export const GroupShape: TLShapeInfo<TLGroupShape>;
|
|
|
|
// @public (undocumented)
|
|
export class GroupShapeUtil extends ShapeUtil<TLGroupShape> {
|
|
// (undocumented)
|
|
canBind: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLGroupShape): JSX.Element | null;
|
|
// (undocumented)
|
|
getBounds(shape: TLGroupShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLGroupShape): Vec2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLGroupShape['props'];
|
|
// (undocumented)
|
|
getOutline(shape: TLGroupShape): Vec2d[];
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: () => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: () => boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLGroupShape): JSX.Element;
|
|
// (undocumented)
|
|
onChildrenChange: TLOnChildrenChangeHandler<TLGroupShape>;
|
|
// (undocumented)
|
|
static type: "group";
|
|
// (undocumented)
|
|
type: "group";
|
|
}
|
|
|
|
// @internal (undocumented)
|
|
export const HAND_TOOL_FRICTION = 0.09;
|
|
|
|
// @public
|
|
export function hardReset({ shouldReload }?: {
|
|
shouldReload?: boolean | undefined;
|
|
}): Promise<void>;
|
|
|
|
// @public (undocumented)
|
|
export function hardResetEditor(): void;
|
|
|
|
// @internal (undocumented)
|
|
export const HASH_PATTERN_ZOOM_NAMES: Record<string, string>;
|
|
|
|
// @public (undocumented)
|
|
export const HighlightShape: TLShapeInfo<TLHighlightShape>;
|
|
|
|
// @public (undocumented)
|
|
export class HighlightShapeUtil extends ShapeUtil<TLHighlightShape> {
|
|
// (undocumented)
|
|
backgroundComponent(shape: TLHighlightShape): JSX.Element;
|
|
// (undocumented)
|
|
component(shape: TLHighlightShape): JSX.Element;
|
|
// (undocumented)
|
|
expandSelectionOutlinePx(shape: TLHighlightShape): number;
|
|
// (undocumented)
|
|
getBounds(shape: TLHighlightShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(shape: TLHighlightShape): Vec2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLHighlightShape['props'];
|
|
// (undocumented)
|
|
getOutline(shape: TLHighlightShape): Vec2d[];
|
|
// (undocumented)
|
|
hideResizeHandles: (shape: TLHighlightShape) => boolean;
|
|
// (undocumented)
|
|
hideRotateHandle: (shape: TLHighlightShape) => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsBg: (shape: TLHighlightShape) => boolean;
|
|
// (undocumented)
|
|
hideSelectionBoundsFg: (shape: TLHighlightShape) => boolean;
|
|
// (undocumented)
|
|
hitTestLineSegment(shape: TLHighlightShape, A: VecLike, B: VecLike): boolean;
|
|
// (undocumented)
|
|
hitTestPoint(shape: TLHighlightShape, point: VecLike): boolean;
|
|
// (undocumented)
|
|
indicator(shape: TLHighlightShape): JSX.Element;
|
|
// (undocumented)
|
|
onResize: TLOnResizeHandler<TLHighlightShape>;
|
|
// (undocumented)
|
|
toBackgroundSvg(shape: TLHighlightShape): SVGPathElement;
|
|
// (undocumented)
|
|
toSvg(shape: TLHighlightShape): SVGPathElement;
|
|
// (undocumented)
|
|
static type: "highlight";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function HTMLContainer({ children, className, ...rest }: HTMLContainerProps): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export type HTMLContainerProps = React_3.HTMLAttributes<HTMLDivElement>;
|
|
|
|
// @public (undocumented)
|
|
export const ImageShape: TLShapeInfo<TLImageShape>;
|
|
|
|
// @public (undocumented)
|
|
export class ImageShapeUtil extends BaseBoxShapeUtil<TLImageShape> {
|
|
// (undocumented)
|
|
canCrop: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLImageShape): JSX.Element;
|
|
// (undocumented)
|
|
getDefaultProps(): TLImageShape['props'];
|
|
// (undocumented)
|
|
indicator(shape: TLImageShape): JSX.Element | null;
|
|
// (undocumented)
|
|
isAspectRatioLocked: () => boolean;
|
|
// (undocumented)
|
|
onDoubleClick: (shape: TLImageShape) => void;
|
|
// (undocumented)
|
|
onDoubleClickEdge: TLOnDoubleClickHandler<TLImageShape>;
|
|
// (undocumented)
|
|
toSvg(shape: TLImageShape): Promise<SVGGElement>;
|
|
// (undocumented)
|
|
static type: "image";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const INDENT = " ";
|
|
|
|
// @public
|
|
export function isAnimated(buffer: ArrayBuffer): boolean;
|
|
|
|
// @public
|
|
export function isGIF(buffer: ArrayBuffer): boolean;
|
|
|
|
// @public (undocumented)
|
|
export const isImage: (ext: string) => boolean;
|
|
|
|
// @public
|
|
export function isSerializable(value: any): boolean;
|
|
|
|
// @public (undocumented)
|
|
export const isSvgText: (text: string) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export const isValidHttpURL: (url: string) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export function isValidUrl(url: string): boolean;
|
|
|
|
// @public (undocumented)
|
|
export const LineShape: TLShapeInfo<TLLineShape>;
|
|
|
|
// @public (undocumented)
|
|
export class LineShapeUtil extends ShapeUtil<TLLineShape> {
|
|
// (undocumented)
|
|
component(shape: TLLineShape): JSX.Element | undefined;
|
|
// (undocumented)
|
|
getBounds(shape: TLLineShape): Box2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLLineShape['props'];
|
|
// (undocumented)
|
|
getHandles(shape: TLLineShape): TLHandle[];
|
|
// (undocumented)
|
|
getOutline(shape: TLLineShape): Vec2d[];
|
|
// (undocumented)
|
|
getOutlineSegments(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: TLOnHandleChangeHandler<TLLineShape>;
|
|
// (undocumented)
|
|
onResize: TLOnResizeHandler<TLLineShape>;
|
|
// (undocumented)
|
|
toSvg(shape: TLLineShape): SVGGElement;
|
|
// (undocumented)
|
|
static type: "line";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function LoadingScreen({ children }: {
|
|
children: any;
|
|
}): JSX.Element;
|
|
|
|
// @public
|
|
export function loadSessionStateSnapshotIntoStore(store: TLStore, snapshot: TLSessionStateSnapshot): void;
|
|
|
|
// @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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: 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 canUnmount: 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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: 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 canUnmount: false;
|
|
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 canUnmount: 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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: 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 canUnmount: 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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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 canUnmount: 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 canUnmount: false;
|
|
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 canUnmount: 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 canUnmount: false;
|
|
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 canUnmount: false;
|
|
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_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 const NoteShape: TLShapeInfo<TLNoteShape>;
|
|
|
|
// @public (undocumented)
|
|
export class NoteShapeUtil extends ShapeUtil<TLNoteShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLNoteShape): JSX.Element;
|
|
// (undocumented)
|
|
getBounds(shape: TLNoteShape): Box2d;
|
|
// (undocumented)
|
|
getCenter(_shape: TLNoteShape): Vec2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLNoteShape['props'];
|
|
// (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-legacy" | "end" | "middle-legacy" | "middle" | "start-legacy" | "start";
|
|
verticalAlign: "end" | "middle" | "start";
|
|
url: string;
|
|
text: string;
|
|
};
|
|
type: "note";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
opacity: number;
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
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-legacy" | "end" | "middle-legacy" | "middle" | "start-legacy" | "start";
|
|
verticalAlign: "end" | "middle" | "start";
|
|
url: string;
|
|
text: string;
|
|
};
|
|
type: "note";
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
opacity: number;
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onEditEnd: TLOnEditEndHandler<TLNoteShape>;
|
|
// (undocumented)
|
|
toSvg(shape: TLNoteShape, ctx: SvgExportContext): SVGGElement;
|
|
// (undocumented)
|
|
static type: "note";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function openWindow(url: string, target?: string): void;
|
|
|
|
// @internal (undocumented)
|
|
export function OptionalErrorBoundary({ children, fallback, ...props }: Omit<TLErrorBoundaryProps, 'fallback'> & {
|
|
fallback: TLErrorFallbackComponent;
|
|
}): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export class PlopManager {
|
|
constructor(editor: Editor);
|
|
createAssetFromFile(_editor: Editor, file: File): Promise<TLAsset>;
|
|
createAssetFromUrl(_editor: Editor, url: string): Promise<TLAsset>;
|
|
// (undocumented)
|
|
createShapesForAssets(editor: Editor, assets: TLAsset[], position: VecLike): Promise<void>;
|
|
// (undocumented)
|
|
editor: Editor;
|
|
// (undocumented)
|
|
handleContent: (info: TLExternalContent) => Promise<void>;
|
|
handleEmbed(editor: Editor, { point, url, embed }: Extract<TLExternalContent, {
|
|
type: 'embed';
|
|
}>): Promise<void>;
|
|
handleFiles(editor: Editor, { point, files }: Extract<TLExternalContent, {
|
|
type: 'files';
|
|
}>): Promise<void>;
|
|
handleSvgText(editor: Editor, { point, text }: Extract<TLExternalContent, {
|
|
type: 'svg-text';
|
|
}>): Promise<void>;
|
|
handleText(editor: Editor, { point, text }: Extract<TLExternalContent, {
|
|
type: 'text';
|
|
}>): Promise<void>;
|
|
handleUrl: (editor: Editor, { point, url }: Extract<TLExternalContent, {
|
|
type: 'url';
|
|
}>) => Promise<void>;
|
|
}
|
|
|
|
// @public
|
|
export function preventDefault(event: Event | React_2.BaseSyntheticEvent): void;
|
|
|
|
export { react }
|
|
|
|
// @public
|
|
export class ReadonlySharedStyleMap {
|
|
// (undocumented)
|
|
[Symbol.iterator](): IterableIterator<[StyleProp<unknown>, SharedStyle<unknown>]>;
|
|
constructor(entries?: Iterable<[StyleProp<unknown>, SharedStyle<unknown>]>);
|
|
// (undocumented)
|
|
entries(): IterableIterator<[StyleProp<unknown>, SharedStyle<unknown>]>;
|
|
// (undocumented)
|
|
equals(other: ReadonlySharedStyleMap): boolean;
|
|
// (undocumented)
|
|
get<T>(prop: StyleProp<T>): SharedStyle<T> | undefined;
|
|
// (undocumented)
|
|
getAsKnownValue<T>(prop: StyleProp<T>): T | undefined;
|
|
// (undocumented)
|
|
keys(): IterableIterator<StyleProp<unknown>>;
|
|
// @internal (undocumented)
|
|
protected map: Map<StyleProp<unknown>, SharedStyle<unknown>>;
|
|
// (undocumented)
|
|
get size(): number;
|
|
// (undocumented)
|
|
values(): IterableIterator<SharedStyle<unknown>>;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function refreshPage(): void;
|
|
|
|
// @public (undocumented)
|
|
export function releasePointerCapture(element: Element, event: PointerEvent | React_2.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>;
|
|
|
|
// @public (undocumented)
|
|
export function resizeBox(shape: TLBaseBoxShape, info: {
|
|
newPoint: Vec2dModel;
|
|
handle: TLResizeHandle;
|
|
mode: TLResizeMode;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
initialBounds: Box2d;
|
|
initialShape: TLBaseBoxShape;
|
|
}, opts?: Partial<{
|
|
minWidth: number;
|
|
maxWidth: number;
|
|
minHeight: number;
|
|
maxHeight: number;
|
|
}>): {
|
|
x: number;
|
|
y: number;
|
|
props: {
|
|
w: number;
|
|
h: number;
|
|
};
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type ResizeBoxOptions = Partial<{
|
|
minWidth: number;
|
|
maxWidth: number;
|
|
minHeight: number;
|
|
maxHeight: number;
|
|
}>;
|
|
|
|
// @internal (undocumented)
|
|
export const RICH_TYPES: Record<string, boolean>;
|
|
|
|
// @public (undocumented)
|
|
export const runtime: {
|
|
openWindow: (url: string, target: string) => void;
|
|
refreshPage: () => void;
|
|
hardReset: () => void;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export class ScribbleManager implements TLScribble {
|
|
constructor(opts: {
|
|
onUpdate: (scribble: TLScribble) => void;
|
|
onComplete: () => void;
|
|
size?: TLScribble['size'];
|
|
color?: TLScribble['color'];
|
|
opacity?: TLScribble['opacity'];
|
|
delay?: TLScribble['delay'];
|
|
});
|
|
addPoint: (x: number, y: number) => void;
|
|
// (undocumented)
|
|
color: "accent" | "black" | "laser" | "muted-1" | "selection-fill" | "selection-stroke" | "white";
|
|
// (undocumented)
|
|
delay: number;
|
|
// (undocumented)
|
|
delayRemaining: number;
|
|
getScribble(): TLScribble;
|
|
// (undocumented)
|
|
opacity: number;
|
|
// (undocumented)
|
|
pause: () => void;
|
|
// (undocumented)
|
|
points: Vec2dModel[];
|
|
// (undocumented)
|
|
resume: () => void;
|
|
// (undocumented)
|
|
size: number;
|
|
// (undocumented)
|
|
state: "active" | "paused" | "starting" | "stopping";
|
|
stop: () => void;
|
|
// (undocumented)
|
|
tick: TLTickEvent;
|
|
// (undocumented)
|
|
timeoutMs: number;
|
|
}
|
|
|
|
// @internal (undocumented)
|
|
export function setDefaultEditorAssetUrls(assetUrls: TLEditorAssetUrls): void;
|
|
|
|
// @public (undocumented)
|
|
export function setPointerCapture(element: Element, event: PointerEvent | React_2.PointerEvent<Element>): void;
|
|
|
|
// @public (undocumented)
|
|
export function setRuntimeOverrides(input: Partial<typeof runtime>): void;
|
|
|
|
// @public (undocumented)
|
|
export function setUserPreferences(user: TLUserPreferences): void;
|
|
|
|
// @public (undocumented)
|
|
export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
|
|
constructor(editor: Editor, type: Shape['type'], styleProps: ReadonlyMap<StyleProp<unknown>, string>);
|
|
// @internal
|
|
backgroundComponent?(shape: Shape): any;
|
|
canBind: <K>(_shape: Shape, _otherShape?: K | undefined) => boolean;
|
|
canCrop: TLShapeUtilFlag<Shape>;
|
|
canDropShapes(shape: Shape, shapes: TLShape[]): boolean;
|
|
canEdit: TLShapeUtilFlag<Shape>;
|
|
canReceiveNewChildrenOfType(shape: Shape, type: TLShape['type']): boolean;
|
|
canResize: TLShapeUtilFlag<Shape>;
|
|
canScroll: TLShapeUtilFlag<Shape>;
|
|
canSnap: TLShapeUtilFlag<Shape>;
|
|
canUnmount: TLShapeUtilFlag<Shape>;
|
|
center(shape: Shape): Vec2d;
|
|
abstract component(shape: Shape): any;
|
|
// (undocumented)
|
|
editor: Editor;
|
|
// @internal (undocumented)
|
|
expandSelectionOutlinePx(shape: Shape): number;
|
|
abstract getBounds(shape: Shape): Box2d;
|
|
getCanvasSvgDefs(): TLShapeUtilCanvasSvgDef[];
|
|
getCenter(shape: Shape): Vec2d;
|
|
abstract getDefaultProps(): Shape['props'];
|
|
getHandles?(shape: Shape): TLHandle[];
|
|
getOutline(shape: Shape): Vec2d[];
|
|
getOutlineSegments(shape: Shape): Vec2d[][];
|
|
hideResizeHandles: TLShapeUtilFlag<Shape>;
|
|
hideRotateHandle: TLShapeUtilFlag<Shape>;
|
|
hideSelectionBoundsBg: TLShapeUtilFlag<Shape>;
|
|
hideSelectionBoundsFg: TLShapeUtilFlag<Shape>;
|
|
hitTestLineSegment(shape: Shape, A: VecLike, B: VecLike): boolean;
|
|
hitTestPoint(shape: Shape, point: VecLike): boolean;
|
|
abstract indicator(shape: Shape): any;
|
|
isAspectRatioLocked: TLShapeUtilFlag<Shape>;
|
|
isClosed: TLShapeUtilFlag<Shape>;
|
|
onBeforeCreate?: TLOnBeforeCreateHandler<Shape>;
|
|
onBeforeUpdate?: TLOnBeforeUpdateHandler<Shape>;
|
|
// @internal
|
|
onBindingChange?: TLOnBindingChangeHandler<Shape>;
|
|
onChildrenChange?: TLOnChildrenChangeHandler<Shape>;
|
|
onClick?: TLOnClickHandler<Shape>;
|
|
onDoubleClick?: TLOnDoubleClickHandler<Shape>;
|
|
onDoubleClickEdge?: TLOnDoubleClickHandler<Shape>;
|
|
onDoubleClickHandle?: TLOnDoubleClickHandleHandler<Shape>;
|
|
onDragShapesOut?: TLOnDragHandler<Shape>;
|
|
onDragShapesOver?: TLOnDragHandler<Shape, {
|
|
shouldHint: boolean;
|
|
}>;
|
|
onDropShapesOver?: TLOnDragHandler<Shape>;
|
|
onEditEnd?: TLOnEditEndHandler<Shape>;
|
|
onHandleChange?: TLOnHandleChangeHandler<Shape>;
|
|
onResize?: TLOnResizeHandler<Shape>;
|
|
onResizeEnd?: TLOnResizeEndHandler<Shape>;
|
|
onResizeStart?: TLOnResizeStartHandler<Shape>;
|
|
onRotate?: TLOnRotateHandler<Shape>;
|
|
onRotateEnd?: TLOnRotateEndHandler<Shape>;
|
|
onRotateStart?: TLOnRotateStartHandler<Shape>;
|
|
onTranslate?: TLOnTranslateHandler<Shape>;
|
|
onTranslateEnd?: TLOnTranslateEndHandler<Shape>;
|
|
onTranslateStart?: TLOnTranslateStartHandler<Shape>;
|
|
// @internal
|
|
providesBackgroundForChildren(shape: Shape): boolean;
|
|
// (undocumented)
|
|
setStyleInPartial<T>(style: StyleProp<T>, shape: TLShapePartial<Shape>, value: T): TLShapePartial<Shape>;
|
|
snapPoints(shape: Shape): Vec2d[];
|
|
// (undocumented)
|
|
readonly styleProps: ReadonlyMap<StyleProp<unknown>, string>;
|
|
toBackgroundSvg?(shape: Shape, ctx: SvgExportContext): null | Promise<SVGElement> | SVGElement;
|
|
toSvg?(shape: Shape, ctx: SvgExportContext): Promise<SVGElement> | SVGElement;
|
|
// (undocumented)
|
|
readonly type: Shape['type'];
|
|
static type: string;
|
|
}
|
|
|
|
// @public
|
|
export type SharedStyle<T> = {
|
|
readonly type: 'mixed';
|
|
} | {
|
|
readonly type: 'shared';
|
|
readonly value: T;
|
|
};
|
|
|
|
// @internal (undocumented)
|
|
export class SharedStyleMap extends ReadonlySharedStyleMap {
|
|
// (undocumented)
|
|
applyValue<T>(prop: StyleProp<T>, value: T): void;
|
|
// (undocumented)
|
|
set<T>(prop: StyleProp<T>, value: SharedStyle<T>): void;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export function snapToGrid(n: number, gridSize: number): number;
|
|
|
|
// @public (undocumented)
|
|
export abstract class StateNode implements Partial<TLEventHandlers> {
|
|
constructor(editor: Editor, parent?: StateNode);
|
|
// (undocumented)
|
|
static children?: () => TLStateNodeConstructor[];
|
|
// (undocumented)
|
|
children?: Record<string, StateNode>;
|
|
// (undocumented)
|
|
current: Atom<StateNode | undefined>;
|
|
// (undocumented)
|
|
editor: Editor;
|
|
// (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?: TLEnterEventHandler;
|
|
// (undocumented)
|
|
onExit?: TLExitEventHandler;
|
|
// (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)
|
|
shapeType?: TLShapeUtilConstructor<TLBaseShape<any, any>>;
|
|
// (undocumented)
|
|
transition(id: string, info: any): this;
|
|
// (undocumented)
|
|
type: TLStateNodeType;
|
|
}
|
|
|
|
// @internal (undocumented)
|
|
export const SVG_PADDING = 32;
|
|
|
|
// @public (undocumented)
|
|
export function SVGContainer({ children, className, ...rest }: SVGContainerProps): JSX.Element;
|
|
|
|
// @public (undocumented)
|
|
export type SVGContainerProps = React_3.HTMLAttributes<SVGElement>;
|
|
|
|
// @public
|
|
export const TAB_ID: string;
|
|
|
|
// @public (undocumented)
|
|
export const TextShape: TLShapeInfo<TLTextShape>;
|
|
|
|
// @public (undocumented)
|
|
export class TextShapeUtil extends ShapeUtil<TLTextShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLTextShape): JSX.Element;
|
|
// (undocumented)
|
|
getBounds(shape: TLTextShape): Box2d;
|
|
// (undocumented)
|
|
getDefaultProps(): TLTextShape['props'];
|
|
// (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;
|
|
opacity: number;
|
|
props: {
|
|
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-legacy" | "end" | "middle-legacy" | "middle" | "start-legacy" | "start";
|
|
w: number;
|
|
text: string;
|
|
scale: number;
|
|
autoSize: boolean;
|
|
};
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
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-legacy" | "end" | "middle-legacy" | "middle" | "start-legacy" | "start";
|
|
text: string;
|
|
scale: number;
|
|
autoSize: boolean;
|
|
};
|
|
type: "text";
|
|
rotation: number;
|
|
index: string;
|
|
parentId: TLParentId;
|
|
isLocked: boolean;
|
|
opacity: number;
|
|
meta: JsonObject;
|
|
id: TLShapeId;
|
|
typeName: "shape";
|
|
} | undefined;
|
|
// (undocumented)
|
|
onDoubleClickEdge: (shape: TLTextShape) => {
|
|
id: TLShapeId;
|
|
type: "text";
|
|
props: {
|
|
autoSize: boolean;
|
|
scale?: undefined;
|
|
};
|
|
} | {
|
|
id: TLShapeId;
|
|
type: "text";
|
|
props: {
|
|
scale: number;
|
|
autoSize?: undefined;
|
|
};
|
|
} | undefined;
|
|
// (undocumented)
|
|
onEditEnd: TLOnEditEndHandler<TLTextShape>;
|
|
// (undocumented)
|
|
onResize: TLOnResizeHandler<TLTextShape>;
|
|
// (undocumented)
|
|
toSvg(shape: TLTextShape, ctx: SvgExportContext): SVGGElement;
|
|
// (undocumented)
|
|
static type: "text";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLAnimationOptions = Partial<{
|
|
duration: number;
|
|
easing: typeof EASINGS.easeInOutCubic;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export type TLBaseBoxShape = TLBaseShape<string, {
|
|
w: number;
|
|
h: number;
|
|
}>;
|
|
|
|
// @public (undocumented)
|
|
export interface TLBaseEventInfo {
|
|
// (undocumented)
|
|
altKey: boolean;
|
|
// (undocumented)
|
|
ctrlKey: boolean;
|
|
// (undocumented)
|
|
shiftKey: boolean;
|
|
// (undocumented)
|
|
type: UiEventType;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLCancelEvent = (info: TLCancelEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLCancelEventInfo = {
|
|
type: 'misc';
|
|
name: 'cancel';
|
|
};
|
|
|
|
// @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 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 interface TLContent {
|
|
// (undocumented)
|
|
assets: TLAsset[];
|
|
// (undocumented)
|
|
rootShapeIds: TLShapeId[];
|
|
// (undocumented)
|
|
schema: SerializedSchema;
|
|
// (undocumented)
|
|
shapes: TLShape[];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLCopyType = 'jpeg' | 'json' | 'png' | 'svg';
|
|
|
|
// @public (undocumented)
|
|
export const TldrawEditor: React_2.NamedExoticComponent<TldrawEditorProps>;
|
|
|
|
// @public (undocumented)
|
|
export type TldrawEditorProps = {
|
|
children?: any;
|
|
shapes?: readonly AnyTLShapeInfo[];
|
|
tools?: readonly TLStateNodeConstructor[];
|
|
assetUrls?: RecursivePartial<TLEditorAssetUrls>;
|
|
autoFocus?: boolean;
|
|
components?: Partial<TLEditorComponents>;
|
|
onMount?: (editor: Editor) => (() => void) | undefined | void;
|
|
} & ({
|
|
store: TLStore | TLStoreWithStatus;
|
|
} | {
|
|
store?: undefined;
|
|
initialData?: SerializedStore<TLRecord>;
|
|
persistenceKey?: string;
|
|
sessionId?: string;
|
|
defaultName?: string;
|
|
});
|
|
|
|
// @public (undocumented)
|
|
export type TLEditorAssetUrls = {
|
|
fonts: {
|
|
monospace: string;
|
|
serif: string;
|
|
sansSerif: string;
|
|
draw: string;
|
|
};
|
|
};
|
|
|
|
// @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: TLErrorFallbackComponent;
|
|
// (undocumented)
|
|
Grid: null | TLGridComponent;
|
|
// (undocumented)
|
|
Handle: null | TLHandleComponent;
|
|
// (undocumented)
|
|
Scribble: null | TLScribbleComponent;
|
|
// (undocumented)
|
|
ShapeErrorFallback: TLShapeErrorFallbackComponent;
|
|
// (undocumented)
|
|
ShapeIndicatorErrorFallback: TLShapeIndicatorErrorFallback;
|
|
// (undocumented)
|
|
SnapLine: null | TLSnapLineComponent;
|
|
// (undocumented)
|
|
Spinner: null | TLSpinnerComponent;
|
|
// (undocumented)
|
|
SvgDefs: null | TLSvgDefsComponent;
|
|
// (undocumented)
|
|
ZoomBrush: null | TLBrushComponent;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface TLEditorOptions {
|
|
getContainer: () => HTMLElement;
|
|
shapes: readonly AnyTLShapeInfo[];
|
|
store: TLStore;
|
|
tools: readonly TLStateNodeConstructor[];
|
|
user?: TLUser;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLEmbedResult = {
|
|
definition: EmbedDefinition;
|
|
url: string;
|
|
embedUrl: string;
|
|
} | undefined;
|
|
|
|
// @public (undocumented)
|
|
export type TLEnterEventHandler = (info: any, from: string) => void;
|
|
|
|
// @public (undocumented)
|
|
export interface TLErrorBoundaryProps {
|
|
// (undocumented)
|
|
children: React_3.ReactNode;
|
|
// (undocumented)
|
|
fallback: (props: {
|
|
error: unknown;
|
|
}) => any;
|
|
// (undocumented)
|
|
onError?: ((error: unknown) => void) | null;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface TLEventHandlers {
|
|
// (undocumented)
|
|
onCancel: TLCancelEvent;
|
|
// (undocumented)
|
|
onComplete: TLCompleteEvent;
|
|
// (undocumented)
|
|
onDoubleClick: TLClickEvent;
|
|
// (undocumented)
|
|
onInterrupt: TLInterruptEvent;
|
|
// (undocumented)
|
|
onKeyDown: TLKeyboardEvent;
|
|
// (undocumented)
|
|
onKeyRepeat: TLKeyboardEvent;
|
|
// (undocumented)
|
|
onKeyUp: TLKeyboardEvent;
|
|
// (undocumented)
|
|
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 interface TLEventMap {
|
|
// (undocumented)
|
|
'change-history': [{
|
|
reason: 'bail';
|
|
markId?: string;
|
|
} | {
|
|
reason: 'push' | 'redo' | 'undo';
|
|
}];
|
|
// (undocumented)
|
|
'mark-history': [{
|
|
id: string;
|
|
}];
|
|
// (undocumented)
|
|
'max-shapes': [{
|
|
name: string;
|
|
pageId: TLPageId;
|
|
count: number;
|
|
}];
|
|
// (undocumented)
|
|
'stop-camera-animation': [];
|
|
// (undocumented)
|
|
'stop-following': [];
|
|
// (undocumented)
|
|
change: [HistoryEntry<TLRecord>];
|
|
// (undocumented)
|
|
crash: [{
|
|
error: unknown;
|
|
}];
|
|
// (undocumented)
|
|
event: [TLEventInfo];
|
|
// (undocumented)
|
|
frame: [number];
|
|
// (undocumented)
|
|
mount: [];
|
|
// (undocumented)
|
|
tick: [number];
|
|
// (undocumented)
|
|
update: [];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLEventMapHandler<T extends keyof TLEventMap> = (...args: TLEventMap[T]) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLEventName = 'cancel' | 'complete' | 'interrupt' | 'wheel' | TLCLickEventName | TLKeyboardEventName | TLPinchEventName | TLPointerEventName;
|
|
|
|
// @public (undocumented)
|
|
export type TLExitEventHandler = (info: any, to: string) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLExportType = 'jpeg' | 'json' | 'png' | 'svg' | 'webp';
|
|
|
|
// @public (undocumented)
|
|
export type TLExternalContent = {
|
|
type: 'embed';
|
|
url: string;
|
|
point?: VecLike;
|
|
embed: EmbedDefinition;
|
|
} | {
|
|
type: 'files';
|
|
files: File[];
|
|
point?: VecLike;
|
|
ignoreParent: boolean;
|
|
} | {
|
|
type: 'svg-text';
|
|
text: string;
|
|
point?: VecLike;
|
|
} | {
|
|
type: 'text';
|
|
point?: VecLike;
|
|
text: string;
|
|
} | {
|
|
type: 'url';
|
|
url: string;
|
|
point?: VecLike;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLHistoryEntry = TLCommand | TLHistoryMark;
|
|
|
|
// @public (undocumented)
|
|
export type TLHistoryMark = {
|
|
type: 'STOP';
|
|
id: string;
|
|
onUndo: boolean;
|
|
onRedo: boolean;
|
|
};
|
|
|
|
// @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 type TLOnBeforeCreateHandler<T extends TLShape> = (next: T) => T | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnBeforeUpdateHandler<T extends TLShape> = (prev: T, next: T) => T | void;
|
|
|
|
// @internal (undocumented)
|
|
export type TLOnBindingChangeHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnChildrenChangeHandler<T extends TLShape> = (shape: T) => TLShapePartial[] | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnClickHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnDoubleClickHandleHandler<T extends TLShape> = (shape: T, handle: TLHandle) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnDoubleClickHandler<T extends TLShape> = (shape: T) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnDragHandler<T extends TLShape, R = void> = (shape: T, shapes: TLShape[]) => R;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnEditEndHandler<T extends TLShape> = (shape: T) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnHandleChangeHandler<T extends TLShape> = (shape: T, info: {
|
|
handle: TLHandle;
|
|
isPrecise: boolean;
|
|
}) => TLShapePartial<T> | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnResizeEndHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnResizeHandler<T extends TLShape> = (shape: T, info: TLResizeInfo<T>) => Omit<TLShapePartial<T>, 'id' | 'type'> | undefined | void;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnResizeStartHandler<T extends TLShape> = TLEventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnRotateEndHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnRotateHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnRotateStartHandler<T extends TLShape> = TLEventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnTranslateEndHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnTranslateHandler<T extends TLShape> = TLEventChangeHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLOnTranslateStartHandler<T extends TLShape> = TLEventStartHandler<T>;
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEvent = (info: TLPinchEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLPinchEventInfo = TLBaseEventInfo & {
|
|
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 TLResizeHandle = SelectionCorner | SelectionEdge;
|
|
|
|
// @public
|
|
export type TLResizeInfo<T extends TLShape> = {
|
|
newPoint: Vec2d;
|
|
handle: TLResizeHandle;
|
|
mode: TLResizeMode;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
initialBounds: Box2d;
|
|
initialShape: T;
|
|
};
|
|
|
|
// @public
|
|
export type TLResizeMode = 'resize_bounds' | 'scale_shape';
|
|
|
|
// @public (undocumented)
|
|
export type TLSelectionHandle = RotateCorner | SelectionCorner | SelectionEdge;
|
|
|
|
// @public
|
|
export interface TLSessionStateSnapshot {
|
|
// (undocumented)
|
|
currentPageId: TLPageId;
|
|
// (undocumented)
|
|
exportBackground: boolean;
|
|
// (undocumented)
|
|
isDebugMode: boolean;
|
|
// (undocumented)
|
|
isFocusMode: boolean;
|
|
// (undocumented)
|
|
isGridMode: boolean;
|
|
// (undocumented)
|
|
isToolLocked: boolean;
|
|
// (undocumented)
|
|
pageStates: Array<{
|
|
pageId: TLPageId;
|
|
camera: {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
};
|
|
selectedIds: TLShapeId[];
|
|
focusLayerId: null | TLShapeId;
|
|
}>;
|
|
// (undocumented)
|
|
version: number;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLShapeInfo<T extends TLUnknownShape = TLUnknownShape> = {
|
|
type: T['type'];
|
|
util: TLShapeUtilConstructor<T>;
|
|
props?: ShapeProps<T>;
|
|
migrations?: Migrations;
|
|
tool?: TLStateNodeConstructor;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export interface TLShapeUtilConstructor<T extends TLUnknownShape, U extends ShapeUtil<T> = ShapeUtil<T>> {
|
|
// (undocumented)
|
|
new (editor: Editor, type: T['type'], styleProps: ReadonlyMap<StyleProp<unknown>, string>): U;
|
|
// (undocumented)
|
|
type: T['type'];
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLShapeUtilFlag<T> = (shape: T) => boolean;
|
|
|
|
// @public (undocumented)
|
|
export interface TLStateNodeConstructor {
|
|
// (undocumented)
|
|
new (editor: Editor, parent?: StateNode): StateNode;
|
|
// (undocumented)
|
|
children?: () => TLStateNodeConstructor[];
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
initial?: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLStoreEventInfo = HistoryEntry<TLRecord>;
|
|
|
|
// @public (undocumented)
|
|
export type TLStoreOptions = {
|
|
initialData?: SerializedStore<TLRecord>;
|
|
defaultName?: string;
|
|
} & ({
|
|
schema: StoreSchema<TLRecord, TLStoreProps>;
|
|
} | {
|
|
shapes: readonly AnyTLShapeInfo[];
|
|
});
|
|
|
|
// @public (undocumented)
|
|
export type TLStoreWithStatus = {
|
|
readonly status: 'error';
|
|
readonly store?: undefined;
|
|
readonly error: Error;
|
|
} | {
|
|
readonly status: 'loading';
|
|
readonly store?: undefined;
|
|
readonly error?: undefined;
|
|
} | {
|
|
readonly status: 'not-synced';
|
|
readonly store: TLStore;
|
|
readonly error?: undefined;
|
|
} | {
|
|
readonly status: 'synced-local';
|
|
readonly store: TLStore;
|
|
readonly error?: undefined;
|
|
} | {
|
|
readonly status: 'synced-remote';
|
|
readonly connectionStatus: 'offline' | 'online';
|
|
readonly store: TLStore;
|
|
readonly error?: undefined;
|
|
};
|
|
|
|
// @public (undocumented)
|
|
export type TLTickEvent = (elapsed: number) => void;
|
|
|
|
// @public
|
|
export interface TLUserPreferences {
|
|
// (undocumented)
|
|
animationSpeed: number;
|
|
// (undocumented)
|
|
color: string;
|
|
// (undocumented)
|
|
id: string;
|
|
// (undocumented)
|
|
isDarkMode: boolean;
|
|
// (undocumented)
|
|
isSnapMode: boolean;
|
|
// (undocumented)
|
|
locale: string;
|
|
// (undocumented)
|
|
name: string;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export type TLWheelEvent = (info: TLWheelEventInfo) => void;
|
|
|
|
// @public (undocumented)
|
|
export type TLWheelEventInfo = TLBaseEventInfo & {
|
|
type: 'wheel';
|
|
name: 'wheel';
|
|
delta: Vec2dModel;
|
|
};
|
|
|
|
export { track }
|
|
|
|
// @public (undocumented)
|
|
export const truncateStringWithEllipsis: (str: string, maxLength: number) => string;
|
|
|
|
// @public (undocumented)
|
|
export type UiEvent = TLCancelEvent | TLClickEvent | TLCompleteEvent | TLKeyboardEvent | TLPinchEvent | TLPointerEvent;
|
|
|
|
// @public (undocumented)
|
|
export type UiEventType = 'click' | 'keyboard' | 'pinch' | 'pointer' | 'wheel' | 'zoom';
|
|
|
|
// @public
|
|
export function uniqueId(): string;
|
|
|
|
export { useComputed }
|
|
|
|
// @public (undocumented)
|
|
export function useContainer(): HTMLDivElement;
|
|
|
|
// @public (undocumented)
|
|
export const useEditor: () => Editor;
|
|
|
|
// @internal (undocumented)
|
|
export function useLocalStore({ persistenceKey, sessionId, ...rest }: {
|
|
persistenceKey?: string;
|
|
sessionId?: string;
|
|
} & TLStoreOptions): TLStoreWithStatus;
|
|
|
|
// @internal (undocumented)
|
|
export function usePeerIds(): string[];
|
|
|
|
// @public (undocumented)
|
|
export function usePrefersReducedMotion(): boolean;
|
|
|
|
// @internal (undocumented)
|
|
export function usePresence(userId: string): null | TLInstancePresence;
|
|
|
|
export { useQuickReactor }
|
|
|
|
// @internal (undocumented)
|
|
export const USER_COLORS: readonly ["#FF802B", "#EC5E41", "#F2555A", "#F04F88", "#E34BA9", "#BD54C6", "#9D5BD2", "#7B66DC", "#02B1CC", "#11B3A3", "#39B178", "#55B467"];
|
|
|
|
export { useReactor }
|
|
|
|
// @public (undocumented)
|
|
export function useTLStore(opts: TLStoreOptions): TLStore;
|
|
|
|
export { useValue }
|
|
|
|
// @public (undocumented)
|
|
export const VideoShape: TLShapeInfo<TLVideoShape>;
|
|
|
|
// @public (undocumented)
|
|
export class VideoShapeUtil extends BaseBoxShapeUtil<TLVideoShape> {
|
|
// (undocumented)
|
|
canEdit: () => boolean;
|
|
// (undocumented)
|
|
component(shape: TLVideoShape): JSX.Element;
|
|
// (undocumented)
|
|
getDefaultProps(): TLVideoShape['props'];
|
|
// (undocumented)
|
|
indicator(shape: TLVideoShape): JSX.Element;
|
|
// (undocumented)
|
|
isAspectRatioLocked: () => boolean;
|
|
// (undocumented)
|
|
toSvg(shape: TLVideoShape): SVGGElement;
|
|
// (undocumented)
|
|
static type: "video";
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export class WeakMapCache<T extends object, K> {
|
|
// (undocumented)
|
|
access(item: T): K | undefined;
|
|
// (undocumented)
|
|
bust(): void;
|
|
// (undocumented)
|
|
get<P extends T>(item: P, cb: (item: P) => K): NonNullable<K>;
|
|
// (undocumented)
|
|
has(item: T): boolean;
|
|
// (undocumented)
|
|
invalidate(item: T): void;
|
|
// (undocumented)
|
|
items: WeakMap<T, K>;
|
|
// (undocumented)
|
|
set(item: T, value: K): void;
|
|
}
|
|
|
|
export { whyAmIRunning }
|
|
|
|
// @internal (undocumented)
|
|
export const ZOOMS: number[];
|
|
|
|
|
|
export * from "@tldraw/indices";
|
|
export * from "@tldraw/tlschema";
|
|
|
|
// (No @packageDocumentation comment for this package)
|
|
|
|
```
|