@yuzhouu/canvas-kit 0.1.12 → 0.1.14

package/_vendor/canvas-core/editor/{managers → selection}/selectionGeometry.d.ts

@@ -1,4 +1,4 @@
-import { type Signal } from "../../../signals/index";
+import type { Signal } from "../../../signals/index";
 import { Box } from "../../geometry/box";
 import { Vec } from "../../geometry/vec";
 import type { ShapeId } from "../../schema/records";
@@ -25,4 +25,4 @@ export interface SelectionGeometrySignals {
     hasCompatibleRotation: Signal<boolean>;
     selectionAnchorPagePoint: Signal<Vec | null>;
 }
-export declare function createSelectionGeometrySignals(editor: Editor, getShapeGeometrySnapshot: (shapeId: ShapeId) => ShapeGeometry | undefined): SelectionGeometrySignals;
+export declare function createSelectionGeometrySignals(editor: Editor, selectedShapeIdsSignal: Signal<ShapeId[]>, getCachedShapeGeometry: (shapeId: ShapeId) => ShapeGeometry | undefined): SelectionGeometrySignals;

package/_vendor/canvas-core/editor/selection/selectionHandleHitTest.d.ts

@@ -0,0 +1,8 @@
+import type { Vec } from "../../geometry/vec";
+import { type SelectionFrame, type SelectionHandle, type SelectionOverlayHandlesState } from "./selection";
+export declare function hitTestSelectionHandles({ point, selectionFrame, handles, hitDistance, }: {
+    point: Vec;
+    selectionFrame: SelectionFrame | null;
+    handles: SelectionOverlayHandlesState;
+    hitDistance: number;
+}): SelectionHandle | null;

package/_vendor/canvas-core/editor/selection/selectionLayout.d.ts

@@ -0,0 +1,20 @@
+import type { ChangeSource } from "../../../store/index";
+import { Box } from "../../geometry/box";
+import type { PageId } from "../../schema/records";
+import type { Editor } from "../editor";
+type AlignMode = "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom";
+type DistributeAxis = "horizontal" | "vertical";
+interface ZoomToBoundsOptions {
+    padding?: number;
+    maxZoom?: number;
+    source?: ChangeSource;
+}
+export declare function canAlignEditorSelection(editor: Editor): boolean;
+export declare function alignEditorSelection(editor: Editor, mode: AlignMode, source?: ChangeSource): boolean;
+export declare function canDistributeEditorSelection(editor: Editor): boolean;
+export declare function distributeEditorSelection(editor: Editor, axis: DistributeAxis, source?: ChangeSource): boolean;
+export declare function getEditorPageBounds(editor: Editor, pageId?: PageId): Box | null;
+export declare function zoomEditorToBounds(editor: Editor, bounds: Box, options?: ZoomToBoundsOptions): boolean;
+export declare function zoomEditorToFit(editor: Editor, options?: ZoomToBoundsOptions): boolean;
+export declare function zoomEditorToSelection(editor: Editor, options?: ZoomToBoundsOptions): boolean;
+export {};

package/_vendor/canvas-core/editor/selection/selectionOverlay.d.ts

@@ -0,0 +1,25 @@
+import { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { ShapeSelectionHandleAnchors, ShapeSelectionPathStyle } from "../../shapes/shapeUtil";
+import type { SelectionBindingMiddleHandle, SelectionBindingSegment, SelectionBindingTerminalHandle, SelectionCustomHandle, SelectionFrame, SelectionOverlayHandleAnchorsState, SelectionResizeHandle, SelectionResizeHandleId, SelectionRotateHandle } from "./selection";
+export interface SelectedShapeOverlayItem {
+    id: ShapeId;
+    usesSelectionPathOverlay: boolean;
+    startPagePoint: Vec | null;
+    endPagePoint: Vec | null;
+    middlePagePoint: Vec | null;
+    path: string | null;
+    pathStyle: ShapeSelectionPathStyle | null;
+    pageClipPath: string | null;
+    bindingSegments: readonly SelectionBindingSegment[];
+}
+export interface SelectionHandleState {
+    resizeHandles: SelectionResizeHandle[];
+    rotateHandles: SelectionRotateHandle[];
+    terminalHandles: SelectionBindingTerminalHandle[];
+    middleHandles: SelectionBindingMiddleHandle[];
+    customHandles: SelectionCustomHandle[];
+}
+export declare function isSingleSelectionPathOverlay(selectedShapeItems: SelectedShapeOverlayItem[]): boolean;
+export declare function getSelectionHandleAnchorsState(selectedShapes: ShapeRecord[], selectionFrame: SelectionFrame | null, zoom: number, getShapeSelectionHandleAnchors: (shape: ShapeRecord) => ShapeSelectionHandleAnchors, canUseSelectionResizeHandles: (shape: ShapeRecord) => boolean, canUseSelectionRotateHandle: (shape: ShapeRecord) => boolean, resizeHandleIds: readonly SelectionResizeHandleId[]): SelectionOverlayHandleAnchorsState;
+export declare function materializeSelectionHandleState(anchors: SelectionOverlayHandleAnchorsState, zoom: number): SelectionHandleState;

package/_vendor/canvas-core/editor/selection/selectionOverlayEquality.d.ts

@@ -0,0 +1,8 @@
+import type { SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandlesState } from "./selection";
+import type { SelectedShapeOverlayItem } from "./selectionOverlay";
+export declare function areSelectedShapeOverlayItemsEqual(a: SelectedShapeOverlayItem[], b: SelectedShapeOverlayItem[]): boolean;
+export declare function areSelectionOverlayFrameGeometryStatesEqual(a: SelectionOverlayFrameGeometryState | null, b: SelectionOverlayFrameGeometryState | null): boolean;
+export declare function areSelectionOverlayFrameGeometryArraysEqual(a: SelectionOverlayFrameGeometryState[], b: SelectionOverlayFrameGeometryState[]): boolean;
+export declare function areSelectionOverlayFrameStyleStatesEqual(a: SelectionOverlayFrameStyleState, b: SelectionOverlayFrameStyleState): boolean;
+export declare function areSelectionOverlayHandlesStatesEqual(a: SelectionOverlayHandlesState | null, b: SelectionOverlayHandlesState | null): boolean;
+export declare function areSelectionOverlayHandleAnchorsStatesEqual(a: SelectionOverlayHandleAnchorsState | null, b: SelectionOverlayHandleAnchorsState | null): boolean;

package/_vendor/canvas-core/editor/selection/selectionOverlayManager.d.ts

@@ -0,0 +1,34 @@
+import type { Signal } from "../../../signals/index";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { EditorToolState } from "../state/editorReadModels";
+import type { SelectionBindingSegment, SelectionHandle, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandlesState } from "./selection";
+import { type SelectedShapeOverlayItem } from "./selectionOverlay";
+interface SelectionOverlaySignals {
+    tool: Signal<EditorToolState>;
+    selectedShapeIds: Signal<ShapeRecord["id"][]>;
+    selectedShapes: Signal<ShapeRecord[]>;
+    cameraZoom: Signal<number>;
+}
+/**
+ * Selection overlay derived state: selected items, frame geometry/style,
+ * handles, hit testing, and companion frames. Editor exposes these signals
+ * through its grouped render facade.
+ */
+export declare class SelectionOverlayManager {
+    private readonly editor;
+    private readonly signals;
+    readonly selectedShapeItemsSignal: Signal<SelectedShapeOverlayItem[]>;
+    readonly frameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly companionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly pathSignal: Signal<string | null>;
+    readonly pageClipPathSignal: Signal<string | null>;
+    readonly bindingSegmentsSignal: Signal<SelectionBindingSegment[]>;
+    readonly frameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
+    readonly handleAnchorsSignal: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly handlesSignal: Signal<SelectionOverlayHandlesState | null>;
+    constructor(editor: Editor, signals: SelectionOverlaySignals);
+    hitTestHandle(point: Vec): SelectionHandle | null;
+}
+export {};

package/_vendor/canvas-core/editor/{selectionResizeCapabilities.d.ts → selection/selectionResizeCapabilities.d.ts}

@@ -1,6 +1,8 @@
-import type { ShapeRecord } from "../schema/records";
-import type { Editor } from "./editor";
+import type { ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
 import { type SelectionResizeHandleId, type SelectionResizeMode } from "./selection";
+export type SelectionResizeRotationCompatibility = "parallel" | "perpendicular";
+export declare function getSelectionResizeRotationCompatibility(left: number, right: number): SelectionResizeRotationCompatibility | null;
 export declare function areSelectionResizeRotationsCompatible(left: number, right: number): boolean;
 export declare function areSelectionResizeTargetRotationsCompatible(editor: Editor, resizeTargetShapes: readonly ShapeRecord[], selectionRotation: number): boolean;
 export declare function intersectSelectionResizeModes(modeSets: readonly (readonly SelectionResizeMode[])[]): SelectionResizeMode[];

package/_vendor/canvas-core/editor/selection/selectionSet.d.ts

@@ -0,0 +1,9 @@
+import type { ChangeSource } from "../../../store/index";
+import type { PageId, ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function setEditorSelectedShapeIds(editor: Editor, ids: ShapeId[], options?: {
+    pageId?: PageId;
+    source?: ChangeSource;
+}): void;
+export declare function removeShapeIdsFromEditorSelection(editor: Editor, ids: ShapeId[], source?: ChangeSource): void;
+export declare function selectAllEditorShapesOnCurrentPage(editor: Editor, source?: ChangeSource): void;

package/_vendor/canvas-core/editor/selection/selectionTargets.d.ts

@@ -0,0 +1,10 @@
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function getShapeIdsForSelectionTransform(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getShapeIdsForSelectionRotation(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getSelectionTransformTargetShapes(editor: Editor): ShapeRecord[];
+export declare function canResizeSelection(editor: Editor): boolean;
+export declare function canFlipSelection(editor: Editor, shapeIds?: Iterable<ShapeId>): boolean;
+export declare function canRotateSelection(editor: Editor): boolean;
+export declare function getSelectionResizeTargetShapes(editor: Editor): ShapeRecord[];
+export declare function getSelectionRotationTargetShapes(editor: Editor): ShapeRecord[];

package/_vendor/canvas-core/editor/selection/selectionTransforms.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeSelectionFlipAxis } from "../../shapes/shapeUtil";
+import type { ShapeUpdate } from "../commands/commandTypes";
+import type { Editor } from "../editor";
+export declare function resetEditorSelectionRotation(editor: Editor, source?: ChangeSource): void;
+export declare function getEditorSelectionFlipUpdates(editor: Editor, axis: ShapeSelectionFlipAxis): ShapeUpdate[];

package/_vendor/canvas-core/editor/shapes/shapeContainment.d.ts

@@ -0,0 +1,14 @@
+import type { Vec } from "../../geometry/vec";
+import { type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type ShapeGeometryQueryCache } from "../queries/shapeGeometryQueryCache";
+import type { ShapeTreeIndex } from "../queries/shapeTreeIndex";
+export type ShapeContainment = "inside" | "intersecting" | "outside";
+export interface ContainerBoundsQueryOptions {
+    includeIntersecting?: boolean;
+}
+export declare function getShapeContainment(editor: Editor, geometry: ShapeGeometryQueryCache, containerId: ShapeId, shapeId: ShapeId): ShapeContainment | null;
+export declare function getContainingShapeParentId(editor: Editor, shapeTree: ShapeTreeIndex, geometry: ShapeGeometryQueryCache, shapeIds: Iterable<ShapeId>): ShapeParentId | null;
+export declare function getContainingShapeParentIdAtPoint(editor: Editor, shapeTree: ShapeTreeIndex, geometry: ShapeGeometryQueryCache, shapeIds: Iterable<ShapeId>, point: Vec): ShapeParentId | null;
+export declare function getContainingParentIdForShapeRecord(editor: Editor, geometry: ShapeGeometryQueryCache, shape: ShapeRecord): ShapeParentId | null;
+export declare function getShapeIdsInContainerBounds(editor: Editor, containerId: ShapeId, options?: ContainerBoundsQueryOptions): ShapeId[];

package/_vendor/canvas-core/editor/{managers → shapes}/shapeEditingManager.d.ts

@@ -1,7 +1,7 @@
-import { type Signal } from "../../../signals/index";
+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 { StartEditingShapeInput } from "../commands/commandTypes";
 import type { Editor } from "../editor";
 /**
  * Shape editing lifecycle for the editor: edit-session entry, completion,

package/_vendor/canvas-core/editor/shapes/shapeExportTraversal.d.ts

@@ -0,0 +1,3 @@
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function getShapeExportTraversalIds(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];

package/_vendor/canvas-core/editor/shapes/shapeGeometry.d.ts

@@ -0,0 +1,21 @@
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import type { ShapeRecord } from "../../schema/records";
+import { type ShapeGeometry } from "../queries/shapeTransforms";
+import { type SelectionFrame } from "../selection/selection";
+import type { Editor } from "../editor";
+export declare function computeEditorShapePositionedBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeLocalBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeRenderBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeExportBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeLocalToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function computeEditorShapeRenderToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function computeEditorShapeExportToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function computeEditorShapePageBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeExportPageBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeGeometry(editor: Editor, shape: ShapeRecord): ShapeGeometry;
+export declare function computeEditorShapePositionedToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function getEditorSelectionFrame(editor: Editor): SelectionFrame | null;
+export declare function isPointInEditorSelectionBounds(editor: Editor, point: Vec): boolean;
+export declare function getEditorSelectionFrameLocalBoundsPoint(editor: Editor, point: Vec): Vec | null;

package/_vendor/canvas-core/editor/shapes/shapeGrouping.d.ts

@@ -0,0 +1,22 @@
+import type { ChangeSource } from "../../../store/index";
+import { Box } from "../../geometry/box";
+import type { ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+/** Grouping and ungrouping mutations over the physical shape tree. */
+export interface ShapeGroupState {
+    parentId: ShapeParentId;
+    shapeIds: ShapeId[];
+    /** Axis-aligned bounds of the grouped roots in their common parent's local space. */
+    parentLocalBounds: Box;
+}
+export declare function getSelectionGroupState(editor: Editor): ShapeGroupState | null;
+export declare function canGroupSelection(editor: Editor): boolean;
+export declare function canGroupShapes(editor: Editor, ids: readonly ShapeId[]): boolean;
+export declare function groupShapes(editor: Editor, ids: readonly ShapeId[], source?: ChangeSource): ShapeRecord | null;
+export declare function groupSelection(editor: Editor, source?: ChangeSource): ShapeRecord | null;
+export declare function getUngroupableSelectedShapeIds(editor: Editor): ShapeId[];
+export declare function getUngroupableShapeIds(editor: Editor, ids: readonly ShapeId[]): ShapeId[];
+export declare function canUngroupSelection(editor: Editor): boolean;
+export declare function canUngroupShapes(editor: Editor, ids: readonly ShapeId[]): boolean;
+export declare function ungroupShapes(editor: Editor, ids: readonly ShapeId[], source?: ChangeSource): ShapeId[];
+export declare function ungroupSelection(editor: Editor, source?: ChangeSource): ShapeId[];

package/_vendor/canvas-core/editor/{managers → shapes}/shapeOrder.d.ts

@@ -1,6 +1,24 @@
 import type { ChangeSource } from "../../../store/index";
-import type { ShapeId } from "../../schema/records";
-import type { Editor, LayerOrderDirection, LayerOrderEdge, ShapeSelectionSiblingOrderState, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState } from "../editor";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+import type { Editor } from "../editor";
+export type ShapeSiblingOrderDirection = "backward" | "forward";
+export type ShapeSiblingOrderEdge = "back" | "front";
+export interface ShapeSiblingOrderState {
+    parentId: ShapeParentId;
+    index: number;
+    count: number;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export interface ShapeSelectionSiblingOrderState {
+    parentId: ShapeParentId;
+    selectedCount: number;
+    count: number;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export type LayerOrderDirection = "backward" | "forward";
+export type LayerOrderEdge = "back" | "front";
 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;

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

@@ -0,0 +1,21 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type ShapeTransformFields } from "../queries/shapeTransforms";
+export type ReparentShapePlacementFailureReason = "notFound" | "locked" | "hidden" | "invalidParent" | "cycle" | "invalidBeforeId" | "unsupportedTransform";
+export type ReparentShapePlacementResult = {
+    ok: true;
+    movedIds: ShapeId[];
+} | {
+    ok: false;
+    reason: ReparentShapePlacementFailureReason;
+};
+export interface ReparentShapePlacementInput {
+    ids: readonly ShapeId[];
+    parentId: ShapeParentId;
+    beforeId?: ShapeId;
+}
+export declare function canReceiveChildren(editor: Editor, parentId: ShapeParentId): boolean;
+export declare function canReceiveChild(editor: Editor, parentId: ShapeParentId, childId: ShapeId): boolean;
+export declare function moveShapesToParentPlacementResult(editor: Editor, input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;
+export declare function getReparentedShapeTransformUpdate(editor: Editor, shape: ShapeRecord, parentId: ShapeParentId): ShapeTransformFields | null;

package/_vendor/canvas-core/editor/shapes/shapeSignalManager.d.ts

@@ -0,0 +1,35 @@
+import type { Signal } from "../../../signals/index";
+import type { Vec } from "../../geometry/vec";
+import { type ShapeEditingSession, type ShapeId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+/** Cached per-shape read signals. Editor keeps the public facade methods. */
+export declare class ShapeSignalManager {
+    private readonly editor;
+    private readonly unsubscribeFromStore;
+    private readonly shapeSignals;
+    private readonly contentCutoutLocalPolygonSignals;
+    private readonly selectedSignals;
+    private readonly renderOrderSignals;
+    private readonly renderVisibleSignals;
+    private readonly documentVisibleSignals;
+    private readonly effectiveOpacitySignals;
+    private readonly editingSessionSignals;
+    private readonly dropTargetSignals;
+    private readonly hoveredSignals;
+    private readonly selectedDescendantTransformAncestorSignals;
+    constructor(editor: Editor);
+    dispose(): void;
+    isDocumentHidden(id: ShapeId): boolean;
+    getShapeSignal(id: ShapeId): Signal<ShapeRecord | undefined>;
+    getContentCutoutLocalPolygonsSignal(id: ShapeId): Signal<readonly (readonly Vec[])[]>;
+    getSelectedSignal(id: ShapeId): Signal<boolean>;
+    getRenderOrderSignal(id: ShapeId): Signal<number>;
+    getRenderVisibleSignal(id: ShapeId): Signal<boolean>;
+    getDocumentVisibleSignal(id: ShapeId): Signal<boolean>;
+    getEffectiveOpacitySignal(id: ShapeId): Signal<number>;
+    getEditingSessionSignal(id: ShapeId): Signal<ShapeEditingSession | null>;
+    getDropTargetSignal(id: ShapeId): Signal<boolean>;
+    getHoveredSignal(id: ShapeId): Signal<boolean>;
+    getSelectedDescendantTransformAncestorSignal(id: ShapeId): Signal<boolean>;
+    private evict;
+}

package/_vendor/canvas-core/editor/{shapeTransformSpace.d.ts → shapes/shapeTransformSpace.d.ts}

@@ -1,6 +1,6 @@
-import type { ShapeRecord } from "../schema/records";
-import type { ShapeUpdate } from "./commands";
-import type { Editor } from "./editor";
+import type { ShapeRecord } from "../../schema/records";
+import type { ShapeUpdate } from "../commands/commandTypes";
+import type { Editor } from "../editor";
 export declare function getShapePageSpaceRecord(editor: Editor, shape: ShapeRecord): ShapeRecord;
 export declare function tryGetShapePageSpaceRecord(editor: Editor, shape: ShapeRecord): ShapeRecord | null;
 export declare function getShapeParentLocalUpdateFromPageSpace(editor: Editor, shape: ShapeRecord, pageShape: ShapeRecord, pageUpdate: ShapeUpdate): ShapeUpdate | null;

package/_vendor/canvas-core/editor/shapes/shapeTreeQueries.d.ts

@@ -0,0 +1,12 @@
+import { Box } from "../../geometry/box";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function isShapeOrAncestorLocked(editor: Editor, shapeId: ShapeId): boolean;
+export declare function hasLockedDescendant(editor: Editor, shapeId: ShapeId): boolean;
+export declare function getOutermostSelectableShapeId(editor: Editor, shapeId: ShapeId): ShapeId;
+export declare function getShapeIdsIncludingDescendants(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getDescendantPageBounds(editor: Editor, parentId: ShapeParentId): Box | null;
+export declare function getShapeSubtreePageBounds(editor: Editor, shapeId: ShapeId): Box | null;
+export declare function isShapeOrAncestorInSet(editor: Editor, shapeId: ShapeId, ids: ReadonlySet<ShapeId>): boolean;
+export declare function isShapeDescendantOf(editor: Editor, shapeId: ShapeId, ancestorId: ShapeId): boolean;
+export declare function isShapeDescendantOfAny(editor: Editor, shapeId: ShapeId, ancestorIds: ReadonlySet<ShapeId>): boolean;

package/_vendor/canvas-core/editor/snapping/gapSnap.d.ts

@@ -0,0 +1,6 @@
+import type { Box } from "../../geometry/box";
+import type { Gap, GapAxisSnap, GapSnapOptions } from "./snapResults";
+import type { SnapAxis, SnapNode } from "./snapTypes";
+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, options?: GapSnapOptions): GapAxisSnap | null;

package/_vendor/canvas-core/editor/snapping/pointSnap.d.ts

@@ -0,0 +1,5 @@
+import type { Vec } from "../../geometry/vec";
+import type { PointAxisSnap, PointSnapOptions } from "./snapResults";
+import type { SnapAxis, SnapPoint, SnapPointIndex } from "./snapTypes";
+export declare function buildSnapPointIndex(points: readonly SnapPoint[]): SnapPointIndex;
+export declare function getPointSnap(axis: SnapAxis, selectionPoints: Vec[], pointIndex: SnapPointIndex, threshold: number, options?: PointSnapOptions): PointAxisSnap | null;

package/_vendor/canvas-core/editor/snapping/resizeSnap.d.ts

@@ -0,0 +1,11 @@
+import type { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { SelectionResizeHandleId } from "../selection/selection";
+import type { ResizeSnapInput } from "./snapTypes";
+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;

package/_vendor/canvas-core/editor/snapping/snapDecision.d.ts

@@ -0,0 +1,2 @@
+import type { AxisSnap, AxisSnapOptions, GapAxisSnap, PointAxisSnap } from "./snapResults";
+export declare function chooseAxisSnap(pointSnap: PointAxisSnap | null, gapSnap: GapAxisSnap | null, options?: AxisSnapOptions): AxisSnap | null;

package/_vendor/canvas-core/editor/{managers → snapping}/snapGeometry.d.ts

@@ -3,7 +3,6 @@ import { Vec } from "../../geometry/vec";
 import type { SnapAxis, SnapPointKind } from "./snapTypes";
 export declare const EPSILON = 1e-8;
 export declare const BOX_SNAP_POINT_KINDS: readonly SnapPointKind[];
-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;

package/_vendor/canvas-core/editor/{managers → snapping}/snapIndicators.d.ts

@@ -1,7 +1,7 @@
 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 { GapSnapIndicatorGapState, GapSnapIndicatorState, PointSnapIndicatorState, SnapIndicatorState } from "../selection/selection";
+import type { Gap, GapAxisSnap, PointAxisSnap } from "./snapResults";
 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;

package/_vendor/canvas-core/editor/{managers → snapping}/snapManager.d.ts

@@ -1,23 +1,41 @@
-import { type Signal } from "../../../signals/index";
+import type { Signal } from "../../../signals/index";
 import type { ShapeId } from "../../schema/records";
 import type { Editor } from "../editor";
-import type { SnapIndicatorState } from "../selection";
+import type { SnapIndicatorState } from "../selection/selection";
 import type { HandleSnapInput, HandleSnapResult, HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapInput, ResizeSnapResult, ResizeSnapSnapshot, SnapCoordinateSpace, TranslateSnapInput, TranslateSnapResult, TranslateSnapSnapshot } from "./snapTypes";
+export interface SnapDiagnosticsState {
+    operation: "translate" | "resize" | "handle";
+    durationMs: number;
+    pointCount: number;
+    nodeCount: number;
+    outlineCount?: number;
+    candidatePointCount?: number;
+    candidateGapCount?: number;
+    matchedPointCount?: number;
+    xSnapId?: string | null;
+    ySnapId?: string | null;
+    indicatorCount: number;
+}
+export interface SnapDiagnostics {
+    now?(): number;
+    onEvaluation?(state: SnapDiagnosticsState): void;
+}
 export declare class SnapManager {
+    private readonly diagnostics;
     private readonly gapCache;
     private readonly _indicatorsSignal;
     readonly indicatorsSignal: Signal<SnapIndicatorState[]>;
-    readonly activeSignal: import("../../../signals/index").Computed<boolean>;
+    readonly activeSignal: Signal<boolean>;
     private readonly snapshots;
     private readonly axisSnapMemory;
-    constructor(editor: Editor);
+    constructor(editor: Editor, diagnostics?: SnapDiagnostics);
     setIndicators(indicators: SnapIndicatorState[]): void;
     clearIndicators(): void;
     private clearAxisSnapMemory;
     private getSwitchDistance;
     private getReleaseThreshold;
     private updateAxisSnapMemory;
-    private writeDebugState;
+    private reportDiagnostics;
     private getNow;
     createTranslateSnapshot({ movingShapeIds, coordinateSpace, }: {
         movingShapeIds: Iterable<ShapeId>;

package/_vendor/canvas-core/editor/{managers/snapCalculations.d.ts → snapping/snapResults.d.ts}

@@ -1,8 +1,6 @@
-import { Box } from "../../geometry/box";
-import { Vec } from "../../geometry/vec";
+import type { Vec } from "../../geometry/vec";
 import type { ShapeId } from "../../schema/records";
-import type { SelectionResizeHandleId } from "../selection";
-import type { ResizeSnapInput, SnapAxis, SnapNode, SnapPointIndex, SnapPoint, SnapPointKind } from "./snapTypes";
+import type { SnapNode, SnapPointKind } from "./snapTypes";
 export interface PointSnapPair {
     selectionPoint: Vec;
     selectionPointKind?: SnapPointKind;
@@ -58,16 +56,3 @@ export interface PointSnapStats {
     candidatePointCount: number;
     matchedPointCount: number;
 }
-export declare function buildSnapPointIndex(points: readonly SnapPoint[]): SnapPointIndex;
-export declare function getPointSnap(axis: SnapAxis, selectionPoints: Vec[], pointIndex: SnapPointIndex, threshold: number, options?: PointSnapOptions): 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, options?: GapSnapOptions): GapAxisSnap | null;
-export declare function chooseAxisSnap(pointSnap: PointAxisSnap | null, gapSnap: GapAxisSnap | null, options?: AxisSnapOptions): AxisSnap | null;

package/_vendor/canvas-core/editor/{managers → snapping}/snapTypes.d.ts

@@ -1,7 +1,7 @@
 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";
+import type { SelectionHandle, SelectionResizeHandleId, SnapIndicatorState } from "../selection/selection";
 export type SnapAxis = "x" | "y";
 export type HandleSnapMode = "none" | "point" | "align";
 export type SnapPointKind = "corner" | "edge_midpoint" | "center" | "custom";

package/_vendor/canvas-core/editor/state/editorReadModels.d.ts

@@ -0,0 +1,34 @@
+import type { Box } from "../../geometry/box";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeEditingSession, ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+export interface ShapeTreeSnapshotEntry {
+    id: ShapeId;
+    parentId: ShapeParentId;
+    type: ShapeRecord["type"];
+}
+export interface EditorToolState {
+    activeToolId: string;
+    isToolLocked: boolean;
+}
+export interface EditorShapeEditingState {
+    editingShapeId: ShapeId | null;
+    session: ShapeEditingSession | null;
+}
+export interface EditorSelectionState {
+    count: number;
+    singleShapeType: ShapeRecord["type"] | null;
+    commonShapeType: ShapeRecord["type"] | null;
+    canFlipSelection: boolean;
+    hasPointHandleSelection: boolean;
+    hasFrameSelection: boolean;
+    isMixedFrameAndPointHandleSelection: boolean;
+    canDragPointHandles: boolean;
+    hasSelectionRotation: boolean;
+    hasMixedSelectionRotation: boolean;
+    canResetSelectionRotation: boolean;
+    frameBounds: Box | null;
+    frameRotation: number;
+    frameRotationCenter: Vec | null;
+    selectionAnchorPagePoint: Vec | null;
+}
+export type EditorSelectionMetadata = Omit<EditorSelectionState, "frameBounds" | "frameRotation" | "frameRotationCenter" | "selectionAnchorPagePoint">;

package/_vendor/canvas-core/editor/state/editorSignals.d.ts

@@ -0,0 +1,82 @@
+import type { Signal } from "../../../signals/index";
+import type { Box } from "../../geometry/box";
+import type { Mat } from "../../geometry/mat";
+import type { Vec } from "../../geometry/vec";
+import type { Camera, PageId, PageRecord, SessionRecord, ShapeEditingEntryRequest, ShapeEditingSession, ShapeId, ShapeRecord } from "../../schema/records";
+import type { HistoryState } from "../history/historyManager";
+import type { BindingPreviewState, SelectionBindingSegment, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandlesState, SnapIndicatorState, TerminalBindingGuideState } from "../selection/selection";
+import type { SelectedShapeOverlayItem } from "../selection/selectionOverlay";
+import type { RenderItem } from "../viewport/renderWindow";
+import type { EditorSelectionMetadata, EditorSelectionState, EditorShapeEditingState, EditorToolState, ShapeTreeSnapshotEntry } from "./editorReadModels";
+export interface EditorStateSignals {
+    readonly readonly: Signal<boolean>;
+    readonly session: Signal<SessionRecord>;
+    readonly pages: Signal<PageRecord[]>;
+    readonly currentPageId: Signal<PageId>;
+    readonly currentPageShapeIds: Signal<ShapeId[]>;
+    readonly currentPageShapes: Signal<ShapeRecord[]>;
+    readonly currentPageShapeTree: Signal<ShapeTreeSnapshotEntry[]>;
+    readonly tool: Signal<EditorToolState>;
+    readonly editingShapeId: Signal<ShapeId | null>;
+    readonly shapeEditingSession: Signal<ShapeEditingSession | null>;
+    readonly shapeEditing: Signal<EditorShapeEditingState>;
+    readonly shapeEditingEntryRequest: Signal<ShapeEditingEntryRequest | null>;
+    readonly selectedShapeIds: Signal<ShapeId[]>;
+    readonly selectedShapeIdSet: Signal<Set<ShapeId>>;
+    readonly selectedShapes: Signal<ShapeRecord[]>;
+    readonly selectionCount: Signal<number>;
+    readonly selection: Signal<EditorSelectionState>;
+    readonly selectionMetadata: Signal<EditorSelectionMetadata>;
+    readonly selectionPageBounds: Signal<Box | null>;
+    readonly selectionFrameBounds: Signal<Box | null>;
+    readonly selectionAnchorPagePoint: Signal<Vec | null>;
+    readonly camera: Signal<Camera>;
+    readonly cameraZoom: Signal<number>;
+    readonly pageTransform: Signal<Mat>;
+    readonly viewportScreenSize: Signal<{
+        w: number;
+        h: number;
+    }>;
+    readonly viewportPageBounds: Signal<Box | null>;
+    readonly history: Signal<HistoryState>;
+}
+export interface EditorRenderViewportSignals {
+    readonly pageBounds: Signal<Box | null>;
+    readonly items: Signal<RenderItem[]>;
+    readonly shapeOrderById: Signal<Map<ShapeId, number>>;
+    readonly culledShapeIds: Signal<ShapeId[]>;
+    readonly culledShapeIdSet: Signal<Set<ShapeId>>;
+    readonly selectedShapeIdsOutsideCulled: Signal<ShapeId[]>;
+    readonly selectedShapeIdsOutsideCulledSet: Signal<Set<ShapeId>>;
+    readonly visibleShapeIds: Signal<ShapeId[]>;
+    readonly visibleShapeIdSet: Signal<Set<ShapeId>>;
+    readonly retainedShapeIds: Signal<ShapeId[]>;
+}
+export interface EditorRenderOverlaySignals {
+    readonly selectedShapeItems: Signal<SelectedShapeOverlayItem[]>;
+    readonly frameGeometry: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly companionFrameGeometries: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly path: Signal<string | null>;
+    readonly pageClipPath: Signal<string | null>;
+    readonly bindingSegments: Signal<SelectionBindingSegment[]>;
+    readonly frameStyle: Signal<SelectionOverlayFrameStyleState>;
+    readonly handleAnchors: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly handles: Signal<SelectionOverlayHandlesState | null>;
+}
+export interface EditorRenderInteractionSignals {
+    readonly brushBox: Signal<Box | null>;
+    readonly brushBoxActive: Signal<boolean>;
+    readonly bindingPreview: Signal<BindingPreviewState | null>;
+    readonly bindingPreviewActive: Signal<boolean>;
+    readonly terminalBindingGuides: Signal<TerminalBindingGuideState[]>;
+    readonly dropTargetShapeId: Signal<ShapeId | null>;
+    readonly hoveredShapeId: Signal<ShapeId | null>;
+    readonly selectionTranslationActive: Signal<boolean>;
+    readonly snapIndicators: Signal<SnapIndicatorState[]>;
+    readonly snapIndicatorsActive: Signal<boolean>;
+}
+export interface EditorRenderSignals {
+    readonly viewport: EditorRenderViewportSignals;
+    readonly overlay: EditorRenderOverlaySignals;
+    readonly interaction: EditorRenderInteractionSignals;
+}

package/_vendor/canvas-core/editor/state/editorStateUtils.d.ts

@@ -0,0 +1,9 @@
+import type { ShapeRecord } from "../../schema/records";
+import type { BindingPreviewState } from "../selection/selection";
+import type { RenderItem } from "../viewport/renderWindow";
+import type { EditorSelectionMetadata } from "./editorReadModels";
+export declare function areEditorSelectionMetadataEqual(left: EditorSelectionMetadata, right: EditorSelectionMetadata): boolean;
+export declare function areBindingPreviewStatesEqual(left: BindingPreviewState | null, right: BindingPreviewState | null): boolean;
+export declare function areRenderItemsEqual(left: readonly RenderItem[], right: readonly RenderItem[]): boolean;
+export declare function getCommonShapeType(shapes: readonly ShapeRecord[]): ShapeRecord["type"] | null;
+export declare function areShapePropsPatchesEqual(left: Readonly<Record<string, unknown>>, right: Readonly<Record<string, unknown>>): boolean;