@vectojs/core 0.1.0 → 0.2.1

package/dist/components/SplineEntity.d.ts

@@ -0,0 +1,144 @@
+import { Bounds, Entity } from '../tree/Entity';
+import { IRenderer } from '../renderer/IRenderer';
+/** One piecewise-cubic segment: x(t) and y(t) as `[a,b,c,d]` polynomial coefficients. */
+export interface SplineSegment {
+    start_t: number;
+    end_t: number;
+    x_poly: number[];
+    y_poly: number[];
+}
+/**
+ * Color of a spline equation: an `[r,g,b]` triple in `0..1`, a linear-gradient
+ * descriptor, or `null` (use the entity's default color).
+ */
+export type SplineColor = [number, number, number] | {
+    stops: [number, [number, number, number]][];
+    start_pos: [number, number];
+    end_pos: [number, number];
+} | null;
+/** A single curve (one stroke color) made of consecutive {@link SplineSegment}s. */
+export interface SplineEquation {
+    color_rgb: SplineColor;
+    data: SplineSegment[];
+}
+/** The native vectomancy `Spline` document. */
+export interface SplineDocument {
+    type: 'Spline' | 'Polyline';
+    equations?: SplineEquation[];
+    paths?: {
+        color_rgb: SplineColor;
+        data: {
+            x: number;
+            y: number;
+        }[];
+    }[];
+    bounding_box?: [number, number, number, number];
+}
+/** Construction options for {@link SplineEntity}. */
+export interface SplineOptions {
+    /** Stroke width in local units. Default `2`. */
+    lineWidth?: number;
+    /** Bake to an OffscreenCanvas once and `drawImage` each frame. Default `true`. */
+    cache?: boolean;
+    /** Color used when an equation's `color_rgb` is `null`. Default `#e2e8f0`. */
+    defaultColor?: string;
+    /**
+     * Hit-test strategy:
+     * - `'curve'` (default): precise — a point hits only within `lineWidth/2 +
+     *   hitTolerance` of an actual curve.
+     * - `'aabb'`: coarse — anywhere in the bounding box hits.
+     */
+    hitTest?: 'curve' | 'aabb';
+    /** Extra pick padding (local units) added to `lineWidth/2` in `'curve'` mode. Default `0`. */
+    hitTolerance?: number;
+}
+/** Cubic Bézier control points produced from a {@link SplineSegment}. */
+export interface BezierControlPoints {
+    x0: number;
+    y0: number;
+    cp1x: number;
+    cp1y: number;
+    cp2x: number;
+    cp2y: number;
+    x3: number;
+    y3: number;
+}
+/**
+ * Convert one cubic-polynomial segment to Bézier control points.
+ *
+ * For a coefficient vector `[a,b,c,d]` describing `f(t)=a+bt+ct²+dt³` on `t∈[0,1]`,
+ * the equivalent Bézier control values are `a`, `a+b/3`, `a+2b/3+c/3`, `a+b+c+d`.
+ * Applied independently to the x and y polynomials.
+ *
+ * @param seg - The polynomial segment.
+ * @returns The cubic Bézier control points.
+ */
+export declare function polySegmentToBezier(seg: SplineSegment): BezierControlPoints;
+/**
+ * Renders a native vectomancy `Spline` document (piecewise-cubic curves) to canvas.
+ *
+ * Bounds come from the document's `bounding_box` (or are computed from segment
+ * endpoints), so the entity participates in {@link Scene} viewport culling. By
+ * default the curves are baked once into an `OffscreenCanvas` and blitted each
+ * frame; without `OffscreenCanvas` it strokes the Bézier paths per frame.
+ *
+ * @example
+ * const doc = await loadSpline('/ast/logo.json');
+ * scene.add(new SplineEntity(doc).setPosition(100, 100));
+ */
+export declare class SplineEntity extends Entity {
+    doc: SplineDocument;
+    lineWidth: number;
+    defaultColor: string;
+    hitTolerance: number;
+    private cache;
+    private hitMode;
+    private bounds;
+    private offscreen;
+    private baked;
+    /** Lazily-flattened polylines (one Float32Array of [x,y,...] per segment) for hit-testing. */
+    private polylines;
+    /**
+     * When `true`, the renderer draws a rounded-rect outline of the entity's
+     * local bounds after painting the curves. Useful for drag feedback and
+     * debugging hit areas. Defaults to `false`.
+     */
+    showBounds: boolean;
+    constructor(doc: SplineDocument, opts?: SplineOptions);
+    private computeBounds;
+    /** @inheritdoc */
+    getBounds(): Bounds;
+    /**
+     * AABB hit-test against the document bounds in world space.
+     *
+     * Curve-accurate hit-testing can be layered on later via {@link hitTestCurve};
+     * this method already calls it as a refinement when it is overridden.
+     */
+    isPointInside(globalX: number, globalY: number): boolean;
+    /**
+     * Curve-accurate refinement of {@link isPointInside}: hit only when the local
+     * point lies within `lineWidth/2 + hitTolerance` of an actual curve.
+     *
+     * Returns `null` in `hitTest: 'aabb'` mode (keep the bounding-box result).
+     * Curves are flattened to polylines once and cached. Override for custom logic.
+     *
+     * @param localX - X in the entity's local space.
+     * @param localY - Y in the entity's local space.
+     * @returns `true`/`false`, or `null` to keep the AABB result.
+     */
+    protected hitTestCurve(localX: number, localY: number): boolean | null;
+    /** Flatten every Bézier segment into a sampled polyline once, then cache. */
+    private getPolylines;
+    private resolveColor;
+    private strokeEquations;
+    /** Bake all equations into an OffscreenCanvas once (when available). */
+    private bake;
+    render(r: IRenderer): void;
+}
+/**
+ * Fetch and parse a vectomancy `Spline` JSON document (browser only).
+ *
+ * @param url - URL of the `.json` spline document.
+ * @returns The parsed {@link SplineDocument}.
+ */
+export declare function loadSpline(url: string): Promise<SplineDocument>;

package/dist/components/TextEntity.d.ts

@@ -0,0 +1,35 @@
+import { Entity } from '../tree/Entity';
+import { IRenderer } from '../renderer/IRenderer';
+export declare class TextEntity extends Entity {
+    text: string;
+    private atlas;
+    private layout;
+    private prepared;
+    private nodes;
+    fontSize: number;
+    fillStyle: string | any;
+    strokeStyle: string | any;
+    hoveredFillStyle: string | any;
+    lineWidth: number;
+    private isHovered;
+    constructor(text: string, atlas: any, maxWidth: number, fontSize?: number);
+    /**
+     * Replace the text content. Runs the **cold** measurement pass (re-segment +
+     * re-measure) since the glyphs changed, then re-lays out.
+     *
+     * @returns `this` for chaining.
+     */
+    setText(text: string): this;
+    /**
+     * Change the wrap width and reflow. Cheap **hot** path only — reuses the
+     * cached {@link PreparedText}, doing no re-segmentation or re-measurement.
+     * Ideal for responsive resize.
+     *
+     * @returns `this` for chaining.
+     */
+    setMaxWidth(maxWidth: number): this;
+    /** Hot pass: place the cached {@link PreparedText} and refresh the a11y box. */
+    private applyLayout;
+    isPointInside(globalX: number, globalY: number): boolean;
+    render(renderer: IRenderer): void;
+}