@yuzhouu/canvas-kit 0.1.2 → 0.1.3

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

@@ -0,0 +1,21 @@
+import type { ChangeSource } from "../../../store/index";
+import type { PageId, ShapeId } from "../../schema/records";
+import type { Editor } from "../Editor";
+/**
+ * Selection-set writes for the editor: which shapes are selected per page. These
+ * are cohesive session-state mutations carved out of the Editor facade so the
+ * editor can stay a thinner delegating surface. Selection geometry and the
+ * rotation/flip transforms live elsewhere (selection.ts /
+ * editorSelectionTransforms.ts); this manager only owns the selected-id sets.
+ * The Editor exposes thin wrappers that forward here.
+ */
+export declare class SelectionManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    setSelectedShapeIds(ids: ShapeId[], options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    removeShapeIdsFromSelection(ids: ShapeId[], source?: ChangeSource): void;
+    selectAllCurrentPage(source?: ChangeSource): void;
+}

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

@@ -0,0 +1,23 @@
+import { type Signal } from "../../../signals/index";
+import type { Editor, EditorOverlayDebugState } from "../Editor";
+import type { SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState } from "../selection";
+/**
+ * Selection overlay derived state: frame geometry/style, handles, combined
+ * overlay state, companion frames, and debug metrics. The Editor exposes thin
+ * signal aliases that forward here.
+ */
+export declare class SelectionOverlayManager {
+    private readonly editor;
+    readonly frameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly companionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly arrowPathSignal: Signal<string | null>;
+    readonly frameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
+    readonly frameSignal: Signal<SelectionOverlayFrameState | null>;
+    readonly handleAnchorsSignal: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly handlesSignal: Signal<SelectionOverlayHandlesState | null>;
+    readonly handleCountsSignal: Signal<SelectionOverlayHandleCountsState | null>;
+    readonly overlaySignal: Signal<SelectionOverlayState | null>;
+    readonly debugStateSignal: Signal<EditorOverlayDebugState>;
+    private readonly debugStateSnapshotSignal;
+    constructor(editor: Editor);
+}

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

@@ -0,0 +1,29 @@
+import { type Signal } from "../../../signals/index";
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeEditingEntryRequest, ShapeEditingSession, ShapeId, ShapeRecord } from "../../schema/records";
+import type { StartEditingShapeInput } from "../commands";
+import type { Editor } from "../Editor";
+/**
+ * Shape editing lifecycle for the editor: edit-session entry, completion,
+ * cancellation, composition state, and focus-entry requests. The Editor exposes
+ * thin wrappers that forward here.
+ */
+export declare class ShapeEditingManager {
+    private readonly editor;
+    private readonly entryRequestAtom;
+    readonly entryRequestSignal: Signal<ShapeEditingEntryRequest | null>;
+    private nextEntryRequestId;
+    constructor(editor: Editor);
+    canEditShape(shapeOrId: ShapeRecord | ShapeId | null | undefined): boolean;
+    start(input: StartEditingShapeInput, source?: ChangeSource): ShapeEditingSession | null;
+    complete(source?: ChangeSource): boolean;
+    cancel(source?: ChangeSource): boolean;
+    setComposition(isComposing: boolean, source?: ChangeSource): void;
+    consumeEntryRequest(requestId: number): void;
+    removeShapeIds(ids: ShapeId[], source?: ChangeSource): void;
+    end(options: {
+        runEditEnd: boolean;
+        source: ChangeSource;
+    }): void;
+    private publishEntryRequest;
+}

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

@@ -0,0 +1,42 @@
+import { Box } from "../../geometry/Box";
+import { Mat } from "../../geometry/Mat";
+import { Vec } from "../../geometry/Vec";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../Editor";
+import { type ShapeGeometry } from "../queries/shapeTransforms";
+import type { SelectionFrame } from "../selection";
+/**
+ * Shape and selection geometry facade helpers. Query-backed methods read the
+ * current editor state; compute methods operate on the provided shape snapshot.
+ */
+export declare class ShapeGeometryManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    computeShapeBounds(shape: ShapeRecord): Box;
+    computeShapeLocalBounds(shape: ShapeRecord): Box;
+    computeShapeRenderBounds(shape: ShapeRecord): Box;
+    computeShapeExportBounds(shape: ShapeRecord): Box;
+    computeShapeLocalToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeRenderToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeExportToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageBounds(shape: ShapeRecord): Box;
+    computeShapeExportPageBounds(shape: ShapeRecord): Box;
+    computeShapeGeometry(shape: ShapeRecord): ShapeGeometry;
+    computeShapePositionedToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageCenter(shape: ShapeRecord): Vec;
+    computeShapePageCorners(shape: ShapeRecord): Vec[];
+    computeShapePageOutlineVertices(shape: ShapeRecord): Vec[];
+    getShapeBounds(shapeId: ShapeId): Box | null;
+    getShapePageBounds(shapeId: ShapeId): Box | null;
+    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | null;
+    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | null;
+    getShapePageCenter(shapeId: ShapeId): Vec | null;
+    getShapePageCorners(shapeId: ShapeId): Vec[] | null;
+    getShapePageOutlineVertices(shapeId: ShapeId): Vec[];
+    getSelectionPageBounds(): Box | null;
+    getSelectionFrame(): SelectionFrame | null;
+    isPointInSelectionBounds(point: Vec): boolean;
+    getSelectionFrameLocalBoundsPoint(point: Vec): Vec | null;
+    getSelectionPageOutlineVertices(): Vec[];
+    getSelectionToolbarAnchorPagePoint(): Vec | null;
+}

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

@@ -0,0 +1,58 @@
+import type { ChangeSource } from "../../../store/index";
+import type { PageId, ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../Editor";
+import type { ContainerBoundsQueryOptions, LayerOrderDirection, LayerOrderEdge, LayerTreeNode, 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;
+    getLayerTree(pageId?: PageId): LayerTreeNode[];
+    getLayerNode(id: ShapeId): LayerTreeNode | null;
+    private getLayerDepth;
+    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/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/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/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,25 @@
+import type { Editor } from "../Editor";
+import type { CancelEditorEvent, EditorEvent } from "../events";
+import type { StateNode } from "../StateNode";
+type ToolFactory = (editor: Editor) => StateNode;
+export interface ToolRegistrationOptions {
+    shortcut?: string;
+}
+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 readonly shortcutToolIds;
+    private activeTool;
+    constructor(editor: Editor);
+    register(id: string, factory: ToolFactory, options?: ToolRegistrationOptions): void;
+    hasTool(id: string): boolean;
+    getToolIdForShortcut(key: string): string | null;
+    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/managers/queryState.d.ts

@@ -0,0 +1,18 @@
+import type { StoreChange } from "../../../store/index";
+import { type BindingId, type BindingRecord, type EditorRecord, type PageId, type ShapeId, type ShapeParentId } from "../../schema/records";
+export interface QueryState {
+    pageShapeIdsByPage: Map<PageId, ShapeId[]>;
+    childShapeIdsByParent: Map<ShapeParentId, ShapeId[]>;
+    pageIdByShape: Map<ShapeId, PageId>;
+    bindingById: Map<BindingId, BindingRecord>;
+    bindingIdsByFromShape: Map<ShapeId, BindingId[]>;
+    bindingIdsByToShape: Map<ShapeId, BindingId[]>;
+    relatedBindingIdsByShape: Map<ShapeId, BindingId[]>;
+}
+type ReadEditorRecord = (id: string) => EditorRecord | undefined;
+export declare function areShapeIdArraysEqual(a: ShapeId[], b: ShapeId[]): boolean;
+export declare function compareBindings(left: BindingRecord, right: BindingRecord): number;
+export declare function buildQueryState(records: EditorRecord[]): QueryState;
+export declare function getRemovedShapeIdsFromQueryStateChange(change: StoreChange<EditorRecord>): ShapeId[];
+export declare function updateQueryStateFromStoreChange(previous: QueryState, change: StoreChange<EditorRecord>, getRecord: ReadEditorRecord): QueryState;
+export {};

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

@@ -0,0 +1,28 @@
+import { type Signal } from "../../../signals/index";
+import { Box } from "../../geometry/Box";
+import { Vec } from "../../geometry/Vec";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../Editor";
+import type { ShapeGeometry } from "../queries/shapeTransforms";
+export interface SelectionGeometrySnapshot {
+    outlineVertices: Vec[];
+    pageBounds: Box | null;
+    frameBounds: Box | null;
+    rotation: number;
+    rotationCenter: Vec | null;
+    toolbarAnchorPagePoint: Vec | null;
+    hasRotation: boolean;
+    hasCompatibleRotation: boolean;
+}
+export interface SelectionGeometrySignals {
+    geometry: Signal<SelectionGeometrySnapshot>;
+    pageOutlineVertices: Signal<Vec[]>;
+    pageBounds: Signal<Box | null>;
+    frameBounds: Signal<Box | null>;
+    hasRotation: Signal<boolean>;
+    rotation: Signal<number>;
+    rotationCenter: Signal<Vec | null>;
+    hasCompatibleRotation: Signal<boolean>;
+    toolbarAnchorPagePoint: Signal<Vec | null>;
+}
+export declare function createSelectionGeometrySignals(editor: Editor, getShapeGeometrySnapshot: (shapeId: ShapeId) => ShapeGeometry | undefined): SelectionGeometrySignals;

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/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/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/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[];