@yuzhouu/canvas-kit 0.1.2 → 0.1.3

package/_vendor/plugin-draw/drawGeometry.ts

@@ -1,491 +0,0 @@
-import { Box, Vec } from "@land/canvas-core";
-import {
-  getDrawSegmentsFromPoints,
-  getFlattenedDrawSegmentPoints,
-} from "./drawPath";
-import {
-  cloneDrawSegments,
-  mapDrawSegmentCoordinates,
-  mapDrawShapeSegmentsToBounds,
-  translateDrawSegments,
-} from "./drawSegments";
-import {
-  mapPageDrawSegmentsToSelectionLocal,
-  mapSelectionLocalDrawSegmentsToPage,
-  mirrorSelectionLocalDrawSegments,
-  type DrawSelectionFlipInput,
-  type DrawSelectionResizeInput,
-} from "./drawSelectionTransform";
-import {
-  createDrawGeometryFromDerivedData,
-  createTranslatedDrawGeometry,
-  getDrawPointGeometry,
-  getDrawSegmentGeometry,
-  type DrawShapeGeometry,
-  type DrawShapeSamplingStats,
-} from "./drawShapeGeometry";
-import type {
-  DrawShapePoint,
-  DrawShapeProps,
-  DrawShapeRecord,
-  DrawShapeSegment,
-} from "./types";
-
-export { getDrawPointGeometry, getDrawSegmentGeometry };
-export type {
-  DrawShapeGeometry,
-  DrawShapeSamplingStats,
-} from "./drawShapeGeometry";
-
-type DrawLocalGeometryCacheKey = Pick<DrawShapeRecord, "props">;
-type DrawPositionedGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "props">;
-type DrawPageGeometryCacheKey = Pick<
-  DrawShapeRecord,
-  "x" | "y" | "rotation" | "scaleX" | "scaleY" | "props"
->;
-
-export interface DrawShapeDiagnostics extends DrawShapeSamplingStats {
-  hasPath: boolean;
-  hasSelectionPath: boolean;
-  outlineVertexCount: number;
-}
-
-const drawLocalGeometryCache = new WeakMap<object, DrawShapeGeometry>();
-const drawPositionedGeometryCache = new WeakMap<object, DrawShapeGeometry>();
-const drawPageGeometryCache = new WeakMap<object, DrawShapeGeometry>();
-
-function getDrawShapeSourceSegments(
-  props: Pick<DrawShapeProps, "segments">,
-): readonly DrawShapeSegment[] {
-  return props.segments;
-}
-
-function getInsetBounds(
-  bounds: Box,
-  padding: { left: number; right: number; top: number; bottom: number },
-): Box {
-  const width = Math.max(0, bounds.w - padding.left - padding.right);
-  const height = Math.max(0, bounds.h - padding.top - padding.bottom);
-
-  return new Box(bounds.x + padding.left, bounds.y + padding.top, width, height);
-}
-
-function getTargetPointBoundsFromSelectionBounds(
-  currentPointBounds: Box,
-  currentStrokeBounds: Box,
-  nextSelectionBounds: Box,
-): Box {
-  return getInsetBounds(nextSelectionBounds, {
-    left: currentPointBounds.minX - currentStrokeBounds.minX,
-    right: currentStrokeBounds.maxX - currentPointBounds.maxX,
-    top: currentPointBounds.minY - currentStrokeBounds.minY,
-    bottom: currentStrokeBounds.maxY - currentPointBounds.maxY,
-  });
-}
-
-function fitDrawSegmentsToSelectionStrokeBounds({
-  segments,
-  strokeWidth,
-  isPen,
-  isClosed,
-  targetSelectionStrokeBounds,
-}: {
-  segments: readonly DrawShapeSegment[];
-  strokeWidth: number;
-  isPen: boolean;
-  isClosed: boolean;
-  targetSelectionStrokeBounds: Box;
-}): DrawShapeSegment[] {
-  let fittedSegments = cloneDrawSegments(segments);
-
-  for (let pass = 0; pass < 2; pass += 1) {
-    const geometry = getDrawSegmentGeometry(
-      fittedSegments,
-      strokeWidth,
-      isPen,
-      isClosed,
-    );
-    const targetPointBounds = getTargetPointBoundsFromSelectionBounds(
-      geometry.pointBounds,
-      geometry.localBounds,
-      targetSelectionStrokeBounds,
-    );
-    fittedSegments = mapDrawShapeSegmentsToBounds(
-      fittedSegments,
-      geometry.pointBounds,
-      targetPointBounds,
-    );
-  }
-
-  return fittedSegments;
-}
-
-function getDrawShapePageCenter(
-  shape: DrawPageGeometryCacheKey,
-  localGeometry: Pick<DrawShapeGeometry, "localBounds">,
-): Vec {
-  return new Vec(
-    shape.x + localGeometry.localBounds.center.x,
-    shape.y + localGeometry.localBounds.center.y,
-  );
-}
-
-function positionedDrawPointToPagePoint(
-  shape: DrawPageGeometryCacheKey,
-  point: Vec,
-  center: Vec,
-): Vec {
-  if (shape.rotation === 0 && shape.scaleX === 1 && shape.scaleY === 1) {
-    return point;
-  }
-  const offset = point.sub(center);
-
-  return center.add(
-    new Vec(offset.x * shape.scaleX, offset.y * shape.scaleY).rot(
-      shape.rotation,
-    ),
-  );
-}
-
-export interface NormalizedDrawShape {
-  x: number;
-  y: number;
-  segments: DrawShapeSegment[];
-  pointBounds: Box;
-  localBounds: Box;
-  renderBounds: Box;
-  path: string | null;
-  selectionPath: string | null;
-  fillPath: string | null;
-  outlineVertices: Vec[];
-  outlinePolygons: Vec[][];
-  sampling: DrawShapeSamplingStats;
-}
-
-export function getDrawShapeLocalGeometry(
-  shape: DrawLocalGeometryCacheKey,
-): DrawShapeGeometry {
-  const cacheKey = shape as object;
-  const cached = drawLocalGeometryCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-
-  const geometry = getDrawSegmentGeometry(
-    getDrawShapeSourceSegments(shape.props),
-    shape.props.strokeWidth,
-    shape.props.isPen ?? false,
-    shape.props.isClosed,
-  );
-  drawLocalGeometryCache.set(cacheKey, geometry);
-  return geometry;
-}
-
-export function normalizeDrawShapeFromSegmentSet(
-  segments: readonly DrawShapeSegment[],
-  strokeWidth: number,
-  isPen = false,
-  isClosed = false,
-): NormalizedDrawShape {
-  const geometry = getDrawSegmentGeometry(segments, strokeWidth, isPen, isClosed);
-  const pointBounds = geometry.pointBounds;
-  const normalizedSegments = mapDrawSegmentCoordinates(
-    geometry.normalizedSegments,
-    (point) => new Vec(point.x - pointBounds.x, point.y - pointBounds.y),
-  );
-  const normalizedGeometry = getDrawSegmentGeometry(
-    normalizedSegments,
-    strokeWidth,
-    isPen,
-    isClosed,
-  );
-
-  return {
-    x: pointBounds.x,
-    y: pointBounds.y,
-    segments: normalizedGeometry.normalizedSegments,
-    pointBounds: normalizedGeometry.pointBounds,
-    localBounds: normalizedGeometry.localBounds,
-    renderBounds: normalizedGeometry.renderBounds,
-    path: normalizedGeometry.path,
-    selectionPath: normalizedGeometry.selectionPath,
-    fillPath: normalizedGeometry.fillPath,
-    outlineVertices: normalizedGeometry.outlineVertices,
-    outlinePolygons: normalizedGeometry.outlinePolygons,
-    sampling: normalizedGeometry.sampling,
-  };
-}
-
-export function normalizeDrawShapeFromPointSet(
-  points: readonly DrawShapePoint[],
-  strokeWidth: number,
-  isPen = false,
-  isClosed = false,
-): NormalizedDrawShape {
-  return normalizeDrawShapeFromSegmentSet(
-    getDrawSegmentsFromPoints(points),
-    strokeWidth,
-    isPen,
-    isClosed,
-  );
-}
-
-export function normalizeDrawShapeFromPagePoints(
-  pagePoints: readonly DrawShapePoint[],
-  strokeWidth: number,
-  isPen = false,
-  isClosed = false,
-): NormalizedDrawShape {
-  return normalizeDrawShapeFromPointSet(pagePoints, strokeWidth, isPen, isClosed);
-}
-
-export function normalizeDrawShapeFromPageSegments(
-  pageSegments: readonly DrawShapeSegment[],
-  strokeWidth: number,
-  isPen = false,
-  isClosed = false,
-): NormalizedDrawShape {
-  return normalizeDrawShapeFromSegmentSet(
-    pageSegments,
-    strokeWidth,
-    isPen,
-    isClosed,
-  );
-}
-
-export function getDrawShapePositionedSegments(
-  shape: Pick<DrawShapeRecord, "x" | "y" | "props">,
-): DrawShapeSegment[] {
-  return translateDrawSegments(
-    getDrawShapeSourceSegments(shape.props),
-    shape.x,
-    shape.y,
-  );
-}
-
-export function getDrawShapePositionedPoints(
-  shape: Pick<DrawShapeRecord, "x" | "y" | "props">,
-): DrawShapePoint[] {
-  return getFlattenedDrawSegmentPoints(getDrawShapePositionedSegments(shape));
-}
-
-export function getDrawShapePositionedGeometry(
-  shape: DrawPositionedGeometryCacheKey,
-): DrawShapeGeometry {
-  const cacheKey = shape as object;
-  const cached = drawPositionedGeometryCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-
-  const geometry = createTranslatedDrawGeometry(
-    getDrawShapeLocalGeometry(shape),
-    shape.props.strokeWidth,
-    shape.x,
-    shape.y,
-    shape.props.isClosed,
-  );
-  drawPositionedGeometryCache.set(cacheKey, geometry);
-  return geometry;
-}
-
-export function getDrawShapePagePoints(shape: DrawShapeRecord): DrawShapePoint[] {
-  return getFlattenedDrawSegmentPoints(getDrawShapePageSegments(shape));
-}
-
-export function getDrawShapePageSegments(shape: DrawShapeRecord): DrawShapeSegment[] {
-  const localGeometry = getDrawShapeLocalGeometry(shape);
-  const center = getDrawShapePageCenter(shape, localGeometry);
-  return mapDrawSegmentCoordinates(
-    getDrawShapePositionedSegments(shape),
-    (point) => positionedDrawPointToPagePoint(shape, point, center),
-  );
-}
-
-export function normalizeTransformedDrawShape(
-  shape: DrawShapeRecord,
-): NormalizedDrawShape {
-  return normalizeDrawShapeFromPageSegments(
-    getDrawShapePageSegments(shape),
-    shape.props.strokeWidth,
-    shape.props.isPen ?? false,
-    shape.props.isClosed,
-  );
-}
-
-export function getDrawShapePageGeometry(
-  shape: DrawPageGeometryCacheKey,
-): DrawShapeGeometry {
-  const cacheKey = shape as object;
-  const cached = drawPageGeometryCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-
-  if (shape.rotation === 0 && shape.scaleX === 1 && shape.scaleY === 1) {
-    const geometry = getDrawShapePositionedGeometry(shape);
-    drawPageGeometryCache.set(cacheKey, geometry);
-    return geometry;
-  }
-
-  const localGeometry = getDrawShapeLocalGeometry(shape);
-  const center = getDrawShapePageCenter(shape, localGeometry);
-  const pageSegments = mapDrawSegmentCoordinates(
-    localGeometry.normalizedSegments,
-    (point) =>
-      positionedDrawPointToPagePoint(
-        shape,
-        new Vec(point.x + shape.x, point.y + shape.y),
-        center,
-      ),
-  );
-  const outlineVertices = localGeometry.outlineVertices.map((point) =>
-    positionedDrawPointToPagePoint(
-      shape,
-      new Vec(point.x + shape.x, point.y + shape.y),
-      center,
-    ),
-  );
-  const outlinePolygons = localGeometry.outlinePolygons.map((polygon) =>
-    polygon.map((point) =>
-      positionedDrawPointToPagePoint(
-        shape,
-        new Vec(point.x + shape.x, point.y + shape.y),
-        center,
-      ),
-    ),
-  );
-  const geometry = createDrawGeometryFromDerivedData({
-    segments: pageSegments,
-    outlineVertices,
-    outlinePolygons,
-    strokeWidth: shape.props.strokeWidth,
-    sampling: localGeometry.sampling,
-    isClosed: shape.props.isClosed,
-  });
-  drawPageGeometryCache.set(cacheKey, geometry);
-  return geometry;
-}
-
-export function resizeDrawShapeToSelectionBounds(
-  shape: DrawShapeRecord,
-  input: DrawSelectionResizeInput,
-): NormalizedDrawShape {
-  const selectionLocalSegments = mapPageDrawSegmentsToSelectionLocal(
-    getDrawShapePageSegments(shape),
-    input,
-  );
-  const resizedSelectionLocalSegments = fitDrawSegmentsToSelectionStrokeBounds({
-    segments: selectionLocalSegments,
-    strokeWidth: shape.props.strokeWidth,
-    isPen: shape.props.isPen ?? false,
-    isClosed: shape.props.isClosed,
-    targetSelectionStrokeBounds: input.targetSelectionStrokeBounds,
-  });
-  let transformedSelectionLocalSegments = resizedSelectionLocalSegments;
-  if (input.scaleX < 0) {
-    transformedSelectionLocalSegments = mirrorSelectionLocalDrawSegments(
-      transformedSelectionLocalSegments,
-      {
-        axis: "horizontal",
-        selectionMirrorBounds: input.targetSelectionStrokeBounds,
-        selectionRotation: input.selectionRotation,
-        selectionRotationCenter: input.selectionRotationCenter,
-      },
-    );
-  }
-  if (input.scaleY < 0) {
-    transformedSelectionLocalSegments = mirrorSelectionLocalDrawSegments(
-      transformedSelectionLocalSegments,
-      {
-        axis: "vertical",
-        selectionMirrorBounds: input.targetSelectionStrokeBounds,
-        selectionRotation: input.selectionRotation,
-        selectionRotationCenter: input.selectionRotationCenter,
-      },
-    );
-  }
-  const resizedPageSegments = mapSelectionLocalDrawSegmentsToPage(
-    transformedSelectionLocalSegments,
-    input,
-  );
-
-  return normalizeDrawShapeFromPageSegments(
-    resizedPageSegments,
-    shape.props.strokeWidth,
-    shape.props.isPen ?? false,
-    shape.props.isClosed,
-  );
-}
-
-export function flipDrawShapeInSelectionBounds(
-  shape: DrawShapeRecord,
-  input: DrawSelectionFlipInput,
-): NormalizedDrawShape {
-  const selectionLocalSegments = mapPageDrawSegmentsToSelectionLocal(
-    getDrawShapePageSegments(shape),
-    input,
-  );
-  const flippedSelectionLocalSegments = mirrorSelectionLocalDrawSegments(
-    selectionLocalSegments,
-    input,
-  );
-  const flippedPageSegments = mapSelectionLocalDrawSegmentsToPage(
-    flippedSelectionLocalSegments,
-    input,
-  );
-
-  return normalizeDrawShapeFromPageSegments(
-    flippedPageSegments,
-    shape.props.strokeWidth,
-    shape.props.isPen ?? false,
-    shape.props.isClosed,
-  );
-}
-
-export function resizeDrawShapeToPageBounds(
-  shape: Pick<DrawShapeRecord, "x" | "y" | "props">,
-  nextPageBounds: Box,
-): NormalizedDrawShape {
-  const positionedSegments = getDrawShapePositionedSegments(shape);
-  const currentGeometry = getDrawShapePositionedGeometry(shape);
-  const currentPointBounds = currentGeometry.pointBounds;
-  const currentStrokeBounds = currentGeometry.localBounds;
-  const targetPointBounds = getInsetBounds(nextPageBounds, {
-    left: currentPointBounds.minX - currentStrokeBounds.minX,
-    right: currentStrokeBounds.maxX - currentPointBounds.maxX,
-    top: currentPointBounds.minY - currentStrokeBounds.minY,
-    bottom: currentStrokeBounds.maxY - currentPointBounds.maxY,
-  });
-  const resizedPositionedSegments = mapDrawShapeSegmentsToBounds(
-    positionedSegments,
-    currentPointBounds,
-    targetPointBounds,
-  );
-
-  return normalizeDrawShapeFromPageSegments(
-    resizedPositionedSegments,
-    shape.props.strokeWidth,
-    shape.props.isPen ?? false,
-    shape.props.isClosed,
-  );
-}
-
-export function cloneDrawShapeSegmentsForUpdate(
-  segments: readonly DrawShapeSegment[],
-): DrawShapeSegment[] {
-  return cloneDrawSegments(segments);
-}
-
-export function getDrawShapeDiagnostics(
-  shape: DrawLocalGeometryCacheKey,
-): DrawShapeDiagnostics {
-  const geometry = getDrawShapeLocalGeometry(shape);
-
-  return {
-    ...geometry.sampling,
-    hasPath: geometry.path !== null,
-    hasSelectionPath: geometry.selectionPath !== null,
-    outlineVertexCount: geometry.outlineVertices.length,
-  };
-}