@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-image/host/index.d.ts

@@ -0,0 +1,14 @@
+export { createImageHostPlugin } from "./plugin";
+export type { ImageHostPluginOptions } from "./plugin";
+export { createImageHostApi } from "./createImageHostApi";
+export { imageHostApiToken } from "./api";
+export type { ImageHostApi, ImageHostInsertInput, ImageHostInsertSize, ImageHostInsertSource, ImageHostReplaceInput, ImageHostSmudgeConfirmPayload, ImageHostSmudgeController, } from "./api";
+export { createLocalImageAssetService } from "./asset/imageAssetService";
+export type { ImageAssetService, OwnedImageAssetService, } from "./asset/imageAssetService";
+export { cleanupUnreferencedImageBlobs, createImageObjectUrlStore, createImageStorageKey, deleteImageBlob, getAllImageBlobStorageKeys, getLocalImageAssetStorageKey, getRemoteImageAssetUrl, getReferencedImageStorageKeys, readImageBlob, readImageBlobAsDataUrl, writeImageBlob, } from "./asset/imageBlobStore";
+export type { ImageBlobWriteResult, ImageObjectUrlStore, } from "./asset/imageBlobStore";
+export { downloadSelectedImageOriginal, getFirstImageFile, insertImageIntoEditor, replaceSelectedImageFromFile, } from "./asset/imageAssetOperations";
+export type { InsertImageInput, ReplaceSelectedImageFileInput, } from "./asset/imageAssetOperations";
+export { confirmImageSmudgeSession } from "./smudge/confirm";
+export type { ConfirmImageSmudgeSessionInput } from "./smudge/confirm";
+export { createImageSvgAssetInliner } from "./export/imageSvgResourceInliner";

package/_vendor/plugin-image/host/plugin.d.ts

@@ -0,0 +1,8 @@
+import { type CanvasPlugin } from "../_vendor/canvas-extension-contracts/index";
+import { type ImageHostApi } from "./api";
+import { type OwnedImageAssetService } from "./asset/imageAssetService";
+export interface ImageHostPluginOptions {
+    readonly createAssetService?: () => OwnedImageAssetService;
+    readonly onError?: (error: unknown) => void;
+}
+export declare function createImageHostPlugin(options?: ImageHostPluginOptions): CanvasPlugin<ImageHostApi>;

package/_vendor/plugin-image/host/smudge/confirm.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../_vendor/canvas-core/index";
+import type { ImageHostSmudgeConfirmPayload } from "../api";
+import { type ImageObjectUrlStore } from "../asset/imageBlobStore";
+export interface ConfirmImageSmudgeSessionInput {
+    editor: Editor;
+    imageObjectUrls: ImageObjectUrlStore;
+    replace?: boolean;
+    signal: AbortSignal;
+}
+export declare function confirmImageSmudgeSession({ editor, imageObjectUrls, replace, signal, }: ConfirmImageSmudgeSessionInput): Promise<ImageHostSmudgeConfirmPayload | null>;

package/_vendor/plugin-image/image/api.d.ts

@@ -0,0 +1,40 @@
+import type { Editor, ShapeId } from "../_vendor/canvas-core/index";
+import { type ImageCropAspectRatioPresetValue } from "./crop/model";
+import { type ImageSmudgeBrush, type ImageSmudgeSessionSnapshot } from "./smudge/session";
+import { type ImageShapeCrop } from "./types";
+export interface ImageSelectionState {
+    readonly shapeId: ShapeId;
+    readonly cornerRadius: number;
+    readonly crop: ImageShapeCrop | null;
+    readonly cropPreset: ImageCropAspectRatioPresetValue | null;
+    readonly isCropping: boolean;
+    readonly smudge: ImageSmudgeSessionSnapshot | null;
+}
+export interface ImageStylePatch {
+    readonly cornerRadius?: number;
+}
+export interface ImageApi {
+    getSelectionState(): ImageSelectionState | null;
+    setSelectionStyle(patch: ImageStylePatch): readonly ShapeId[];
+    startCrop(shapeId?: ShapeId): boolean;
+    finishCrop(): boolean;
+    cancelCrop(): boolean;
+    zoomCrop(direction: "in" | "out"): boolean;
+    setCropAspectRatio(preset: ImageCropAspectRatioPresetValue): boolean;
+    resetCrop(): boolean;
+    smudge: {
+        start(input?: {
+            readonly shapeId?: ShapeId;
+            readonly brush?: Partial<ImageSmudgeBrush>;
+        }): boolean;
+        setBrush(brush: Partial<ImageSmudgeBrush>): boolean;
+        cancel(): void;
+        undo(): boolean;
+        redo(): boolean;
+        getSnapshot(): ImageSmudgeSessionSnapshot | null;
+    };
+}
+export declare const imageApiToken: import("../_vendor/canvas-extension-contracts/index").CanvasApiToken<ImageApi>;
+export declare function createImagePluginApi({ editor, }: {
+    editor: Editor;
+}): ImageApi;

package/_vendor/plugin-image/image/cornerRadius.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeImageCornerRadius(value: unknown, fallback?: number): number;
+export declare function getImageCornerRadiusForBounds({ cornerRadius, h, w, }: {
+    cornerRadius: unknown;
+    h: number;
+    w: number;
+}): number;

package/_vendor/plugin-image/image/crop/interactions.d.ts

@@ -0,0 +1,3 @@
+import { type LandInteractionHandler, type SelectionHandleInteractionHandler } from "../../_vendor/canvas-core/index";
+export declare function createImageCropSelectionHandleInteractionHandler(): SelectionHandleInteractionHandler;
+export declare function createImageCropInteractionHandler(): LandInteractionHandler;

package/_vendor/plugin-image/image/crop/model.d.ts

@@ -0,0 +1,112 @@
+import { Vec, type SelectionResizeHandleId, type ShapeUpdate } from "../../_vendor/canvas-core/index";
+import type { ImageShapeCrop, ImageShapeRecord } from "../types";
+export declare const IMAGE_CROP_HANDLE_TYPE = "image.crop";
+export declare const IMAGE_CROP_OPERATION_KIND_PREFIX = "image.crop:";
+export declare const IMAGE_CROP_HANDLE_OPERATION_KIND = "image.crop.handle";
+export declare const IMAGE_CROP_TRANSLATE_OPERATION_KIND = "image.crop.translate";
+export declare const IMAGE_CROP_MODE_OPERATION_KIND_PREFIX = "image.crop:edit:";
+export declare const IMAGE_CROP_ASPECT_RATIO_PRESETS: readonly [{
+    readonly label: "1:1";
+    readonly value: "1:1";
+    readonly ratio: 1;
+}, {
+    readonly label: "4:3";
+    readonly value: "4:3";
+    readonly ratio: number;
+}, {
+    readonly label: "16:9";
+    readonly value: "16:9";
+    readonly ratio: number;
+}];
+export type ImageCropAspectRatioPresetValue = (typeof IMAGE_CROP_ASPECT_RATIO_PRESETS)[number]["value"];
+export interface ImageCropRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export interface ImageCropPlacement {
+    imageX: number;
+    imageY: number;
+    imageWidth: number;
+    imageHeight: number;
+    rect: ImageCropRect;
+}
+export interface ImageCropCustomHandleAnchor {
+    kind: "custom";
+    type: typeof IMAGE_CROP_HANDLE_TYPE;
+    id: SelectionResizeHandleId;
+    point: Vec;
+    cursor: string;
+}
+interface UncroppedImageSpace {
+    w: number;
+    h: number;
+}
+export declare function normalizeImageShapeCrop(value: unknown): ImageShapeCrop | null;
+export declare function getImageCropRect(crop: ImageShapeCrop | null | undefined): ImageCropRect | null;
+export declare function getDefaultImageCrop(): ImageShapeCrop;
+export declare function getImageCropRectOrDefault(crop: ImageShapeCrop | null | undefined): ImageCropRect;
+export declare function getUncroppedImageSize({ crop, shape, }: {
+    crop: ImageShapeCrop | null | undefined;
+    shape: ImageShapeRecord;
+}): UncroppedImageSpace;
+export declare function getImageCropAspectRatioPresetValue(shape: ImageShapeRecord): ImageCropAspectRatioPresetValue | null;
+export declare function isImageCropModeForShape(shape: ImageShapeRecord, operationKind: string | null | undefined): boolean;
+export declare function getImageCropModeOperationKind(shapeId: ImageShapeRecord["id"]): string;
+export declare function getImageCropHandleIds(): readonly SelectionResizeHandleId[];
+export declare function isImageCropHandleId(value: string): value is SelectionResizeHandleId;
+export declare function getImageCropHandleCursor(handleId: SelectionResizeHandleId): string;
+export declare function getImageCropHandleAnchors({ localToPage, shape, }: {
+    crop: ImageShapeCrop | null | undefined;
+    localToPage: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+}): ImageCropCustomHandleAnchor[];
+export declare function getImageCropUpdateFromHandleDrag({ handleId, pageToLocal, shape, startCrop, startPagePoint, currentPagePoint, }: {
+    handleId: SelectionResizeHandleId;
+    pageToLocal: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+    startPagePoint: Vec;
+    currentPagePoint: Vec;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromContentDrag({ currentPagePoint, pageToLocal, shape, startCrop, startPagePoint, shiftKey, }: {
+    currentPagePoint: Vec;
+    pageToLocal: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+    startPagePoint: Vec;
+    shiftKey: boolean;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromContentNudge({ pageDelta, shape, startCrop, }: {
+    pageDelta: Vec;
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromZoom({ direction, shape, }: {
+    direction: "in" | "out";
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromAspectRatioPreset({ preset, shape, }: {
+    preset: ImageCropAspectRatioPresetValue;
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropResetUpdate({ baselineShape, shape, }: {
+    baselineShape: ImageShapeRecord;
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropPlacement({ crop, shapeHeight, shapeWidth, }: {
+    crop: ImageShapeCrop | null | undefined;
+    shapeHeight: number;
+    shapeWidth: number;
+}): ImageCropPlacement | null;
+export declare function formatImageCropViewBox(rect: ImageCropRect): string;
+export {};

package/_vendor/plugin-image/image/crop/session.d.ts

@@ -0,0 +1,6 @@
+import { type Editor } from "../../_vendor/canvas-core/index";
+import type { ImageShapeRecord } from "../types";
+export declare function rememberImageCropSessionBaseline(editor: Editor, shape: ImageShapeRecord): void;
+export declare function getImageCropSessionBaseline(editor: Editor, shapeId: ImageShapeRecord["id"]): ImageShapeRecord | null;
+export declare function clearImageCropSessionBaseline(editor: Editor, shapeId: ImageShapeRecord["id"]): void;
+export declare function setupImageCropSessionLifecycle(editor: Editor): () => void;

package/_vendor/plugin-image/image/editor/imageShapeUtil.d.ts

@@ -0,0 +1,13 @@
+import { Box, ShapeUtil, type ShapeEditEndInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionResizeModesInput } from "../../_vendor/canvas-core/index";
+import type { ImageShapeProps, ImageShapeRecord } from "../types";
+export declare class ImageShapeUtil extends ShapeUtil<ImageShapeRecord> {
+    readonly type: "image";
+    getDefaultProps(): ImageShapeProps;
+    validateProps(props: unknown): ImageShapeProps;
+    getLocalBounds(shape: ImageShapeRecord): Box;
+    canReceiveTerminalBinding(_shape: ImageShapeRecord): boolean;
+    getAllowedSelectionResizeModes(_shape: ImageShapeRecord, _input: ShapeSelectionResizeModesInput): readonly ["aspect_ratio_locked"];
+    canEdit(_shape: ImageShapeRecord): boolean;
+    onEditEnd(shape: ImageShapeRecord, input: ShapeEditEndInput): void;
+    getSelectionHandleAnchors(shape: ImageShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+}

package/_vendor/plugin-image/image/editor/imageSvgExporter.d.ts

@@ -0,0 +1,6 @@
+import type { ShapeSvgExporter, SvgExportContext, SvgNode } from "../../_vendor/canvas-core/index";
+import type { ImageShapeRecord } from "../types";
+export declare class ImageShapeSvgExporter implements ShapeSvgExporter<ImageShapeRecord> {
+    readonly type: "image";
+    toSvg(shape: ImageShapeRecord, context: SvgExportContext): SvgNode | null;
+}

package/_vendor/plugin-image/image/editor/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { EditorPlugin } from "../../_vendor/canvas-core/index";
+export { ImageShapeSvgExporter } from "./imageSvgExporter";
+export declare function createImageEditorPlugin(): EditorPlugin;

package/_vendor/plugin-image/image/index.d.ts

@@ -0,0 +1,14 @@
+export { ImageShapeSvgExporter, createImageEditorPlugin, } from "./editor/plugin";
+export { createImageCanvasRenderPlugin } from "./render/plugin";
+export { createImageCropInteractionHandler, createImageCropSelectionHandleInteractionHandler, } from "./crop/interactions";
+export { createImageSmudgeInteractionHandler } from "./smudge/interactions";
+export { IMAGE_CROP_ASPECT_RATIO_PRESETS, getImageCropModeOperationKind, getImageCropRectOrDefault, } from "./crop/model";
+export type { ImageCropRect } from "./crop/model";
+export { DEFAULT_IMAGE_SMUDGE_BRUSH_COLOR, DEFAULT_IMAGE_SMUDGE_BRUSH_SIZE, IMAGE_SMUDGE_BRUSH_SIZE_MAX, IMAGE_SMUDGE_BRUSH_SIZE_MIN, cancelImageSmudgeSession, cancelImageSmudgeSessionIfActive, cloneImageSmudgeStrokes, completeImageSmudgeSession, getActiveImageSmudgeSession, getImageSmudgeModeOperationKind, isImageSmudgeModeForShape, registerImageSmudgeConfirmHandler, redoImageSmudgeStroke, requestImageSmudgeConfirm, startImageSmudgeSession, undoImageSmudgeStroke, updateImageSmudgeBrush, } from "./smudge/session";
+export type { ImageSmudgeBrush, ImageSmudgeSessionSnapshot, ImageSmudgeStroke, ImageSmudgeStrokePoint, } from "./smudge/session";
+export { Image } from "./plugin";
+export { imageApiToken } from "./api";
+export type { ImageApi, ImageSelectionState, ImageStylePatch, } from "./api";
+export { ImageShapeUtil } from "./editor/imageShapeUtil";
+export type { ImageAssetProps, ImageAssetRecord, ImageAssetSource, ImageShapeCrop, ImageShapeProps, ImageShapeRecord, } from "./types";
+export { isImageAssetRecord, isImageShapeRecord } from "./types";

package/_vendor/plugin-image/image/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { CanvasPlugin } from "@yuzhouu/canvas-kit";
+import type { ImageApi } from "./api";
+export declare const Image: CanvasPlugin<ImageApi>;

package/_vendor/plugin-image/image/render/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type CanvasRenderPlugin } from "../../_vendor/canvas-react/host/index";
+export declare function createImageCanvasRenderPlugin(): CanvasRenderPlugin;

package/_vendor/plugin-image/image/smudge/interactions.d.ts

@@ -0,0 +1,2 @@
+import { type LandInteractionHandler } from "../../_vendor/canvas-core/index";
+export declare function createImageSmudgeInteractionHandler(): LandInteractionHandler;

package/_vendor/plugin-image/image/smudge/session.d.ts

@@ -0,0 +1,61 @@
+import { type Editor, type ShapeId } from "../../_vendor/canvas-core/index";
+import type { ImageShapeRecord } from "../types";
+export declare const IMAGE_SMUDGE_OPERATION_KIND_PREFIX = "image.smudge:";
+export declare const IMAGE_SMUDGE_MODE_OPERATION_KIND_PREFIX = "image.smudge:edit:";
+export declare const DEFAULT_IMAGE_SMUDGE_BRUSH_SIZE = 24;
+export declare const DEFAULT_IMAGE_SMUDGE_BRUSH_COLOR = "#ffff00";
+export declare const IMAGE_SMUDGE_BRUSH_SIZE_MIN = 1;
+export declare const IMAGE_SMUDGE_BRUSH_SIZE_MAX = 128;
+export interface ImageSmudgeBrush {
+    size: number;
+    color?: string;
+    opacity?: number;
+}
+export interface ImageSmudgeStrokePoint {
+    x: number;
+    y: number;
+    pressure?: number;
+}
+export interface ImageSmudgeStroke {
+    id: string;
+    points: ImageSmudgeStrokePoint[];
+    brush: ImageSmudgeBrush;
+}
+export interface ImageSmudgeConfirmInput {
+    replace?: boolean;
+}
+export type ImageSmudgeSessionSnapshot = Readonly<{
+    shapeId: ShapeId;
+    brush: ImageSmudgeBrush;
+    strokes: readonly ImageSmudgeStroke[];
+    canUndo: boolean;
+    canRedo: boolean;
+}>;
+type ImageSmudgeSubscriber = () => void;
+type ImageSmudgeConfirmHandler = (input?: ImageSmudgeConfirmInput) => Promise<unknown>;
+export declare function getImageSmudgeModeOperationKind(shapeId: ShapeId): string;
+export declare function isImageSmudgeModeForShape(shape: ImageShapeRecord, operationKind: string | null | undefined): boolean;
+export declare function normalizeImageSmudgeBrush(brush?: Partial<ImageSmudgeBrush>): ImageSmudgeBrush;
+export declare function startImageSmudgeSession({ brush, editor, shape, }: {
+    brush?: Partial<ImageSmudgeBrush>;
+    editor: Editor;
+    shape: ImageShapeRecord;
+}): boolean;
+export declare function cancelImageSmudgeSession(editor: Editor): void;
+export declare function completeImageSmudgeSession(editor: Editor): void;
+export declare function cancelImageSmudgeSessionIfActive(editor: Editor): boolean;
+export declare function clearImageSmudgeSessionForShape(editor: Editor, shapeId: ShapeId): void;
+export declare function updateImageSmudgeBrush(editor: Editor, brush: Partial<ImageSmudgeBrush>): boolean;
+export declare function getImageSmudgeSessionSnapshot(editor: Editor, shapeId: ShapeId): ImageSmudgeSessionSnapshot | null;
+export declare function getActiveImageSmudgeSession(editor: Editor): ImageSmudgeSessionSnapshot | null;
+export declare function subscribeImageSmudgeSession(editor: Editor, subscriber: ImageSmudgeSubscriber): () => void;
+export declare function beginImageSmudgeStroke(editor: Editor, point: ImageSmudgeStrokePoint): void;
+export declare function appendImageSmudgeStrokePoint(editor: Editor, point: ImageSmudgeStrokePoint): void;
+export declare function endImageSmudgeStroke(editor: Editor): void;
+export declare function cancelImageSmudgeStroke(editor: Editor): void;
+export declare function undoImageSmudgeStroke(editor: Editor): boolean;
+export declare function redoImageSmudgeStroke(editor: Editor): boolean;
+export declare function registerImageSmudgeConfirmHandler(editor: Editor, handler: ImageSmudgeConfirmHandler): () => void;
+export declare function requestImageSmudgeConfirm(editor: Editor, input?: ImageSmudgeConfirmInput): Promise<unknown>;
+export declare function cloneImageSmudgeStrokes(strokes: readonly ImageSmudgeStroke[]): ImageSmudgeStroke[];
+export {};

package/_vendor/plugin-image/image/types.d.ts

@@ -0,0 +1,46 @@
+import { type AssetId, type AssetRecordBase, type BaseRecord, type ShapeRecordBase } from "../_vendor/canvas-core/index";
+export type ImageAssetSource = {
+    kind: "local";
+    storageKey: string;
+    originalUrl?: string;
+} | {
+    kind: "remote";
+    url: string;
+};
+export interface ImageAssetProps {
+    w: number;
+    h: number;
+    name: string;
+    source: ImageAssetSource;
+    mimeType: string | null;
+    fileSize?: number;
+    isAnimated: boolean;
+}
+export interface ImageAssetRecord extends AssetRecordBase<"image", ImageAssetProps> {
+    type: "image";
+    props: ImageAssetProps;
+}
+export interface ImageShapeCrop {
+    topLeft: {
+        x: number;
+        y: number;
+    };
+    bottomRight: {
+        x: number;
+        y: number;
+    };
+}
+export interface ImageShapeProps {
+    w: number;
+    h: number;
+    assetId: AssetId | null;
+    crop: ImageShapeCrop | null;
+    cornerRadius: number;
+    altText: string;
+}
+export interface ImageShapeRecord extends ShapeRecordBase<"image", ImageShapeProps> {
+    type: "image";
+    props: ImageShapeProps;
+}
+export declare function isImageAssetRecord(record: BaseRecord | null | undefined): record is ImageAssetRecord;
+export declare function isImageShapeRecord(record: BaseRecord | null | undefined): record is ImageShapeRecord;

package/_vendor/plugin-image/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./image";
+export * from "./host";

package/_vendor/plugin-laser/_vendor/canvas-core/bindings/bindingManager.d.ts

@@ -0,0 +1,33 @@
+import type { ChangeSource } from "../../store/index";
+import { type BindingId, type BindingRecord, type ShapeId, type ShapeRecord } from "../schema/records";
+import type { Editor } from "../editor/editor";
+declare const SYNCHRONOUS_CALLBACK_ERROR = "Binding reaction scope callbacks must be synchronous";
+type SynchronousCallbackGuard<T> = T extends PromiseLike<unknown> ? [error: typeof SYNCHRONOUS_CALLBACK_ERROR] : [];
+export interface ShapeChangeEntry {
+    before: ShapeRecord;
+    after: ShapeRecord;
+}
+export declare class BindingManager {
+    private readonly editor;
+    private suppressedReactionIds;
+    constructor(editor: Editor);
+    getSuppressedReactionIds(): ReadonlySet<BindingId>;
+    runWithSuppressedReactions<T>(bindingIds: Iterable<BindingId>, callback: () => T, ..._synchronousCallbackGuard: SynchronousCallbackGuard<T>): T;
+    getConflictingBindings(binding: BindingRecord): BindingRecord[];
+    canBind(binding: BindingRecord): boolean;
+    syncCreatedBinding(binding: BindingRecord, source: ChangeSource): void;
+    syncUpdatedBinding(before: BindingRecord, after: BindingRecord, source: ChangeSource): void;
+    repairLoadedBindings(source: ChangeSource): void;
+    handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource): void;
+    getShapeCompanionRootId(shapeId: ShapeId): ShapeId;
+    getShapeCompanionRootIds(shapeIds: readonly ShapeId[], bindings?: readonly BindingRecord[]): ReadonlyMap<ShapeId, ShapeId>;
+    getShapeCompanionMemberIds(shapeIds: readonly ShapeId[]): ShapeId[];
+    cleanupBindingsForDeletedShapes(ids: ShapeId[], source: ChangeSource): void;
+    cleanupBindings(ids: BindingId[], source: ChangeSource): void;
+    private applyEffect;
+    private syncShapeCompanionState;
+    private getShapeCompanionContext;
+    private getAllBindings;
+    private getExclusiveBindingKey;
+}
+export {};

package/_vendor/plugin-laser/_vendor/canvas-core/bindings/bindingUtil.d.ts

@@ -0,0 +1,69 @@
+import type { Editor } from "../editor/editor";
+import type { SelectionOverlayFrameGeometryState } from "../editor/selection/selection";
+import type { Vec } from "../geometry/vec";
+import type { BindingId, BindingRecord, BindingRecordBase, ShapeRecord } from "../schema/records";
+export interface BindingUtilEffect {
+    shapes?: ShapeRecord[];
+    bindings?: BindingRecord[];
+    deleteShapeIds?: ShapeRecord["id"][];
+    deleteBindingIds?: BindingId[];
+    /** Suppress these bindings while applying this effect and its derived writes. */
+    suppressBindingIds?: BindingId[];
+}
+export interface BindingShapeChangeContext {
+    before: ShapeRecord;
+    after: ShapeRecord;
+    role: "from" | "to";
+    reason: "self" | "ancestry";
+}
+export interface BindingShapeDeleteContext {
+    shape: ShapeRecord;
+    role: "from" | "to";
+}
+export interface BindingEndpointContext {
+    fromShape: ShapeRecord;
+    toShape: ShapeRecord;
+}
+export interface BindingSelectionCompanionFrameContext {
+    selectedShape: ShapeRecord;
+}
+export interface BindingShapeGeometryDependencyContext {
+    shape: ShapeRecord;
+    role: "from" | "to";
+}
+export interface BindingTargetShapeContentCutoutContext {
+    fromShape: ShapeRecord;
+    toShape: ShapeRecord;
+}
+export declare abstract class BindingUtil<B extends BindingRecordBase = BindingRecordBase> {
+    abstract readonly type: B["type"];
+    abstract getDefaultProps(): B["props"];
+    abstract validateProps(props: unknown): B["props"];
+    canBind?(editor: Editor, binding: B, context: BindingEndpointContext): boolean;
+    getExclusiveBindingKey?(binding: B): string | null;
+    onBindingCreate?(editor: Editor, binding: B): BindingUtilEffect | void;
+    onBindingUpdate?(editor: Editor, before: B, after: B): BindingUtilEffect | void;
+    onBindingLoad?(editor: Editor, binding: B): BindingUtilEffect | void;
+    onInvalidBindingLoad?(editor: Editor, binding: B): BindingUtilEffect | void;
+    onAfterShapeChange?(editor: Editor, binding: B, context: BindingShapeChangeContext): BindingUtilEffect | void;
+    onBeforeDeleteShape?(editor: Editor, binding: B, context: BindingShapeDeleteContext): BindingUtilEffect | void;
+    onBeforeDeleteBinding?(editor: Editor, binding: B): BindingUtilEffect | void;
+    getExportShapeIds?(editor: Editor, binding: B): ShapeRecord["id"][];
+    /**
+     * Map a companion shape (for example, a bound label) to the owner shape that
+     * controls its grouping lifecycle and selection semantics.
+     */
+    getShapeCompanionRootId?(binding: B, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
+    canUseShapeCompanion?(binding: B, context: BindingEndpointContext): boolean;
+    getGeometryDependentShapeIds?(editor: Editor, binding: B, context: BindingShapeGeometryDependencyContext): ShapeRecord["id"][];
+    /**
+     * Return polygons in the target shape's local space that should be removed
+     * from its rendered content. This lets a binding-owned companion such as a
+     * text label create a transparent gap without coupling the target plugin to
+     * the companion shape implementation.
+     */
+    getTargetShapeContentCutoutLocalPolygons?(editor: Editor, binding: B, context: BindingTargetShapeContentCutoutContext): readonly (readonly Vec[])[];
+    getSelectionCompanionFrameGeometries?(editor: Editor, binding: B, context: BindingSelectionCompanionFrameContext): SelectionOverlayFrameGeometryState[];
+}
+export declare function resolveShapeCompanionRootId(shapeId: ShapeRecord["id"], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ShapeRecord["id"];
+export declare function resolveShapeCompanionRootIds(shapeIds: readonly ShapeRecord["id"][], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ReadonlyMap<ShapeRecord["id"], ShapeRecord["id"]>;

package/_vendor/plugin-laser/_vendor/canvas-core/bindings/bindingUtilRegistry.d.ts

@@ -0,0 +1,8 @@
+import type { BindingRecordBase } from "../schema/records";
+import { BindingUtil } from "./bindingUtil";
+export declare class BindingUtilRegistry {
+    private readonly registry;
+    register<B extends BindingRecordBase>(util: BindingUtil<B>): void;
+    values(): IterableIterator<BindingUtil>;
+    get<B extends BindingRecordBase>(type: B["type"]): BindingUtil<B>;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/bindings/terminalBinding.d.ts

@@ -0,0 +1,28 @@
+import { Vec } from "../geometry/vec";
+import type { Editor } from "../editor/editor";
+import type { BindingPreviewState } from "../editor/selection/selection";
+import type { ShapeId } from "../schema/records";
+export interface ConnectionPoint {
+    x: number;
+    y: number;
+}
+export type ConnectionTerminal = "start" | "end";
+export interface TerminalBindingTargetInput {
+    targetShapeId: ShapeId;
+    normalizedAnchor: ConnectionPoint;
+}
+export interface ResolvedTerminalBinding {
+    pagePoint: Vec;
+    binding: TerminalBindingTargetInput | null;
+    preview: BindingPreviewState | null;
+}
+export interface TerminalBindingResolverInput {
+    terminal: ConnectionTerminal;
+    rawPagePoint: Vec;
+    oppositePagePoint: Vec;
+    excludeShapeId?: ShapeId;
+    ignoreTargets?: boolean;
+}
+export type TerminalBindingResolver = (editor: Editor, input: TerminalBindingResolverInput) => ResolvedTerminalBinding;
+export declare function getFreeTerminalBinding({ rawPagePoint, }: TerminalBindingResolverInput): ResolvedTerminalBinding;
+export declare function resolveTerminalBindingAtPoint(editor: Editor, input: TerminalBindingResolverInput): ResolvedTerminalBinding;

package/_vendor/plugin-laser/_vendor/canvas-core/bindings/terminalPorts.d.ts

@@ -0,0 +1,67 @@
+import type { Editor } from "../editor/editor";
+import { Vec } from "../geometry/vec";
+import type { ShapeRecord } from "../schema/records";
+export type TerminalBindingPortId = "top" | "right" | "bottom" | "left" | (string & {});
+export interface ShapeTerminalBindingPort {
+    id: TerminalBindingPortId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    outwardNormal: {
+        x: number;
+        y: number;
+    };
+}
+export interface ResolvedShapeTerminalBindingPort {
+    id: TerminalBindingPortId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    pagePoint: Vec;
+    pageOutwardNormal: Vec;
+}
+export declare const DEFAULT_TERMINAL_BINDING_PORTS: readonly [{
+    readonly id: "top";
+    readonly normalizedAnchor: {
+        readonly x: 0.5;
+        readonly y: 0;
+    };
+    readonly outwardNormal: {
+        readonly x: 0;
+        readonly y: -1;
+    };
+}, {
+    readonly id: "right";
+    readonly normalizedAnchor: {
+        readonly x: 1;
+        readonly y: 0.5;
+    };
+    readonly outwardNormal: {
+        readonly x: 1;
+        readonly y: 0;
+    };
+}, {
+    readonly id: "bottom";
+    readonly normalizedAnchor: {
+        readonly x: 0.5;
+        readonly y: 1;
+    };
+    readonly outwardNormal: {
+        readonly x: 0;
+        readonly y: 1;
+    };
+}, {
+    readonly id: "left";
+    readonly normalizedAnchor: {
+        readonly x: 0;
+        readonly y: 0.5;
+    };
+    readonly outwardNormal: {
+        readonly x: -1;
+        readonly y: 0;
+    };
+}];
+export declare function getResolvedShapeTerminalBindingPorts(editor: Editor, shape: ShapeRecord): ResolvedShapeTerminalBindingPort[];
+export declare function getResolvedShapeTerminalBindingPort(editor: Editor, shape: ShapeRecord, portId: TerminalBindingPortId): ResolvedShapeTerminalBindingPort | null;

package/_vendor/plugin-laser/_vendor/canvas-core/editor/clipboard.d.ts

@@ -0,0 +1,43 @@
+import type { ChangeSource } from "../../store/index";
+import { Vec } from "../geometry/vec";
+import type { AssetId, AssetRecord, BindingRecord, ShapeId, ShapeRecord } from "../schema/records";
+import type { Editor } from "./editor";
+export interface EditorClipboardPayload {
+    type: "land/clipboard";
+    version: 2;
+    source: {
+        app: "land";
+        documentId?: string;
+    };
+    rootShapeIds: readonly ShapeId[];
+    records: {
+        shapes: readonly ShapeRecord[];
+        bindings: readonly BindingRecord[];
+        assets: readonly AssetRecord[];
+    };
+    bounds: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+export interface ClipboardAssetSidecar {
+    assetId: AssetId;
+    kind: "local-image-blob";
+    storageKey: string;
+}
+export interface PasteClipboardPayloadInput {
+    payload: EditorClipboardPayload;
+    pagePoint?: Vec;
+    offset?: Vec;
+    source?: ChangeSource;
+}
+export interface DuplicateSelectionInput {
+    offset?: Vec;
+    source?: ChangeSource;
+}
+export declare function isEditorClipboardPayload(value: unknown): value is EditorClipboardPayload;
+export declare function createEditorClipboardPayloadFromSelection(editor: Editor): EditorClipboardPayload | null;
+export declare function pasteEditorClipboardPayload(editor: Editor, input: PasteClipboardPayloadInput): ShapeId[];
+export declare function duplicateEditorSelection(editor: Editor, input?: DuplicateSelectionInput): ShapeId[];

package/_vendor/plugin-laser/_vendor/canvas-core/editor/clipboardAssets.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from "./editor";
+import type { AssetId, AssetRecord, ShapeRecord } from "../schema/records";
+export declare function getClipboardAssets(editor: Editor, shapes: readonly ShapeRecord[]): AssetRecord[];
+export declare function remapAssetIdsInRecord(record: object, assetIdMap: ReadonlyMap<AssetId, AssetId>): Record<string, unknown>;
+export declare function cloneRecordObject(value: object): Record<string, unknown>;
+export declare function cloneSerializableRecord<T>(value: T): T;