@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/canvas-core/editor/managers/shapeHierarchyManager.d.ts

@@ -0,0 +1,55 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { ContainerBoundsQueryOptions, LayerOrderDirection, LayerOrderEdge, ReparentShapePlacementInput, ReparentShapePlacementResult, ShapeGroupState, ShapeSelectionSiblingOrderState, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState } from "../editor";
+/**
+ * Shape-tree structure operations for the editor: grouping/ungrouping, the layer
+ * tree, sibling/parent z-ordering, and reparent placement. These are cohesive
+ * mutations over the shape hierarchy carved out of the Editor facade so the
+ * editor can stay a thinner delegating surface. The Editor exposes thin wrappers
+ * that forward here.
+ */
+export declare class ShapeHierarchyManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    private get store();
+    getSelectionParentOrderState(): ShapeSelectionSiblingOrderState | null;
+    getSelectionGroupState(): ShapeGroupState | null;
+    canGroupSelection(): boolean;
+    private getGroupStateForShapeIds;
+    private groupShapesFromState;
+    canGroupShapes(ids: readonly ShapeId[]): boolean;
+    groupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeRecord | null;
+    groupSelection(source?: ChangeSource): ShapeRecord | null;
+    getUngroupableSelectedShapeIds(): ShapeId[];
+    getUngroupableShapeIds(ids: readonly ShapeId[]): ShapeId[];
+    canUngroupSelection(): boolean;
+    canUngroupShapes(ids: readonly ShapeId[]): boolean;
+    ungroupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeId[];
+    ungroupSelection(source?: ChangeSource): ShapeId[];
+    getSelectionSiblingOrderState(): ShapeSiblingOrderState | null;
+    canMoveSelectionWithinParent(direction: ShapeSiblingOrderDirection): boolean;
+    canMoveSelectionInParentOrder(direction: ShapeSiblingOrderDirection): boolean;
+    canMoveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection): boolean;
+    moveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource): boolean;
+    moveShapesToParentOrderEdge(ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource): boolean;
+    moveSelectionWithinParent(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+    moveShapesToParentPlacement(input: ReparentShapePlacementInput, source?: ChangeSource): boolean;
+    moveShapesToParentPlacementResult(input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;
+    moveSelectionInParentOrder(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+    moveSelectionToParentOrderEdge(edge: ShapeSiblingOrderEdge, source?: ChangeSource): boolean;
+    isShapeOrAncestorLocked(shapeId: ShapeId): boolean;
+    hasLockedDescendant(shapeId: ShapeId): boolean;
+    getOutermostSelectableShapeId(shapeId: ShapeId): ShapeId;
+    getShapeIdsIncludingDescendants(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeIdsForSelectionTransform(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeIdsForSelectionRotation(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getSelectionTransformTargetShapes(): ShapeRecord[];
+    getSelectionRotationTargetShapes(): ShapeRecord[];
+    getShapeExportTraversalIds(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeIdsInContainerBounds(containerId: ShapeId, options?: ContainerBoundsQueryOptions): ShapeId[];
+    canUseShapeParent(parentId: ShapeParentId, childId?: ShapeId): boolean;
+    isShapeOrAncestorInSet(shapeId: ShapeId, ids: ReadonlySet<ShapeId>): boolean;
+    isShapeDescendantOf(shapeId: ShapeId, ancestorId: ShapeId): boolean;
+    private getShapeIdsForSelectionDescendantTransform;
+}

package/_vendor/canvas-core/editor/managers/shapeOrder.d.ts

@@ -0,0 +1,14 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId } from "../../schema/records";
+import type { Editor, LayerOrderDirection, LayerOrderEdge, ShapeSelectionSiblingOrderState, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState } from "../editor";
+export declare function getSelectionParentOrderState(editor: Editor): ShapeSelectionSiblingOrderState | null;
+export declare function getSelectionSiblingOrderState(editor: Editor): ShapeSiblingOrderState | null;
+export declare function canMoveSelectionWithinParent(editor: Editor, direction: ShapeSiblingOrderDirection): boolean;
+export declare function canMoveSelectionInParentOrder(editor: Editor, direction: ShapeSiblingOrderDirection): boolean;
+export declare function getShapeParentOrderState(editor: Editor, ids: readonly ShapeId[]): ShapeSelectionSiblingOrderState | null;
+export declare function canMoveShapesInParentOrder(editor: Editor, ids: readonly ShapeId[], direction: LayerOrderDirection): boolean;
+export declare function moveShapesInParentOrder(editor: Editor, ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource): boolean;
+export declare function moveShapesToParentOrderEdge(editor: Editor, ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource): boolean;
+export declare function moveSelectionWithinParent(editor: Editor, direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+export declare function moveSelectionInParentOrder(editor: Editor, direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+export declare function moveSelectionToParentOrderEdge(editor: Editor, edge: ShapeSiblingOrderEdge, source?: ChangeSource): boolean;

package/_vendor/canvas-core/editor/managers/shapeReparenting.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+import type { Editor, ReparentShapePlacementInput, ReparentShapePlacementResult } from "../editor";
+export declare function canUseShapeParent(editor: Editor, parentId: ShapeParentId, childId?: ShapeId): boolean;
+export declare function moveShapesToParentPlacement(editor: Editor, input: ReparentShapePlacementInput, source?: ChangeSource): boolean;
+export declare function moveShapesToParentPlacementResult(editor: Editor, input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;

package/_vendor/canvas-core/editor/managers/shortcutManager.d.ts

@@ -0,0 +1,56 @@
+import type { KeyboardEditorEvent } from "../events";
+export type EditorKeyboardShortcutCommand = "delete-selection" | "move-selection-backward" | "move-selection-forward" | "redo" | "reset-interaction" | "undo";
+export type KeyboardShortcutTarget = {
+    type: "action";
+    actionId: string;
+} | {
+    type: "editor";
+    command: EditorKeyboardShortcutCommand;
+} | {
+    type: "tool";
+    toolId: string;
+};
+export interface KeyboardShortcutChord {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    accelKey?: boolean;
+}
+export type KeyboardShortcutInput = string | KeyboardShortcutChord;
+export interface KeyboardShortcutBinding {
+    id: string;
+    shortcut: KeyboardShortcutInput;
+    target: KeyboardShortcutTarget;
+    label?: string;
+}
+export type KeyboardShortcutEventLike = Pick<KeyboardEditorEvent, "key" | "altKey" | "ctrlKey" | "metaKey" | "shiftKey" | "accelKey">;
+interface NormalizedKeyboardShortcutChord {
+    key: string;
+    altKey: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey: boolean;
+    accelKey?: boolean;
+}
+export declare class ShortcutManager {
+    private readonly bindings;
+    private readonly bindingIds;
+    register(binding: KeyboardShortcutBinding): void;
+    registerActionShortcut(actionId: string, shortcut: KeyboardShortcutInput): void;
+    registerEditorShortcut(command: EditorKeyboardShortcutCommand, shortcut: KeyboardShortcutInput): void;
+    registerToolShortcut(toolId: string, shortcut: KeyboardShortcutInput): void;
+    unregister(id: string): void;
+    getBinding(id: string): KeyboardShortcutBinding | null;
+    getTargetForEvent(event: KeyboardShortcutEventLike): KeyboardShortcutTarget | null;
+    getActionIdForEvent(event: KeyboardShortcutEventLike): string | null;
+    getToolIdForEvent(event: KeyboardShortcutEventLike): string | null;
+    getActionShortcutLabel(actionId: string): string | undefined;
+    getToolShortcutLabel(toolId: string): string | undefined;
+    private getBindingForEvent;
+    private getBindingLabel;
+}
+export declare function normalizeKeyboardShortcut(shortcut: KeyboardShortcutInput): NormalizedKeyboardShortcutChord;
+export declare function formatKeyboardShortcut(shortcut: KeyboardShortcutInput): string;
+export {};

package/_vendor/canvas-core/editor/managers/sideEffectManager.d.ts

@@ -0,0 +1,23 @@
+import type { ChangeSource } from "../../../store/index";
+import type { EditorRecord } from "../../schema/records";
+/**
+ * Type-keyed lifecycle handlers for record changes. Side effects let the editor
+ * and plugins react to record mutations (binding cleanup, selection repair,
+ * delete cleanup) without each command hard-coding the full cleanup sequence.
+ *
+ * `before*` handlers run synchronously inside the mutating command, while the
+ * record still exists, so a handler can cascade further changes in the same
+ * transaction. `after*` handlers run once a command's cleanup phase completes.
+ */
+export type RecordTypeName = EditorRecord["typeName"];
+export type BeforeDeleteHandler = (ids: readonly string[], source: ChangeSource) => void;
+export type AfterDeleteHandler = (ids: readonly string[], source: ChangeSource) => void;
+export declare class SideEffectManager {
+    private readonly beforeDelete;
+    private readonly afterDelete;
+    registerBeforeDeleteHandler(typeName: RecordTypeName, handler: BeforeDeleteHandler): () => void;
+    registerAfterDeleteHandler(typeName: RecordTypeName, handler: AfterDeleteHandler): () => void;
+    runBeforeDelete(typeName: RecordTypeName, ids: readonly string[], source: ChangeSource): void;
+    runAfterDelete(typeName: RecordTypeName, ids: readonly string[], source: ChangeSource): void;
+    private register;
+}

package/_vendor/canvas-core/editor/managers/snapCalculations.d.ts

@@ -0,0 +1,40 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { ShapeId } from "../../schema/records";
+import type { SelectionResizeHandleId } from "../selection";
+import type { ResizeSnapInput, SnapAxis, SnapNode, SnapPoint } from "./snapTypes";
+export interface PointSnapPair {
+    selectionPoint: Vec;
+    candidatePoint: Vec;
+    candidateNodeId: ShapeId;
+}
+export interface PointAxisSnap {
+    type: "points";
+    nudge: number;
+    pairs: PointSnapPair[];
+}
+export interface Gap {
+    direction: "horizontal" | "vertical";
+    startNode: SnapNode;
+    endNode: SnapNode;
+    length: number;
+    breadthIntersection: [number, number];
+}
+export interface GapAxisSnap {
+    type: "gaps";
+    nudge: number;
+    gaps: Gap[];
+}
+export type AxisSnap = PointAxisSnap | GapAxisSnap;
+export declare function getPointSnap(axis: SnapAxis, selectionPoints: Vec[], candidatePoints: SnapPoint[], threshold: number): PointAxisSnap | null;
+export declare function getResizeSnapPointsForHandle(handleId: SelectionResizeHandleId | "any", bounds: Box): Vec[];
+export declare function getResizeResultAfterNudge(input: ResizeSnapInput, nudge: Vec): {
+    bounds: Box;
+    scaleX: number;
+    scaleY: number;
+};
+export declare function getResizeBoundsAfterNudge(input: ResizeSnapInput, nudge: Vec): Box;
+export declare function collectGaps(nodes: SnapNode[], axis: SnapAxis): Gap[];
+export declare function createGap(direction: Gap["direction"], startNode: SnapNode, endNode: SnapNode, axis: SnapAxis): Gap | null;
+export declare function getGapSnap(axis: SnapAxis, selectionBounds: Box, visibleGaps: Gap[], threshold: number): GapAxisSnap | null;
+export declare function chooseAxisSnap(pointSnap: PointAxisSnap | null, gapSnap: GapAxisSnap | null): AxisSnap | null;

package/_vendor/canvas-core/editor/managers/snapGeometry.d.ts

@@ -0,0 +1,26 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { SnapAxis } from "./snapTypes";
+export declare const EPSILON = 1e-8;
+export declare function areVecsEqual(left: Vec, right: Vec): boolean;
+export declare function getBoxSnapPoints(bounds: Box): Vec[];
+export declare function getAxisValue(point: Vec, axis: SnapAxis): number;
+export declare function getAxisMin(bounds: Box, axis: SnapAxis): number;
+export declare function getAxisMax(bounds: Box, axis: SnapAxis): number;
+export declare function getAxisSize(bounds: Box, axis: SnapAxis): number;
+export declare function getBreadthRange(bounds: Box, axis: SnapAxis): [number, number];
+export declare function getRangeIntersection(first: [number, number], second: [number, number]): [number, number] | null;
+export declare function rangesOverlap(first: [number, number], second: [number, number]): boolean;
+export declare function translateBounds(bounds: Box, delta: Vec): Box;
+export declare function getAxisDelta(axis: SnapAxis, value: number): Vec;
+export declare function translateBoundsOnAxis(bounds: Box, axis: SnapAxis, value: number): Box;
+export declare function translatePoints(points: Vec[], delta: Vec): Vec[];
+export declare function getBoxPagePoints(bounds: Box): Vec[];
+export declare function getBoxLocalOutline(bounds: Box): Vec[];
+export declare function getDistanceToSegmentSquared(point: Vec, segmentStart: Vec, segmentEnd: Vec): number;
+export declare function getNearestPointOnSegment(point: Vec, segmentStart: Vec, segmentEnd: Vec): Vec;
+export declare function getNearestPointOnOutline(point: Vec, outline: readonly Vec[]): {
+    point: Vec;
+    distanceSquared: number;
+} | null;
+export declare function dedupePoints(points: Vec[]): Vec[];

package/_vendor/canvas-core/editor/managers/snapIndicators.d.ts

@@ -0,0 +1,22 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { GapSnapIndicatorGapState, GapSnapIndicatorState, PointSnapIndicatorState, SnapIndicatorState } from "../selection";
+import type { Gap, GapAxisSnap, PointAxisSnap } from "./snapCalculations";
+import type { SnapAxis, SnapCoordinateSpace, SnapNode } from "./snapTypes";
+export declare function arePointIndicatorsEqual(left: PointSnapIndicatorState, right: PointSnapIndicatorState): boolean;
+export declare function areGapEdgesEqual(left: GapSnapIndicatorGapState, right: GapSnapIndicatorGapState): boolean;
+export declare function areGapIndicatorsEqual(left: GapSnapIndicatorState, right: GapSnapIndicatorState): boolean;
+export declare function areIndicatorsEqual(left: SnapIndicatorState[], right: SnapIndicatorState[]): boolean;
+export declare function getGapEdges(gap: Gap): GapSnapIndicatorGapState;
+export declare function getPointIndicator(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace): PointSnapIndicatorState;
+export declare function getPointIndicators(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace): PointSnapIndicatorState[];
+export declare function getPointSnapGroups(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec): PointAxisSnap[];
+export declare function getAxisExtentPoints(axis: SnapAxis, axisValue: number, bounds: Box): Vec[];
+export declare function getPointIndicatorLine(axis: SnapAxis, points: readonly Vec[]): [Vec, Vec];
+export declare function getPointIndicatorId(axis: SnapAxis, line: readonly [Vec, Vec], points: readonly Vec[]): string;
+export declare function getPointIndicatorWithBoundsExtent(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace, bounds: Box, candidateNodes: readonly SnapNode[]): PointSnapIndicatorState;
+export declare function getPointIndicatorsWithBoundsExtent(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace, bounds: Box, candidateNodes: readonly SnapNode[]): PointSnapIndicatorState[];
+export declare function getHandlePointIndicator(snappedPagePoint: Vec): PointSnapIndicatorState;
+export declare function getHandleAlignIndicator(axis: SnapAxis, snappedPagePoint: Vec, targetPoint: Vec): PointSnapIndicatorState;
+export declare function getGapIndicator(snap: GapAxisSnap, coordinateSpace: SnapCoordinateSpace, finalNudge: Vec): SnapIndicatorState;
+export declare function cloneIndicator(indicator: SnapIndicatorState): SnapIndicatorState;

package/_vendor/canvas-core/editor/managers/snapManager.d.ts

@@ -0,0 +1,29 @@
+import { type Signal } from "../../../signals/index";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { SnapIndicatorState } from "../selection";
+import type { HandleSnapInput, HandleSnapResult, HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapInput, ResizeSnapResult, ResizeSnapSnapshot, SnapCoordinateSpace, TranslateSnapInput, TranslateSnapResult, TranslateSnapSnapshot } from "./snapTypes";
+export declare class SnapManager {
+    private readonly gapCache;
+    private readonly _indicatorsSignal;
+    readonly indicatorsSignal: Signal<SnapIndicatorState[]>;
+    readonly activeSignal: import("../../../signals/index").Computed<boolean>;
+    private readonly snapshots;
+    constructor(editor: Editor);
+    setIndicators(indicators: SnapIndicatorState[]): void;
+    clearIndicators(): void;
+    createTranslateSnapshot({ movingShapeIds, coordinateSpace, }: {
+        movingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): TranslateSnapSnapshot;
+    createResizeSnapshot({ resizingShapeIds, coordinateSpace, }: {
+        resizingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): ResizeSnapSnapshot;
+    createHandleSnapshot(input: HandleSnapSnapshotInput): HandleSnapSnapshot;
+    snapTranslate(input: TranslateSnapInput): TranslateSnapResult;
+    snapResize(input: ResizeSnapInput): ResizeSnapResult;
+    snapHandle(input: HandleSnapInput): HandleSnapResult | null;
+    private snapHandlePoint;
+    private snapHandleAlign;
+}

package/_vendor/canvas-core/editor/managers/snapSnapshotBuilder.d.ts

@@ -0,0 +1,22 @@
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapSnapshot, SnapCoordinateSpace, TranslateSnapSnapshot } from "./snapTypes";
+export declare class SnapSnapshotBuilder {
+    private readonly editor;
+    constructor(editor: Editor);
+    createTranslateSnapshot({ movingShapeIds, coordinateSpace, }: {
+        movingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): TranslateSnapSnapshot;
+    createResizeSnapshot({ resizingShapeIds, coordinateSpace, }: {
+        resizingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): ResizeSnapSnapshot;
+    createHandleSnapshot({ context, currentPagePoint, allowSelfSnap, excludedShapeIds, }: HandleSnapSnapshotInput): HandleSnapSnapshot;
+    private collectHandleSnapGeometry;
+    private collectSelfHandleSnapGeometry;
+    private createBoundsSnapSnapshot;
+    private collectBindingDrivenExcludedShapeIds;
+    private getSnapScopeParentId;
+    private getCandidateShapeIds;
+}

package/_vendor/canvas-core/editor/managers/snapTypes.d.ts

@@ -0,0 +1,98 @@
+import type { Box } from "../../geometry/box";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+import type { SelectionHandle, SelectionResizeHandleId, SnapIndicatorState } from "../selection";
+export type SnapAxis = "x" | "y";
+export type HandleSnapMode = "none" | "point" | "align";
+export interface SnapCoordinateSpace {
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface SnapPoint {
+    id: string;
+    nodeId: ShapeId;
+    point: Vec;
+}
+export interface SnapNode {
+    id: string;
+    bounds: Box;
+}
+export interface HandleSnapContext {
+    shapeId: ShapeId;
+    handle: SelectionHandle;
+}
+export interface HandleSnapPoint {
+    id: string;
+    nodeId: ShapeId;
+    point: Vec;
+}
+export interface HandleSnapOutline {
+    id: ShapeId;
+    points: Vec[];
+}
+export interface HandleSnapSnapshot {
+    points: HandleSnapPoint[];
+    outlines: HandleSnapOutline[];
+    scopeParentId?: ShapeParentId | null;
+    candidateShapeIds?: ShapeId[];
+}
+export interface TranslateSnapSnapshot {
+    points: SnapPoint[];
+    nodes: SnapNode[];
+    coordinateSpace: SnapCoordinateSpace;
+    scopeParentId?: ShapeParentId | null;
+    candidateShapeIds?: ShapeId[];
+}
+export interface TranslateSnapInput {
+    lockedAxis: SnapAxis | null;
+    initialSelectionBounds: Box;
+    dragDelta: Vec;
+    snapshot: TranslateSnapSnapshot;
+    threshold: number;
+}
+export interface TranslateSnapResult {
+    nudge: Vec;
+    indicators: SnapIndicatorState[];
+}
+export interface ResizeSnapSnapshot {
+    points: SnapPoint[];
+    nodes: SnapNode[];
+    coordinateSpace: SnapCoordinateSpace;
+    scopeParentId?: ShapeParentId | null;
+    candidateShapeIds?: ShapeId[];
+}
+export interface ResizeSnapInput {
+    handleId: SelectionResizeHandleId;
+    initialSelectionBounds: Box;
+    resizedSelectionBounds: Box;
+    scaleX: number;
+    scaleY: number;
+    snapshot: ResizeSnapSnapshot;
+    threshold: number;
+    isAspectRatioLocked: boolean;
+    isResizingFromCenter: boolean;
+}
+export interface ResizeSnapResult {
+    nudge: Vec;
+    bounds: Box;
+    scaleX: number;
+    scaleY: number;
+    indicators: SnapIndicatorState[];
+}
+export interface HandleSnapSnapshotInput {
+    context: HandleSnapContext;
+    currentPagePoint: Vec;
+    allowSelfSnap?: boolean;
+    excludedShapeIds?: Iterable<ShapeId>;
+}
+export interface HandleSnapInput {
+    mode: HandleSnapMode;
+    pagePoint: Vec;
+    snapshot: HandleSnapSnapshot;
+    threshold: number;
+}
+export interface HandleSnapResult {
+    snappedPagePoint: Vec;
+    nudge: Vec;
+    indicators: SnapIndicatorState[];
+}

package/_vendor/canvas-core/editor/managers/spatialIndexManager.d.ts

@@ -0,0 +1,30 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { PageId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { QueryManager } from "./queryManager";
+export interface SpatialQueryOptions {
+    pageId?: PageId;
+}
+export interface ShapeAtPointOptions extends SpatialQueryOptions {
+    filter?: (shape: ShapeRecord) => boolean;
+}
+export interface ShapeLineSegmentHitTestOptions extends SpatialQueryOptions {
+    margin?: number;
+    filter?: (shape: ShapeRecord) => boolean;
+}
+export declare class SpatialIndexManager {
+    private readonly editor;
+    private readonly queries;
+    private readonly pageIndexSignals;
+    constructor(editor: Editor, queries: QueryManager);
+    getShapesInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getShapeIdsInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord["id"][];
+    getShapesInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getShapeIdsInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord["id"][];
+    getShapeAtPoint(point: Vec, options?: ShapeAtPointOptions): ShapeRecord | null;
+    getShapesAtPoint(point: Vec, options?: ShapeAtPointOptions): ShapeRecord[];
+    getShapesHitByLineSegment(start: Vec, end: Vec, options?: ShapeLineSegmentHitTestOptions): ShapeRecord[];
+    private getPageIndexSignal;
+    private getPageIndex;
+}

package/_vendor/canvas-core/editor/managers/toolManager.d.ts

@@ -0,0 +1,24 @@
+import type { Editor } from "../editor";
+import type { CancelEditorEvent, EditorEvent } from "../events";
+import type { StateNode } from "../stateNode";
+import type { KeyboardShortcutInput } from "./shortcutManager";
+type ToolFactory = (editor: Editor) => StateNode;
+export interface ToolRegistrationOptions {
+    shortcut?: KeyboardShortcutInput;
+}
+export declare class ToolManager {
+    private readonly editor;
+    readonly activeToolId: import("../../../signals/index").Atom<string>;
+    readonly isToolLocked: import("../../../signals/index").Atom<boolean>;
+    private readonly registry;
+    private activeTool;
+    constructor(editor: Editor);
+    register(id: string, factory: ToolFactory, options?: ToolRegistrationOptions): void;
+    hasTool(id: string): boolean;
+    setActiveTool(id: string, reason?: CancelEditorEvent["reason"]): void;
+    dispatch(event: EditorEvent): void;
+    cancel(reason: CancelEditorEvent["reason"]): void;
+    setToolLocked(locked: boolean): void;
+    isActiveToolInInitialState(): boolean;
+}
+export {};

package/_vendor/canvas-core/editor/queries/shapeTransforms.d.ts

@@ -0,0 +1,27 @@
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import type { ShapeRecord } from "../../schema/records";
+import type { ShapeUtil } from "../../shapes/shapeUtil";
+export interface ShapeGeometry {
+    bounds: Box;
+    center: Vec;
+    corners: Vec[];
+    outlineVertices: Vec[];
+}
+export declare function getShapeLocalBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
+export declare function getShapeRenderBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
+export declare function getShapeExportBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
+export declare function getShapeLocalToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Mat;
+export declare function getShapePositionedToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Mat;
+export declare function getShapeRenderToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Mat;
+export declare function getShapeExportToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Mat;
+export declare function getShapePageCenter<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Vec;
+export declare function positionedShapePointToPagePoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>): Vec;
+export declare function pagePointToShapePositionedPoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>): Vec;
+export declare function getShapePositionedOutlineVertices<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Vec[];
+export declare function getShapePageCorners<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Vec[];
+export declare function getShapePageOutlineVertices<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Vec[];
+export declare function getShapePageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
+export declare function getShapeExportPageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
+export declare function getShapeGeometry<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): ShapeGeometry;

package/_vendor/canvas-core/editor/renderWindow.d.ts

@@ -0,0 +1,30 @@
+import { Box } from "../geometry/box";
+import type { ShapeId } from "../schema/records";
+export declare const RENDER_CULLING_OVERSCAN_SCREEN = 160;
+export interface ShapeIndexRange {
+    start: number;
+    end: number;
+}
+export interface ShapeWindowSnapshot {
+    viewportReady: boolean;
+    ranges: ShapeIndexRange[];
+    shapeIds: ShapeId[];
+}
+export declare function doesBoxContainBox(outer: Box, inner: Box): boolean;
+export declare function formatShapeIndexRanges(ranges: ShapeIndexRange[]): string;
+export declare function getRetainedRenderWindowExtraShapeBudget(culledShapeCount: number): number;
+export declare function mergeShapeIndexRanges(ranges: ShapeIndexRange[], gapAllowance?: number): ShapeIndexRange[];
+export declare function doRangesContainRanges(outerRanges: ShapeIndexRange[], innerRanges: ShapeIndexRange[]): boolean;
+export declare function getShapeIndexRangeSpan(ranges: ShapeIndexRange[]): number;
+export declare function getExpandedRetainedShapeRanges(previousRanges: ShapeIndexRange[], nextRanges: ShapeIndexRange[], extraShapeBudget: number): ShapeIndexRange[] | null;
+export declare function getExpandedRetainedBaseShapeRanges(previousRanges: ShapeIndexRange[], nextRanges: ShapeIndexRange[]): ShapeIndexRange[] | null;
+export declare function getShapeIndexRangesForShapeIds(shapeIds: ShapeId[], pageIndexById: Map<ShapeId, number>, gapAllowance?: number): ShapeIndexRange[];
+export declare function getShapeWindowSnapshot(pageShapeIds: ShapeId[], ranges: ShapeIndexRange[], options?: {
+    viewportReady?: boolean;
+}): ShapeWindowSnapshot;
+export declare function getShapeIdArrayChangeCounts(previous: ShapeId[], next: ShapeId[]): {
+    changed: number;
+    added: number;
+    removed: number;
+};
+export declare function collectRetainedShapeRanges(pageShapeIds: ShapeId[], culledShapeIds: ShapeId[], selectedIds: Set<ShapeId>, extraShapeBudget: number): ShapeIndexRange[];

package/_vendor/canvas-core/editor/resizeGeometry.d.ts

@@ -0,0 +1,97 @@
+import { Box } from "../geometry/box";
+import { Vec } from "../geometry/vec";
+import type { SelectionResizeHandleId } from "./selection";
+export interface SelectionResizeBoundsResult {
+    bounds: Box;
+    scaleX: number;
+    scaleY: number;
+}
+export interface SelectionResizeScalesResult {
+    scaleX: number;
+    scaleY: number;
+}
+export declare function selectionResizeHandleMovesLeftEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function selectionResizeHandleMovesRightEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function selectionResizeHandleMovesTopEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function selectionResizeHandleMovesBottomEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function isSelectionResizeCorner(handleId: SelectionResizeHandleId): boolean;
+export declare function getSelectionResizeHandleForScale({ handleId, scaleX, scaleY, }: {
+    handleId: SelectionResizeHandleId;
+    scaleX: number;
+    scaleY: number;
+}): SelectionResizeHandleId;
+export declare function getSelectionResizeScalesFromBounds({ startBounds, bounds, handleId, scaleX, scaleY, isResizingFromCenter, }: {
+    startBounds: Box;
+    bounds: Box;
+    handleId: SelectionResizeHandleId;
+    scaleX?: number;
+    scaleY?: number;
+    isResizingFromCenter?: boolean;
+}): SelectionResizeScalesResult;
+export declare function getAnchoredSelectionResizeLocalBounds({ requestedBounds, handleId, actualWidth, actualHeight, scaleX, scaleY, isResizingFromCenter, }: {
+    requestedBounds: Box;
+    handleId: SelectionResizeHandleId;
+    actualWidth: number;
+    actualHeight: number;
+    scaleX: number;
+    scaleY: number;
+    isResizingFromCenter: boolean;
+}): Box;
+export declare function getSelectionResizeBounds({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): Box;
+export declare function getSelectionResizeBoundsWithScale({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): SelectionResizeBoundsResult;
+export declare function getCenteredSelectionResizeBounds({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): Box;
+export declare function getCenteredSelectionResizeBoundsWithScale({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): SelectionResizeBoundsResult;
+export declare function getAspectRatioLockedSelectionResizeBounds({ bounds, startBounds, handleId, aspectRatio, isResizingFromCenter, }: {
+    bounds: Box;
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    aspectRatio: number;
+    isResizingFromCenter: boolean;
+}): Box;
+export declare function getAspectRatioLockedSelectionResizeBoundsWithScale({ bounds, startBounds, handleId, aspectRatio, isResizingFromCenter, scaleX, scaleY, }: {
+    bounds: Box;
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    aspectRatio: number;
+    isResizingFromCenter: boolean;
+    scaleX?: number;
+    scaleY?: number;
+}): SelectionResizeBoundsResult;
+export declare function getConstrainedSelectionResizeBounds({ startBounds, handleId, pagePoint, isAspectRatioLocked, isResizingFromCenter, aspectRatio, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+    isAspectRatioLocked: boolean;
+    isResizingFromCenter: boolean;
+    aspectRatio: number;
+}): Box;
+export declare function getConstrainedSelectionResizeBoundsWithScale({ startBounds, handleId, pagePoint, isAspectRatioLocked, isResizingFromCenter, aspectRatio, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+    isAspectRatioLocked: boolean;
+    isResizingFromCenter: boolean;
+    aspectRatio: number;
+}): SelectionResizeBoundsResult;
+export declare function normalizeSelectionResizeBoundsFromEdges({ minX, minY, maxX, maxY, }: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}): Box;