@techzyapp/ui-library 1.0.42 → 1.0.44

package/dist/components/ImageEditor/CropShapeMenu.d.cts

@@ -0,0 +1,17 @@
+import type { ImageCropRatioOption } from './core/types';
+/** The Crop Shape presets (landscape form — the portrait toggle flips them). */
+export declare const DEFAULT_CROP_RATIOS: ImageCropRatioOption[];
+export interface CropShapeMenuProps {
+    /** The current crop shape (width / height), `null` = custom. */
+    ratio: number | null;
+    /** The presets (landscape form). */
+    options: ImageCropRatioOption[];
+    /** Pick a shape (`null` = custom). */
+    onChange: (ratio: number | null) => void;
+}
+/**
+ * The Crop tool's **Crop Shape** menu: a landscape / portrait toggle on top, then Custom (free) and the
+ * ratio presets, each with a little preview of its shape. Picking one reshapes the crop and locks it to
+ * that ratio. Internal to the ImageEditor.
+ */
+export declare function CropShapeMenu({ ratio, options, onChange }: CropShapeMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/CropShapeMenu.d.ts

@@ -0,0 +1,17 @@
+import type { ImageCropRatioOption } from './core/types';
+/** The Crop Shape presets (landscape form — the portrait toggle flips them). */
+export declare const DEFAULT_CROP_RATIOS: ImageCropRatioOption[];
+export interface CropShapeMenuProps {
+    /** The current crop shape (width / height), `null` = custom. */
+    ratio: number | null;
+    /** The presets (landscape form). */
+    options: ImageCropRatioOption[];
+    /** Pick a shape (`null` = custom). */
+    onChange: (ratio: number | null) => void;
+}
+/**
+ * The Crop tool's **Crop Shape** menu: a landscape / portrait toggle on top, then Custom (free) and the
+ * ratio presets, each with a little preview of its shape. Picking one reshapes the crop and locks it to
+ * that ratio. Internal to the ImageEditor.
+ */
+export declare function CropShapeMenu({ ratio, options, onChange }: CropShapeMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/EditorStage.d.cts

@@ -0,0 +1,27 @@
+import { type RefObject } from 'react';
+import type { ImageEditorCore, ImageEditorSnapshot } from './core/editor';
+export interface EditorStageHandle {
+    /** Call right before a rotate-left / flip / other jump changes the state, so the view animates it. */
+    transition(kind: 'rotate' | 'flip' | 'jump'): void;
+}
+export interface EditorStageProps {
+    core: ImageEditorCore;
+    snapshot: ImageEditorSnapshot;
+    /** Lock crop resizing to this ratio. */
+    cropAspectRatio?: number | null;
+    /** Filter / Finetune view zoom (CSS px per source px), `null` = fit. */
+    viewZoom: number | null;
+    onViewZoom: (zoom: number | null) => void;
+    /** Reports the effective view zoom (CSS px per source px) for the header label. */
+    onZoomReport: (zoom: number) => void;
+    /**
+     * The free area between the toolbars: the canvas fills the whole editor (the image runs behind the
+     * header / nav / footer), but the crop fits + centers in this element's box.
+     */
+    areaRef?: RefObject<HTMLElement | null>;
+}
+/** The editor's canvas + crop overlay: renders the image, owns the view and the pointer gestures. */
+export declare const EditorStage: import("react").ForwardRefExoticComponent<EditorStageProps & import("react").RefAttributes<EditorStageHandle>>;
+/** The Filter / Finetune view zoom range (CSS px per source px). */
+export declare const VIEW_ZOOM_MIN = 0.02;
+export declare const VIEW_ZOOM_MAX = 8;

package/dist/components/ImageEditor/EditorStage.d.ts

@@ -0,0 +1,27 @@
+import { type RefObject } from 'react';
+import type { ImageEditorCore, ImageEditorSnapshot } from './core/editor';
+export interface EditorStageHandle {
+    /** Call right before a rotate-left / flip / other jump changes the state, so the view animates it. */
+    transition(kind: 'rotate' | 'flip' | 'jump'): void;
+}
+export interface EditorStageProps {
+    core: ImageEditorCore;
+    snapshot: ImageEditorSnapshot;
+    /** Lock crop resizing to this ratio. */
+    cropAspectRatio?: number | null;
+    /** Filter / Finetune view zoom (CSS px per source px), `null` = fit. */
+    viewZoom: number | null;
+    onViewZoom: (zoom: number | null) => void;
+    /** Reports the effective view zoom (CSS px per source px) for the header label. */
+    onZoomReport: (zoom: number) => void;
+    /**
+     * The free area between the toolbars: the canvas fills the whole editor (the image runs behind the
+     * header / nav / footer), but the crop fits + centers in this element's box.
+     */
+    areaRef?: RefObject<HTMLElement | null>;
+}
+/** The editor's canvas + crop overlay: renders the image, owns the view and the pointer gestures. */
+export declare const EditorStage: import("react").ForwardRefExoticComponent<EditorStageProps & import("react").RefAttributes<EditorStageHandle>>;
+/** The Filter / Finetune view zoom range (CSS px per source px). */
+export declare const VIEW_ZOOM_MIN = 0.02;
+export declare const VIEW_ZOOM_MAX = 8;

package/dist/components/ImageEditor/FilterStrip.d.cts

@@ -0,0 +1,14 @@
+import { type Size } from './core/geometry';
+import { type ImageSource } from './core/load';
+import type { ImageFilterId, ImageState } from './core/types';
+export interface FilterStripProps {
+    image: ImageSource;
+    size: Size;
+    state: ImageState;
+    onSelect: (id: ImageFilterId) => void;
+}
+/**
+ * The Filter tool's footer: a horizontally scrolling strip of preset tiles (live thumbnails), grouped.
+ * Wheel scrolls it sideways, it drags with momentum, arrows move between tiles; the edges fade.
+ */
+export declare function FilterStrip({ image, size, state, onSelect }: FilterStripProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/FilterStrip.d.ts

@@ -0,0 +1,14 @@
+import { type Size } from './core/geometry';
+import { type ImageSource } from './core/load';
+import type { ImageFilterId, ImageState } from './core/types';
+export interface FilterStripProps {
+    image: ImageSource;
+    size: Size;
+    state: ImageState;
+    onSelect: (id: ImageFilterId) => void;
+}
+/**
+ * The Filter tool's footer: a horizontally scrolling strip of preset tiles (live thumbnails), grouped.
+ * Wheel scrolls it sideways, it drags with momentum, arrows move between tiles; the edges fade.
+ */
+export declare function FilterStrip({ image, size, state, onSelect }: FilterStripProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/ImageEditor.d.cts

@@ -0,0 +1,30 @@
+import { type HTMLAttributes } from 'react';
+import type { ImageEditorOptions, ImageEditorResult, ImageState } from './core/types';
+export interface ImageEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onLoad' | 'title' | 'children'>, Omit<ImageEditorOptions, 'src'> {
+    /** Whether the editor is shown (a fullscreen overlay). */
+    open: boolean;
+    /** The image to edit: a `File` / `Blob`, a URL or a data URL. */
+    src: ImageEditorOptions['src'] | null;
+    /** Fired once the image has loaded. */
+    onLoad?: (info: {
+        width: number;
+        height: number;
+    }) => void;
+    /** Fired on every committed change (a drag's end, a click, a preset). */
+    onUpdate?: (state: ImageState) => void;
+    /** Fired by **Done** with the rendered image + the state it came from; the editor then closes. */
+    onProcess?: (result: ImageEditorResult) => void;
+    /** Requested close (✕, Escape, or after **Done**). Changes are discarded unless processed. */
+    onClose: () => void;
+}
+/**
+ * A fullscreen image editor — **Crop** (resize, pan, zoom, rotate ±45°, scale, rotate left, flip, Crop
+ * Shape presets), **Filter** (14 presets with live thumbnails), **Finetune** (brightness, contrast,
+ * saturation, exposure, temperature, gamma, clarity, vignette), **Redact** (blur or pixelate the whole
+ * image) and **Resize** (width × height, aspect lock, never upscales) — over a WebGL renderer (Canvas2D
+ * fallback), with undo / redo / revert (Revert = back to the original image). **Done** renders the result
+ * at full source resolution (JPEG / PNG / WebP keep their type, anything else becomes PNG) and hands it to
+ * `onProcess` with the `imageState`, which re-opens the edit non-destructively via `initialState`. Follows
+ * the app's light / dark theme.
+ */
+export declare const ImageEditor: import("react").ForwardRefExoticComponent<ImageEditorProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/ImageEditor/ImageEditor.d.ts

@@ -0,0 +1,30 @@
+import { type HTMLAttributes } from 'react';
+import type { ImageEditorOptions, ImageEditorResult, ImageState } from './core/types';
+export interface ImageEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onLoad' | 'title' | 'children'>, Omit<ImageEditorOptions, 'src'> {
+    /** Whether the editor is shown (a fullscreen overlay). */
+    open: boolean;
+    /** The image to edit: a `File` / `Blob`, a URL or a data URL. */
+    src: ImageEditorOptions['src'] | null;
+    /** Fired once the image has loaded. */
+    onLoad?: (info: {
+        width: number;
+        height: number;
+    }) => void;
+    /** Fired on every committed change (a drag's end, a click, a preset). */
+    onUpdate?: (state: ImageState) => void;
+    /** Fired by **Done** with the rendered image + the state it came from; the editor then closes. */
+    onProcess?: (result: ImageEditorResult) => void;
+    /** Requested close (✕, Escape, or after **Done**). Changes are discarded unless processed. */
+    onClose: () => void;
+}
+/**
+ * A fullscreen image editor — **Crop** (resize, pan, zoom, rotate ±45°, scale, rotate left, flip, Crop
+ * Shape presets), **Filter** (14 presets with live thumbnails), **Finetune** (brightness, contrast,
+ * saturation, exposure, temperature, gamma, clarity, vignette), **Redact** (blur or pixelate the whole
+ * image) and **Resize** (width × height, aspect lock, never upscales) — over a WebGL renderer (Canvas2D
+ * fallback), with undo / redo / revert (Revert = back to the original image). **Done** renders the result
+ * at full source resolution (JPEG / PNG / WebP keep their type, anything else becomes PNG) and hands it to
+ * `onProcess` with the `imageState`, which re-opens the edit non-destructively via `initialState`. Follows
+ * the app's light / dark theme.
+ */
+export declare const ImageEditor: import("react").ForwardRefExoticComponent<ImageEditorProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/ImageEditor/ResizePanel.d.cts

@@ -0,0 +1,19 @@
+import type { Size } from './core/geometry';
+export interface ResizePanelProps {
+    /** The largest size — the crop at full resolution (the tool never upscales). */
+    max: Size;
+    /** The current result size. */
+    value: Size;
+    /** Keep the crop's aspect ratio while typing. */
+    locked: boolean;
+    onLockedChange: (locked: boolean) => void;
+    /** A live change (while typing). */
+    onInput: (size: Size | null) => void;
+    /** A committed change (Enter, blur, a preset). */
+    onChange: (size: Size | null) => void;
+}
+/**
+ * The Resize tool's footer: a Width × Height pair (with an aspect-ratio lock between them) under the
+ * full size it can go up to, and Original / 75% / 50% / 25% quick picks. Internal to the ImageEditor.
+ */
+export declare function ResizePanel({ max, value, locked, onLockedChange, onInput, onChange, }: ResizePanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/ResizePanel.d.ts

@@ -0,0 +1,19 @@
+import type { Size } from './core/geometry';
+export interface ResizePanelProps {
+    /** The largest size — the crop at full resolution (the tool never upscales). */
+    max: Size;
+    /** The current result size. */
+    value: Size;
+    /** Keep the crop's aspect ratio while typing. */
+    locked: boolean;
+    onLockedChange: (locked: boolean) => void;
+    /** A live change (while typing). */
+    onInput: (size: Size | null) => void;
+    /** A committed change (Enter, blur, a preset). */
+    onChange: (size: Size | null) => void;
+}
+/**
+ * The Resize tool's footer: a Width × Height pair (with an aspect-ratio lock between them) under the
+ * full size it can go up to, and Original / 75% / 50% / 25% quick picks. Internal to the ImageEditor.
+ */
+export declare function ResizePanel({ max, value, locked, onLockedChange, onInput, onChange, }: ResizePanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/RulerSlider.d.cts

@@ -0,0 +1,37 @@
+export interface RulerSliderProps {
+    /** Lowest value. */
+    min: number;
+    /** Highest value. */
+    max: number;
+    /** The current value. */
+    value: number;
+    /** Value granularity. Defaults to `1`. */
+    step?: number;
+    /** Arrow-key step (Shift = ×10). Defaults to `1`. */
+    keyStep?: number;
+    /** Values the ruler snaps to when within `snapThreshold`. Defaults to `[0]`. */
+    snapPoints?: number[];
+    /** Snap distance in value units. Defaults to 2% of the range. */
+    snapThreshold?: number;
+    /** Value units between two ruler dots. Defaults to 5% of the range. */
+    tickStep?: number;
+    /** Every n-th dot is a bigger one. Defaults to `5`. */
+    majorEvery?: number;
+    /** The value a double-click resets to. Defaults to `0` (clamped into the range). */
+    resetValue?: number;
+    /** The label shown at the center (and the `aria-valuetext`). */
+    format?: (value: number) => string;
+    /** Fired continuously while the value changes (drag, inertia, wheel). */
+    onInput: (value: number) => void;
+    /** Fired when a change is committed (pointer-up / inertia end, a key press, wheel idle, reset). */
+    onChange: (value: number) => void;
+    /** Accessible name. */
+    'aria-label': string;
+    className?: string;
+}
+/**
+ * A tape-measure slider: a dotted ruler slides under a fixed center indicator (drag left → the value
+ * grows), with inertia, wheel and keyboard control, snapping to `snapPoints`, and a double-click reset.
+ * Internal to the ImageEditor (Rotation / Scale / Finetune).
+ */
+export declare function RulerSlider({ min, max, value, step, keyStep, snapPoints, snapThreshold, tickStep, majorEvery, resetValue, format, onInput, onChange, 'aria-label': ariaLabel, className, }: RulerSliderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/RulerSlider.d.ts

@@ -0,0 +1,37 @@
+export interface RulerSliderProps {
+    /** Lowest value. */
+    min: number;
+    /** Highest value. */
+    max: number;
+    /** The current value. */
+    value: number;
+    /** Value granularity. Defaults to `1`. */
+    step?: number;
+    /** Arrow-key step (Shift = ×10). Defaults to `1`. */
+    keyStep?: number;
+    /** Values the ruler snaps to when within `snapThreshold`. Defaults to `[0]`. */
+    snapPoints?: number[];
+    /** Snap distance in value units. Defaults to 2% of the range. */
+    snapThreshold?: number;
+    /** Value units between two ruler dots. Defaults to 5% of the range. */
+    tickStep?: number;
+    /** Every n-th dot is a bigger one. Defaults to `5`. */
+    majorEvery?: number;
+    /** The value a double-click resets to. Defaults to `0` (clamped into the range). */
+    resetValue?: number;
+    /** The label shown at the center (and the `aria-valuetext`). */
+    format?: (value: number) => string;
+    /** Fired continuously while the value changes (drag, inertia, wheel). */
+    onInput: (value: number) => void;
+    /** Fired when a change is committed (pointer-up / inertia end, a key press, wheel idle, reset). */
+    onChange: (value: number) => void;
+    /** Accessible name. */
+    'aria-label': string;
+    className?: string;
+}
+/**
+ * A tape-measure slider: a dotted ruler slides under a fixed center indicator (drag left → the value
+ * grows), with inertia, wheel and keyboard control, snapping to `snapPoints`, and a double-click reset.
+ * Internal to the ImageEditor (Rotation / Scale / Finetune).
+ */
+export declare function RulerSlider({ min, max, value, step, keyStep, snapPoints, snapThreshold, tickStep, majorEvery, resetValue, format, onInput, onChange, 'aria-label': ariaLabel, className, }: RulerSliderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImageEditor/core/affine.d.cts

@@ -0,0 +1,11 @@
+export type Affine = [number, number, number, number, number, number];
+export declare const IDENTITY_AFFINE: Affine;
+export declare const translate: (x: number, y: number) => Affine;
+export declare const scaleAffine: (sx: number, sy?: number) => Affine;
+export declare const rotateAffine: (theta: number) => Affine;
+/** `a ∘ b` — apply `b` first, then `a`. */
+export declare function multiplyAffine(a: Affine, b: Affine): Affine;
+/** Compose in application order: `chain(t1, t2, t3)` applies t1, then t2, then t3. */
+export declare const chain: (...ts: Affine[]) => Affine;
+export declare function invertAffine([a, b, c, d, e, f]: Affine): Affine;
+export declare const applyAffine: ([a, b, c, d, e, f]: Affine, x: number, y: number) => [number, number];

package/dist/components/ImageEditor/core/affine.d.ts

@@ -0,0 +1,11 @@
+export type Affine = [number, number, number, number, number, number];
+export declare const IDENTITY_AFFINE: Affine;
+export declare const translate: (x: number, y: number) => Affine;
+export declare const scaleAffine: (sx: number, sy?: number) => Affine;
+export declare const rotateAffine: (theta: number) => Affine;
+/** `a ∘ b` — apply `b` first, then `a`. */
+export declare function multiplyAffine(a: Affine, b: Affine): Affine;
+/** Compose in application order: `chain(t1, t2, t3)` applies t1, then t2, then t3. */
+export declare const chain: (...ts: Affine[]) => Affine;
+export declare function invertAffine([a, b, c, d, e, f]: Affine): Affine;
+export declare const applyAffine: ([a, b, c, d, e, f]: Affine, x: number, y: number) => [number, number];

package/dist/components/ImageEditor/core/editor.d.cts

@@ -0,0 +1,69 @@
+import { type Size } from './geometry';
+import { type LoadedImage } from './load';
+import type { ImageEditorOptions, ImageEditorResult, ImageEditorUiState, ImageState } from './types';
+export type ImageEditorEvent = 'load' | 'update' | 'process' | 'close' | 'undo' | 'redo' | 'revert';
+/** The store snapshot (a new object on every change — safe for `useSyncExternalStore`). */
+export interface ImageEditorSnapshot {
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    error: unknown;
+    state: ImageState | null;
+    ui: ImageEditorUiState;
+    size: Size | null;
+    canUndo: boolean;
+    canRedo: boolean;
+    canRevert: boolean;
+}
+/** The headless editor API. */
+export interface Editor {
+    open(options: ImageEditorOptions): Promise<void>;
+    close(): void;
+    getState(): ImageState;
+    setState(s: Partial<ImageState>): void;
+    undo(): void;
+    redo(): void;
+    revert(): void;
+    on(event: ImageEditorEvent, cb: (payload?: unknown) => void): () => void;
+    process(): Promise<ImageEditorResult>;
+}
+export declare class ImageEditorCore implements Editor {
+    private snapshot;
+    private storeListeners;
+    private events;
+    private history;
+    private index;
+    /** The untouched state of the loaded image (what `revert()` goes back to). */
+    private initial;
+    private loaded;
+    private options;
+    private openToken;
+    subscribe: (fn: () => void) => () => void;
+    getSnapshot: () => ImageEditorSnapshot;
+    private patch;
+    on(event: ImageEditorEvent, cb: (payload?: unknown) => void): () => void;
+    private emit;
+    /** The loaded image (full resolution) — for renderers. */
+    get image(): LoadedImage | null;
+    /** The `open()` options. */
+    get openOptions(): ImageEditorOptions | null;
+    open(options: ImageEditorOptions): Promise<void>;
+    close(): void;
+    getState(): ImageState;
+    /** Replace part of the state and commit it (one undo step). */
+    setState(s: Partial<ImageState>): void;
+    /** Apply a live (uncommitted) change — e.g. while dragging. Call `commit()` when the interaction ends. */
+    preview(s: Partial<ImageState>): void;
+    /** Push the current state onto the history (if it changed) and emit `update`. */
+    commit(): void;
+    undo(): void;
+    redo(): void;
+    /**
+     * Back to the original image — every edit dropped, including the ones an `initialState` re-opened with.
+     * It's one history step, so Undo brings the edits back.
+     */
+    revert(): void;
+    setUi(ui: Partial<ImageEditorUiState>): void;
+    /** Render the current state at full resolution. */
+    process(): Promise<ImageEditorResult>;
+}
+/** Create a headless editor. */
+export declare const createImageEditor: () => ImageEditorCore;

package/dist/components/ImageEditor/core/editor.d.ts

@@ -0,0 +1,69 @@
+import { type Size } from './geometry';
+import { type LoadedImage } from './load';
+import type { ImageEditorOptions, ImageEditorResult, ImageEditorUiState, ImageState } from './types';
+export type ImageEditorEvent = 'load' | 'update' | 'process' | 'close' | 'undo' | 'redo' | 'revert';
+/** The store snapshot (a new object on every change — safe for `useSyncExternalStore`). */
+export interface ImageEditorSnapshot {
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    error: unknown;
+    state: ImageState | null;
+    ui: ImageEditorUiState;
+    size: Size | null;
+    canUndo: boolean;
+    canRedo: boolean;
+    canRevert: boolean;
+}
+/** The headless editor API. */
+export interface Editor {
+    open(options: ImageEditorOptions): Promise<void>;
+    close(): void;
+    getState(): ImageState;
+    setState(s: Partial<ImageState>): void;
+    undo(): void;
+    redo(): void;
+    revert(): void;
+    on(event: ImageEditorEvent, cb: (payload?: unknown) => void): () => void;
+    process(): Promise<ImageEditorResult>;
+}
+export declare class ImageEditorCore implements Editor {
+    private snapshot;
+    private storeListeners;
+    private events;
+    private history;
+    private index;
+    /** The untouched state of the loaded image (what `revert()` goes back to). */
+    private initial;
+    private loaded;
+    private options;
+    private openToken;
+    subscribe: (fn: () => void) => () => void;
+    getSnapshot: () => ImageEditorSnapshot;
+    private patch;
+    on(event: ImageEditorEvent, cb: (payload?: unknown) => void): () => void;
+    private emit;
+    /** The loaded image (full resolution) — for renderers. */
+    get image(): LoadedImage | null;
+    /** The `open()` options. */
+    get openOptions(): ImageEditorOptions | null;
+    open(options: ImageEditorOptions): Promise<void>;
+    close(): void;
+    getState(): ImageState;
+    /** Replace part of the state and commit it (one undo step). */
+    setState(s: Partial<ImageState>): void;
+    /** Apply a live (uncommitted) change — e.g. while dragging. Call `commit()` when the interaction ends. */
+    preview(s: Partial<ImageState>): void;
+    /** Push the current state onto the history (if it changed) and emit `update`. */
+    commit(): void;
+    undo(): void;
+    redo(): void;
+    /**
+     * Back to the original image — every edit dropped, including the ones an `initialState` re-opened with.
+     * It's one history step, so Undo brings the edits back.
+     */
+    revert(): void;
+    setUi(ui: Partial<ImageEditorUiState>): void;
+    /** Render the current state at full resolution. */
+    process(): Promise<ImageEditorResult>;
+}
+/** Create a headless editor. */
+export declare const createImageEditor: () => ImageEditorCore;

package/dist/components/ImageEditor/core/geometry.d.cts

@@ -0,0 +1,112 @@
+import type { ImageRect, ImageState } from './types';
+export interface Size {
+    width: number;
+    height: number;
+}
+export type Vec = [number, number];
+/** Rotate a vector by θ (positive = clockwise on a y-down screen). */
+export declare const rotate: ([x, y]: Vec, theta: number) => Vec;
+/** Half the size of a w×h box's bounding box once it's turned by θ. */
+export declare function halfExtents(w: number, h: number, theta: number): Vec;
+/** The crop's center. */
+export declare const cropCenter: (crop: ImageRect) => Vec;
+/**
+ * The minimum `scale` at which an image of `size` covers a w×h crop turned by θ **when centered on the
+ * image** — the "cover" scale every zoom is measured from (zoom = scale / coverScale).
+ */
+export declare function coverScale(w: number, h: number, theta: number, size: Size): number;
+/** The image point (image-centered, unrotated, unscaled) under the crop's center. */
+export declare function cropAnchor(state: ImageState, size: Size): Vec;
+/** Clamp the crop anchor so a w×h crop (turned by θ, image scaled by s) stays inside the image. */
+export declare function clampAnchor([ux, uy]: Vec, w: number, h: number, theta: number, s: number, size: Size): Vec;
+/** Place a w×h crop so its center sits over image point `u` (inverse of `cropAnchor`). */
+export declare function cropAt(u: Vec, w: number, h: number, theta: number, s: number, size: Size): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** Whether the image fully covers `crop` (with a small tolerance). */
+export declare function coversCrop(crop: ImageRect, theta: number, s: number, size: Size): boolean;
+/**
+ * Re-fit a state so the image covers the crop: the scale is raised to at least the cover scale, then the
+ * anchor (the image point under the crop's center) is clamped. The crop's size never changes here.
+ */
+export declare function fitState(state: ImageState, size: Size): ImageState;
+/** The output size in pixels — the crop at full source resolution. */
+export declare function outputSize(state: ImageState): Size;
+/** The size `process()` renders — the Resize tool's pick, else the crop at full resolution. */
+export declare function finalSize(state: ImageState): Size;
+/**
+ * The part of the crop the output shows — the crop itself, or for a Resize pick of another aspect its
+ * largest centered sub-rect of that aspect (`object-fit: cover`: the image is cut, never squashed).
+ */
+export declare function resizedCrop(state: ImageState): ImageRect;
+/**
+ * Apply a Resize pick to `base` (the state the pick is made from). A size of the crop's own aspect just
+ * scales the output; another aspect first cuts the crop to it — its largest centered part of that aspect
+ * (`object-fit: cover`) — so the Crop tool shows exactly what's kept. `null` (or the crop's full size)
+ * clears it. The size never goes above what `base`'s crop holds.
+ */
+export declare function applyResize(base: ImageState, pick: Size | null): ImageState;
+/**
+ * Keep a Resize pick in step when the crop changes under it: it keeps its share of the crop (a 25% pick
+ * stays 25% of the new crop), so the result size follows the crop. Unchanged when no resize is set or the
+ * crop's output size didn't move.
+ */
+export declare function syncResize(prev: ImageState, next: ImageState): ImageState['resize'];
+/** The largest crop of the given ratio that fits the (unrotated) image, centered. */
+export declare function initialCrop(size: Size, aspectRatio?: number | null): ImageRect;
+/** The untouched state for an image of `size`. */
+export declare function defaultState(size: Size, aspectRatio?: number | null): ImageState;
+/** Split a rotation into its quarter turns (multiple of π/2, normalized to [0, 2π)) + the fine part. */
+export declare function splitRotation(theta: number, quarterHint?: number): {
+    quarter: number;
+    fine: number;
+};
+/** Normalize an angle into [0, 2π). */
+export declare const normalizeAngle: (a: number) => number;
+/**
+ * Set the rotation to `theta`, keeping the same image point under the crop's center: the image scales up
+ * to cover the crop when needed (never below `base.scale`) and the anchor is clamped. `base` is the state
+ * at the start of the interaction, so turning back restores the original zoom.
+ */
+export declare function rotateTo(base: ImageState, theta: number, size: Size): ImageState;
+/** Rotate the whole image −90° (counter-clockwise): the crop turns with it (its width/height swap, and so
+ * does a picked crop shape — 16:9 becomes 9:16). */
+export declare function rotateLeft(state: ImageState, size: Size): ImageState;
+/** Mirror the result horizontally (the image flips inside the crop; the crop mirrors about the center). */
+export declare function flipHorizontal(state: ImageState, size: Size): ImageState;
+/** The current zoom relative to the cover scale (1 = the image just covers the crop). */
+export declare function zoomOf(state: ImageState, size: Size): number;
+/** The largest zoom inside the crop (relative to the cover scale) — 500%. */
+export declare const MAX_CROP_ZOOM = 5;
+/**
+ * Set the zoom (1…`MAX_CROP_ZOOM`, relative to the cover scale), keeping the image point under the
+ * crop's center.
+ */
+export declare function zoomTo(state: ImageState, zoom: number, size: Size): ImageState;
+/** Move the crop across the image by (dx, dy) plane units (the image moves the other way on screen). */
+export declare function panBy(state: ImageState, dx: number, dy: number, size: Size): ImageState;
+/**
+ * Pick a crop shape: `ratio` (width / height) reshapes the crop into the largest rect of that ratio the
+ * image covers at the current rotation + zoom, kept over the same image point (moved only as far as it
+ * must to stay on the image); `null` frees it (the crop itself is left as is).
+ */
+export declare function setCropRatio(state: ImageState, ratio: number | null, size: Size): ImageState;
+export type CropHandle = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+export interface ResizeOptions {
+    /** Lock the crop to this width/height ratio. */
+    aspectRatio?: number | null;
+    /** The smallest crop side, in plane units. */
+    minSize: number;
+}
+/**
+ * Resize the crop by dragging `handle` by (dx, dy) plane units from the interaction's `start` state. A
+ * corner moves against its opposite corner, an edge moves one side (with a locked ratio the other side
+ * follows, centered). The result never leaves the image: an out-of-bounds request is pulled back along
+ * the way from `start` to it (so it stops at the image's edge instead of jumping).
+ */
+export declare function resizeCrop(start: ImageState, handle: CropHandle, dx: number, dy: number, size: Size, { aspectRatio, minSize }: ResizeOptions): ImageState;
+/** Clamp a state's crop + scale into a valid configuration (used on `setState` / `initialState`). */
+export declare function normalizeState(state: ImageState, size: Size): ImageState;