@weasel-js/core 1.4.3 → 1.5.0

package/dist/geometry-CHR36Ub_.d.ts

@@ -1,114 +0,0 @@
-import { V as View } from './view-DSQgxBJB.js';
-import { R as ResizePose, a as RotatedPose } from './types-BJqsTlXl.js';
-
-/**
- * Axis-aligned rectangle in world space. Kit-wide `Bounds` shape used by
- * selection, group, and viewport helpers. The optional `rotation` field
- * (radians, around the AABB center) lets selection chrome attach a rotated
- * orientation to an otherwise axis-aligned rect without needing a parallel
- * type.
- */
-interface Bounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation?: number;
-}
-/** Pixel dimensions of the canvas viewport. */
-interface ViewportDims {
-    width: number;
-    height: number;
-}
-/** Options for {@link fitViewToBounds}. */
-interface FitViewToBoundsOptions {
-    /** Inset (in CSS px) around the bounds. Default 16. */
-    padding?: number;
-    /**
-     * Override the kit's system max scale. Defaults to the kit-wide max zoom
-     * used by `computeWheelAction` (`DEFAULT_MAX_ZOOM`).
-     */
-    maxScale?: number;
-    /**
-     * Override the kit's system min scale. Defaults to the kit-wide min zoom
-     * used by `computeWheelAction` (`DEFAULT_MIN_ZOOM`).
-     */
-    minScale?: number;
-    /**
-     * Fit mode:
-     * - `'contain'` (default): uniform scale = `min(availW/w, availH/h)`. Bounds fit entirely; one axis has letterboxing.
-     * - `'fill'`: uniform scale = `max(...)`. Bounds overflow viewport on one axis.
-     * - `'stretch'`: per-axis scale. Bounds match viewport exactly; scale is non-uniform.
-     */
-    mode?: 'contain' | 'fill' | 'stretch';
-}
-/**
- * Compute the target {@link View} that fits `bounds` (world space) inside
- * `viewportDims` (CSS px). The bounds are centered in the viewport with
- * uniform padding on all sides; the resulting scale is clamped to the
- * configured min/max.
- *
- * View semantics: `view.x` / `view.y` is the world point currently drawn at
- * the canvas top-left, and `view.scale.{x,y}` is pixels per world unit on
- * each axis (see `view.ts`). So:
- *   screenX = (worldX - view.x) * view.scale.x
- *   screenY = (worldY - view.y) * view.scale.y
- *
- * Empty / zero-sized bounds or viewports cannot be fit — in that case this
- * returns `currentView` unchanged and logs a `console.warn`. Callers that
- * want to no-op silently can detect zero area themselves before calling.
- */
-declare function fitViewToBounds(bounds: Bounds, viewportDims: ViewportDims, currentView: View, opts?: FitViewToBoundsOptions): View;
-
-/**
- * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.
- * The hook reads bounds via `getBounds`, runs anchor-relative math on those
- * bounds, then asks `remapBounds` to project the result back into TPose.
- *
- * `remapBounds(pose, src, dst)` is a single operation that subsumes both
- * "set my own AABB to dst" (single-leaf resize) and "scale me as a leaf
- * inside parent's src→dst rect" (group resize) — they're the same affine
- * map. For rect-shaped poses the default geometry interprets the pose as
- * its own bounds; for Path or polygon poses the consumer supplies a
- * projection that knows how to read and rewrite the underlying geometry.
- */
-interface PoseProjection<TPose> {
-    getBounds(pose: TPose): ResizePose;
-    remapBounds(pose: TPose, src: ResizePose, dst: ResizePose): TPose;
-    /** Translate the pose by (dx, dy). Optional — when omitted, callers fall
-     *  back to a translation derived from `remapBounds` (origin shifted, no
-     *  scale). Path-shaped poses should provide this for performance. */
-    translate?(pose: TPose, dx: number, dy: number): TPose;
-    /** True iff any portion of the pose's geometry intersects `rect`. Optional
-     *  — when omitted, area-select and similar callers test against `getBounds`
-     *  AABB (looser, but correct for axis-aligned rect poses). */
-    intersectsRect?(pose: TPose, rect: ResizePose): boolean;
-    /** Interpolate between two poses. Optional — animation helpers fall back to
-     *  rect-shape lerp when omitted (which fails for non-rect poses). */
-    lerp?(a: TPose, b: TPose, t: number): TPose;
-    /** Read the pose's rotation in radians. Pivot is the AABB center
-     *  (`getBounds(pose)` center). Default 0 when omitted — descriptor
-     *  declares "this pose has no rotation." When supplied and non-zero,
-     *  `useResize` projects the drag delta into the leaf's local frame,
-     *  runs anchor math there, and translates the resulting pose so the
-     *  diagonally opposite world-space corner is pinned. */
-    getRotation?(pose: TPose): number;
-    /** True iff this pose shape can carry a rotation. Consulted by the
-     *  rotation affordance to decide whether to render the rotate cursor /
-     *  drag-band over a selection. When omitted, the kit assumes `true` for
-     *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`
-     *  fields (e.g. polygon Paths) should return `false` so the affordance
-     *  hides instead of exposing a non-functional rotate cursor. */
-    supportsRotation?(pose: TPose): boolean;
-}
-/** Identity geometry for `TPose extends ResizePose`. Treats the pose as its
- *  own bounds and remaps via affine scale against `src`/`dst`. */
-declare const RECT_POSE_DESCRIPTOR: PoseProjection<ResizePose>;
-/** Identity geometry for `RotatedPose`. Inherits rect-shape projection
- *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends ResizePose`
- *  subtype lets the rect descriptor's methods apply directly; `remapBounds`
- *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so
- *  `useResize` knows to take the rotation-aware math path. */
-declare const ROTATED_POSE_DESCRIPTOR: PoseProjection<RotatedPose>;
-
-export { type Bounds as B, type FitViewToBoundsOptions as F, type PoseProjection as P, RECT_POSE_DESCRIPTOR as R, type ViewportDims as V, ROTATED_POSE_DESCRIPTOR as a, fitViewToBounds as f };

package/dist/path-JEV2c5If.d.ts

@@ -1,48 +0,0 @@
-/**
- * Path data model. Vector-graphics primitive used kit-wide as the canonical
- * shape (replacing per-shape ad-hoc poses). SVG-style command stream so we
- * cover lines, polygons, beziers, and multi-contour shapes (think the inner
- * hole of an "O") under one type.
- *
- * Storage: command codes in a `Uint8Array`, parameters in a `Float32Array`.
- * Each command consumes a fixed number of float coords from the parameter
- * array; the parser walks both arrays in lockstep. This keeps interaction
- * hot loops monomorphic and keeps GC pressure low under heavy edits.
- *
- * Two path subtypes are distinguished at the type level so common-case
- * machinery (selection AABBs, area-select intersection, hit-testing rect
- * silhouettes) can short-circuit on `RectPath` without paying the polygon
- * kernel cost. Polymorphic kernels accept either via the `Path` union and
- * dispatch on `kind`.
- */
-
-/** Fill rule used by polygon path hit-testing and `ctx.fill()`. */
-type PathFillRule = 'nonzero' | 'evenodd';
-/**
- * Polygon path with arbitrary contours and optional bezier segments.
- * Multi-contour: each `M` opens a new subpath; `Z` closes the current one.
- * Open subpaths (no `Z`) render as polylines and don't contribute to fills.
- */
-interface PolygonPath {
-    kind: 'polygon';
-    commands: Uint8Array;
-    coords: Float32Array;
-    fillRule: PathFillRule;
-}
-/**
- * Axis-aligned rectangle. Fast path for the (very common) case where the
- * shape is just a rect — preserves O(1) bounds and hit-test, avoids the
- * polygon kernel entirely. Promote to `PolygonPath` only when the shape
- * grows beyond what a rect can express.
- */
-interface RectPath {
-    kind: 'rect';
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** Canonical path shape — either an axis-aligned rect (fast path) or a polygon command stream. */
-type Path = PolygonPath | RectPath;
-
-export type { Path as P, RectPath as R, PolygonPath as a, PathFillRule as b };