ppu-ocv 3.1.3 → 3.1.4

package/canvas-factory.d.ts

@@ -2,44 +2,71 @@
  * Platform abstraction layer for canvas operations.
  * Allows ppu-ocv to work with both @napi-rs/canvas (Node) and browser canvas APIs.
  */
-/** Structural type satisfied by both @napi-rs/canvas Canvas and HTMLCanvasElement/OffscreenCanvas */
+/** Structural type satisfied by both @napi-rs/canvas Canvas and HTMLCanvasElement/OffscreenCanvas. */
 export interface CanvasLike {
+    /** Canvas width in pixels. */
     width: number;
+    /** Canvas height in pixels. */
     height: number;
+    /** Return a 2D rendering context for drawing on the canvas. */
     getContext(contextId: "2d"): any;
+    /** Serialize the canvas to a binary buffer (Node-side `@napi-rs/canvas`). Absent on browser canvases. */
     toBuffer?: (...args: any[]) => Buffer;
+    /** Serialize the canvas to a data-URL string (browser canvases). Absent on Node-side `@napi-rs/canvas`. */
     toDataURL?: (...args: any[]) => string;
 }
-/** Structural type for 2D rendering context */
+/** Structural type for 2D rendering context, matching the cross-runtime subset used by ppu-ocv. */
 export interface Context2DLike {
+    /** The canvas this context is bound to. */
     canvas: any;
+    /** Draw an image, canvas, or bitmap onto the context. Signature follows the standard Canvas2D `drawImage`. */
     drawImage(...args: any[]): void;
+    /** Read raw RGBA pixel data from a rectangular region of the canvas. */
     getImageData(sx: number, sy: number, sw: number, sh: number): {
         data: Uint8ClampedArray;
         width: number;
         height: number;
     };
+    /** Write raw RGBA pixel data back to the canvas at `(dx, dy)`. */
     putImageData(imageData: any, dx: number, dy: number): void;
+    /** Allocate a blank `ImageData` of the given size. */
     createImageData(width: number, height: number): any;
+    /** Start a new path for stroke/fill commands. */
     beginPath(): void;
+    /** Close the current sub-path by connecting the last point to the first. */
     closePath(): void;
+    /** Move the path cursor to `(x, y)` without drawing. */
     moveTo(x: number, y: number): void;
+    /** Draw a straight line from the current path point to `(x, y)`. */
     lineTo(x: number, y: number): void;
+    /** Stroke the current path with the current `strokeStyle` and `lineWidth`. */
     stroke(): void;
+    /** Stroke an axis-aligned rectangle outline. */
     strokeRect(x: number, y: number, w: number, h: number): void;
+    /** Color, gradient, or pattern used by `stroke` and `strokeRect`. */
     strokeStyle: string | CanvasGradient | CanvasPattern;
+    /** Width in pixels of the line drawn by `stroke` / `strokeRect`. */
     lineWidth: number;
+    /** Color, gradient, or pattern used by `fill` and `fillRect`. */
     fillStyle: string | CanvasGradient | CanvasPattern;
+    /** Fill an axis-aligned rectangle with the current `fillStyle`. */
     fillRect(x: number, y: number, w: number, h: number): void;
+    /** Save the current drawing state (transform, styles) onto the state stack. */
     save(): void;
+    /** Restore the most recently saved drawing state. */
     restore(): void;
+    /** Translate the coordinate system by `(x, y)`. */
     translate(x: number, y: number): void;
+    /** Rotate the coordinate system clockwise by `angle` radians. */
     rotate(angle: number): void;
 }
-/** Platform-specific canvas operations */
+/** Platform-specific canvas operations. Each runtime entry point registers an implementation via {@link setPlatform}. */
 export interface CanvasPlatform {
+    /** Create a blank canvas of the given width and height. */
     createCanvas(width: number, height: number): CanvasLike;
+    /** Decode an image from a buffer or URL and draw it onto a fresh canvas. */
     loadImage(source: ArrayBuffer | string): Promise<CanvasLike>;
+    /** Type guard for "is this value a canvas of this platform?". */
     isCanvas(value: unknown): value is CanvasLike;
 }
 /** Register the platform-specific canvas implementation */

package/canvas-toolkit.base.d.ts

@@ -1,7 +1,8 @@
 import type { BoundingBox } from "./index.interface.js";
 import type { CanvasLike, Context2DLike } from "./canvas-factory.js";
-/** Structural interface for contour-like objects with 32-bit signed integer point data */
+/** Structural interface for contour-like objects with 32-bit signed integer point data. */
 export interface ContourLike {
+    /** Flat `[x0, y0, x1, y1, ...]` point array. Matches `cv.Mat.data32S` for contour Mats. */
     data32S: Int32Array | number[];
 }
 /**

package/canvas-toolkit.d.ts

@@ -7,6 +7,7 @@ import { CanvasToolkitBase } from "./canvas-toolkit.base.js";
 export declare class CanvasToolkit extends CanvasToolkitBase {
     private static _nodeInstance;
     protected constructor();
+    /** Return the singleton instance of {@link CanvasToolkit}. */
     static getInstance(): CanvasToolkit;
     /**
      * Save a canvas to an image file

package/cv-provider.d.ts

@@ -18,9 +18,11 @@ type CV = typeof _cvType;
  */
 export declare function setCv(instance: CV): void;
 /**
- * TypeScript Declaration Merging:
- * By exporting both a `namespace cv` and a `const cv`, consumers importing `{ cv }`
- * get BOTH the types (e.g. `cv.Mat`) AND the runtime Proxy object.
+ * Type-side companion to the {@link cv} runtime proxy.
+ *
+ * Re-exports the OpenCV.js type aliases (Mat, Rect, Size, enum constants…) under
+ * the `cv.` namespace, so consumers importing `{ cv }` get the types AND the
+ * runtime Proxy object via TypeScript's declaration-merging rules.
  */
 export declare namespace cv {
     /** OpenCV Mat (matrix / image buffer). */

package/deskew.d.ts

@@ -38,6 +38,10 @@ export interface DeskewOptions {
 export declare class DeskewService {
     private readonly verbose;
     private readonly minimumAreaThreshold;
+    /**
+     * Create a DeskewService.
+     * @param options - Configuration. See {@link DeskewOptions}.
+     */
     constructor(options?: DeskewOptions);
     private log;
     /**

package/image-processor.d.ts

@@ -25,8 +25,11 @@ type NameWithOptionalOptions = Exclude<OperationName, NameWithRequiredOptions>;
  * ```
  */
 export declare class ImageProcessor {
+    /** Underlying OpenCV Mat. Each operation deletes the previous Mat and replaces this reference. */
     img: cv.Mat;
+    /** Current image width in pixels, kept in sync with `img.cols`. */
     width: number;
+    /** Current image height in pixels, kept in sync with `img.rows`. */
     height: number;
     /**
      * Create an ImageProcessor instance from a Canvas or cv.Mat

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ppu-ocv",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "description": "A type-safe, modular, chainable image processing library built on top of OpenCV.js with a fluent API leveraging pipeline processing.",
   "keywords": [
     "open-cv",

package/pipeline/types.d.ts

@@ -54,19 +54,33 @@ export type OperationFunction<T> = (img: cv.Mat, options: T) => OperationResult;
  * it stays an interface rather than a type alias.
  */
 export interface RegisteredOperations {
+    /** Adaptive (windowed) thresholding. See {@link AdaptiveThresholdOptions}. */
     adaptiveThreshold: AdaptiveThresholdOptions;
+    /** Gaussian blur. See {@link BlurOptions}. */
     blur: BlurOptions;
+    /** Constant-color border around the image. See {@link BorderOptions}. */
     border: BorderOptions;
+    /** Canny edge detection. See {@link CannyOptions}. */
     canny: CannyOptions;
+    /** Convert Mat depth/channel type. See {@link ConvertOptions}. */
     convert: ConvertOptions;
+    /** Morphological dilation. See {@link DilateOptions}. */
     dilate: DilateOptions;
+    /** Morphological erosion. See {@link ErodeOptions}. */
     erode: ErodeOptions;
+    /** Convert to grayscale via `COLOR_RGBA2GRAY`. See {@link GrayscaleOptions}. */
     grayscale: GrayscaleOptions;
+    /** Bitwise-NOT color inversion. See {@link InvertOptions}. */
     invert: InvertOptions;
+    /** Morphological gradient (dilation minus erosion). See {@link MorphologicalGradientOptions}. */
     morphologicalGradient: MorphologicalGradientOptions;
+    /** Resize to absolute pixel dimensions. See {@link ResizeOptions}. */
     resize: ResizeOptions;
+    /** Affine rotation around a pivot point. See {@link RotateOptions}. */
     rotate: RotateOptions;
+    /** Global threshold (including Otsu). See {@link ThresholdOptions}. */
     threshold: ThresholdOptions;
+    /** Four-point perspective warp. See {@link WarpOptions}. */
     warp: WarpOptions;
 }
 /** Union of all registered operation names. Extend {@link RegisteredOperations} to add new ones. */