@netless/appliance-plugin 1.0.0-beta.0

package/dist/core/utils/index.d.ts

@@ -0,0 +1,364 @@
+import { Box2d } from './primitives/Box2d';
+import { Vec2d, VecLike } from './primitives/Vec2d';
+export * from "./math";
+export * from "./spriteNode";
+/** @public */
+export declare function precise(A: VecLike): string;
+/** @public */
+export declare function average(A: VecLike, B: VecLike): string;
+/** @public */
+export declare const PI: number;
+/** @public */
+export declare const TAU: number;
+/** @public */
+export declare const PI2: number;
+/** @public */
+export declare const EPSILON: number;
+/** @public */
+export declare const SIN: (x: number) => number;
+/**
+ * Clamp a value into a range.
+ *
+ * @example
+ *
+ * ```ts
+ * const A = clamp(0, 1) // 1
+ * ```
+ *
+ * @param n - The number to clamp.
+ * @param min - The minimum value.
+ * @public
+ */
+export declare function clamp(n: number, min: number): number;
+/**
+ * Clamp a value into a range.
+ *
+ * @example
+ *
+ * ```ts
+ * const A = clamp(0, 1, 10) // 1
+ * const B = clamp(11, 1, 10) // 10
+ * const C = clamp(5, 1, 10) // 5
+ * ```
+ *
+ * @param n - The number to clamp.
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @public
+ */
+export declare function clamp(n: number, min: number, max: number): number;
+/**
+ * Get a number to a precision.
+ *
+ * @param n - The number.
+ * @param precision - The precision.
+ * @public
+ */
+export declare function toPrecision(n: number, precision?: number): number;
+/**
+ * Whether two numbers numbers a and b are approximately equal.
+ *
+ * @param a - The first point.
+ * @param b - The second point.
+ * @public
+ */
+export declare function approximately(a: number, b: number, precision?: number): boolean;
+/**
+ * Find the approximate perimeter of an ellipse.
+ *
+ * @param rx - The ellipse's x radius.
+ * @param ry - The ellipse's y radius.
+ * @public
+ */
+export declare function perimeterOfEllipse(rx: number, ry: number): number;
+/**
+ * @param a - Any angle in radians
+ * @returns A number between 0 and 2 * PI
+ * @public
+ */
+export declare function canonicalizeRotation(a: number): number;
+/**
+ * Get the clockwise angle distance between two angles.
+ *
+ * @param a0 - The first angle.
+ * @param a1 - The second angle.
+ * @public
+ */
+export declare function clockwiseAngleDist(a0: number, a1: number): number;
+/**
+ * Get the counter-clockwise angle distance between two angles.
+ *
+ * @param a0 - The first angle.
+ * @param a1 - The second angle.
+ * @public
+ */
+export declare function counterClockwiseAngleDist(a0: number, a1: number): number;
+/**
+ * Get the short angle distance between two angles.
+ *
+ * @param a0 - The first angle.
+ * @param a1 - The second angle.
+ * @public
+ */
+export declare function shortAngleDist(a0: number, a1: number): number;
+/**
+ * Get the long angle distance between two angles.
+ *
+ * @param a0 - The first angle.
+ * @param a1 - The second angle.
+ * @public
+ */
+export declare function longAngleDist(a0: number, a1: number): number;
+/**
+ * Interpolate an angle between two angles.
+ *
+ * @param a0 - The first angle.
+ * @param a1 - The second angle.
+ * @param t - The interpolation value.
+ * @public
+ */
+export declare function lerpAngles(a0: number, a1: number, t: number): number;
+/**
+ * Get the short distance between two angles.
+ *
+ * @param a0 - The first angle.
+ * @param a1 - The second angle.
+ * @public
+ */
+export declare function angleDelta(a0: number, a1: number): number;
+/**
+ * Get the "sweep" or short distance between two points on a circle's perimeter.
+ *
+ * @param C - The center of the circle.
+ * @param A - The first point.
+ * @param B - The second point.
+ * @public
+ */
+export declare function getSweep(C: VecLike, A: VecLike, B: VecLike): number;
+/**
+ * Clamp radians within 0 and 2PI
+ *
+ * @param r - The radian value.
+ * @public
+ */
+export declare function clampRadians(r: number): number;
+/**
+ * Clamp rotation to even segments.
+ *
+ * @param r - The rotation in radians.
+ * @param segments - The number of segments.
+ * @public
+ */
+export declare function snapAngle(r: number, segments: number): number;
+/**
+ * Checks whether two angles are approximately at right-angles or parallel to each other
+ *
+ * @param a - Angle a (radians)
+ * @param b - Angle b (radians)
+ * @returns True iff the angles are approximately at right-angles or parallel to each other
+ * @public
+ */
+export declare function areAnglesCompatible(a: number, b: number): boolean;
+/**
+ * Is angle c between angles a and b?
+ *
+ * @param a - The first angle.
+ * @param b - The second angle.
+ * @param c - The third angle.
+ * @public
+ */
+export declare function isAngleBetween(a: number, b: number, c: number): boolean;
+/**
+ * Convert degrees to radians.
+ *
+ * @param d - The degree in degrees.
+ * @public
+ */
+export declare function degreesToRadians(d: number): number;
+/**
+ * Convert radians to degrees.
+ *
+ * @param r - The degree in radians.
+ * @public
+ */
+export declare function radiansToDegrees(r: number): number;
+/**
+ * Get the length of an arc between two points on a circle's perimeter.
+ *
+ * @param C - The circle's center as [x, y].
+ * @param r - The circle's radius.
+ * @param A - The first point.
+ * @param B - The second point.
+ * @public
+ */
+export declare function getArcLength(C: VecLike, r: number, A: VecLike, B: VecLike): number;
+/**
+ * Get a point on the perimeter of a circle.
+ *
+ * @param cx - The center x of the circle.
+ * @param cy - The center y of the circle.
+ * @param r - The radius of the circle.
+ * @param a - The normalized point on the circle.
+ * @public
+ */
+export declare function getPointOnCircle(cx: number, cy: number, r: number, a: number): Vec2d;
+/** @public */
+export declare function getPolygonVertices(width: number, height: number, sides: number): Vec2d[];
+/**
+ * @param a0 - The start point in the A range
+ * @param a1 - The end point in the A range
+ * @param b0 - The start point in the B range
+ * @param b1 - The end point in the B range
+ * @returns True if the ranges overlap
+ * @public
+ */
+export declare function rangesOverlap(a0: number, a1: number, b0: number, b1: number): boolean;
+/**
+ * Finds the intersection of two ranges.
+ *
+ * @param a0 - The start point in the A range
+ * @param a1 - The end point in the A range
+ * @param b0 - The start point in the B range
+ * @param b1 - The end point in the B range
+ * @returns The intersection of the ranges, or null if no intersection
+ * @public
+ */
+export declare function rangeIntersection(a0: number, a1: number, b0: number, b1: number): [number, number] | null;
+/**
+ * Gets the width/height of a star given its input bounds.
+ *
+ * @param sides - Number of sides
+ * @param w - T target width
+ * @param h - Target height
+ * @returns Box2d
+ * @public
+ */
+export declare const getStarBounds: (sides: number, w: number, h: number) => Box2d;
+/**
+ * Utils for working with points.
+ *
+ * @public
+ */
+/**
+ * Get whether a point is inside of a circle.
+ *
+ * @param A - The point to check.
+ * @param C - The circle's center point as [x, y].
+ * @param r - The circle's radius.
+ * @returns Boolean
+ * @public
+ */
+export declare function pointInCircle(A: VecLike, C: VecLike, r: number): boolean;
+/**
+ * Get whether a point is inside of an ellipse.
+ *
+ * @param point - The point to check.
+ * @param center - The ellipse's center point as [x, y].
+ * @param rx - The ellipse's x radius.
+ * @param ry - The ellipse's y radius.
+ * @param rotation - The ellipse's rotation.
+ * @returns Boolean
+ * @public
+ */
+export declare function pointInEllipse(A: VecLike, C: VecLike, rx: number, ry: number, rotation?: number): boolean;
+/**
+ * Get whether a point is inside of a rectangle.
+ *
+ * @param A - The point to check.
+ * @param point - The rectangle's top left point as [x, y].
+ * @param size - The rectangle's size as [width, height].
+ * @public
+ */
+export declare function pointInRect(A: VecLike, point: VecLike, size: VecLike): boolean;
+/**
+ * Get whether a point is inside of a polygon.
+ *
+ * ```ts
+ * const result = pointInPolygon(myPoint, myPoints)
+ * ```
+ *
+ * @public
+ */
+export declare function pointInPolygon(A: VecLike, points: VecLike[]): boolean;
+/**
+ * Get whether a point is inside of a bounds.
+ *
+ * @param A - The point to check.
+ * @param b - The bounds to check.
+ * @returns Boolean
+ * @public
+ */
+export declare function pointInBounds(A: VecLike, b: Box2d): boolean;
+/**
+ * Hit test a point and a polyline using a minimum distance.
+ *
+ * @param A - The point to check.
+ * @param points - The points that make up the polyline.
+ * @param distance - The mininum distance that qualifies a hit.
+ * @returns Boolean
+ * @public
+ */
+export declare function pointInPolyline(A: VecLike, points: VecLike[], distance?: number): boolean;
+/**
+ * Get whether a point is within a certain distance from a polyline.
+ *
+ * @param A - The point to check.
+ * @param points - The points that make up the polyline.
+ * @param distance - The mininum distance that qualifies a hit.
+ * @public
+ */
+export declare function pointNearToPolyline(A: VecLike, points: VecLike[], distance?: number): boolean;
+/**
+ * Get whether a point is within a certain distance from a line segment.
+ *
+ * @param A - The point to check.
+ * @param p1 - The polyline's first point.
+ * @param p2 - The polyline's second point.
+ * @param distance - The mininum distance that qualifies a hit.
+ * @public
+ */
+export declare function pointNearToLineSegment(A: VecLike, p1: VecLike, p2: VecLike, distance?: number): boolean;
+/**
+ * Simplify a line (using Ramer-Douglas-Peucker algorithm).
+ *
+ * @param points - An array of points as [x, y, ...][]
+ * @param tolerance - The minimum line distance (also called epsilon).
+ * @returns Simplified array as [x, y, ...][]
+ * @public
+ */
+export declare function simplify(points: VecLike[], tolerance?: number): VecLike[];
+/** @public */
+export declare function simplify2(points: VecLike[], tolerance?: number): VecLike[];
+/** @public */
+export declare function getMinX(pts: VecLike[]): number;
+/** @public */
+export declare function getMinY(pts: VecLike[]): number;
+/** @public */
+export declare function getMaxX(pts: VecLike[]): number;
+/** @public */
+export declare function getMaxY(pts: VecLike[]): number;
+/** @public */
+export declare function getMidX(pts: VecLike[]): number;
+/** @public */
+export declare function getMidY(pts: VecLike[]): number;
+/** @public */
+export declare function getWidth(pts: VecLike[]): number;
+/** @public */
+export declare function getHeight(pts: VecLike[]): number;
+/**
+ * The DOM likes values to be fixed to 3 decimal places
+ *
+ * @public
+ */
+export declare function toDomPrecision(v: number): number;
+/**
+ * @public
+ */
+export declare function toFixed(v: number): number;
+/**
+ * Check if a float is safe to use. ie: Not too big or small.
+ * @public
+ */
+export declare const isSafeFloat: (n: number) => boolean;
+export declare const requestAsyncCallBack: (callBack: () => void, timeout: number) => Promise<void>;
+export declare const getRatioWithContext: (context: CanvasRenderingContext2D) => number;

package/dist/core/utils/math.d.ts

@@ -0,0 +1,57 @@
+import { Group } from "spritejs";
+import { IRectType } from "../types";
+import { Point2d } from "./primitives/Point2d";
+import { Vec2d } from "./primitives/Vec2d";
+import type { Rectangle } from "../types";
+export declare function outerRect(rect: IRectType, offset: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function interRect(rect: IRectType, offset: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function computRect(rect1?: IRectType, rect2?: IRectType): IRectType | undefined;
+export declare function computRectangle(rect1?: Rectangle, rect2?: Rectangle): Rectangle | undefined;
+export declare function getRectFromPoints(points: (Point2d | Vec2d)[], offset?: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function isIntersect(rect1: IRectType, rect2: IRectType): boolean;
+export declare function isSameArray(a: Array<string | number>, b: Array<string | number>): boolean;
+export declare function getSafetyRect(oldRect: IRectType, tolerance?: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function getRectTranslated(rect: IRectType, translate: [number, number]): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function getRectRotated(rect: IRectType, angle: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function getRectScaleed(rect: IRectType, scale: [number, number]): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function rotatePoints(points: number[], originPos: [number, number], angle: number): void;
+export declare function scalePoints(points: number[], originPos: [number, number], scale: [number, number]): void;
+export declare function getNodeRect(key: string, layer?: Group, safeBorderPadding?: number): IRectType | undefined;
+export declare function isIntersectForPoint(point: [number, number], rect: IRectType): boolean;
+export declare const getLineSegIntersection: (p1: [number, number], p2: [number, number], p3: [number, number], p4: [number, number]) => [number, number] | null;
+export declare function getWHRatio(w: number, h: number): [number, number];

package/dist/core/utils/primitives/Box2d.d.ts

@@ -0,0 +1,100 @@
+import { Vec2d, VecLike } from './Vec2d';
+/**
+ * A serializable model for 2D boxes.
+ *
+ * @public */
+export interface Box2dModel {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** @public */
+export type SelectionEdge = 'top' | 'right' | 'bottom' | 'left';
+/** @public */
+export type SelectionCorner = 'top_left' | 'top_right' | 'bottom_right' | 'bottom_left';
+/** @public */
+export type SelectionHandle = SelectionEdge | SelectionCorner;
+/** @public */
+export type RotateCorner = 'top_left_rotate' | 'top_right_rotate' | 'bottom_right_rotate' | 'bottom_left_rotate' | 'mobile_rotate';
+/** @public */
+export declare class Box2d {
+    constructor(x?: number, y?: number, w?: number, h?: number);
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    get point(): Vec2d;
+    set point(val: Vec2d);
+    get minX(): number;
+    set minX(n: number);
+    get midX(): number;
+    get maxX(): number;
+    get minY(): number;
+    set minY(n: number);
+    get midY(): number;
+    get maxY(): number;
+    get width(): number;
+    set width(n: number);
+    get height(): number;
+    set height(n: number);
+    get aspectRatio(): number;
+    get center(): Vec2d;
+    set center(v: Vec2d);
+    get corners(): Vec2d[];
+    get snapPoints(): Vec2d[];
+    get sides(): Array<[Vec2d, Vec2d]>;
+    get size(): Vec2d;
+    toFixed(): this;
+    setTo(B: Box2d): this;
+    set(x?: number, y?: number, w?: number, h?: number): this;
+    expand(A: Box2d): this;
+    expandBy(n: number): this;
+    scale(n: number): this;
+    clone(): Box2d;
+    translate(delta: VecLike): this;
+    snapToGrid(size: number): void;
+    collides(B: Box2d): boolean;
+    contains(B: Box2d): boolean;
+    includes(B: Box2d): boolean;
+    containsPoint(V: VecLike, margin?: number): boolean;
+    getHandlePoint(handle: SelectionCorner | SelectionEdge): Vec2d;
+    toJson(): Box2dModel;
+    resize(handle: SelectionCorner | SelectionEdge | string, dx: number, dy: number): void;
+    union(box: Box2dModel): this;
+    static From(box: Box2dModel): Box2d;
+    static FromPoints(points: VecLike[]): Box2d;
+    static Expand(A: Box2d, B: Box2d): Box2d;
+    static ExpandBy(A: Box2d, n: number): Box2d;
+    static Collides: (A: Box2d, B: Box2d) => boolean;
+    static Contains: (A: Box2d, B: Box2d) => boolean;
+    static Includes: (A: Box2d, B: Box2d) => boolean;
+    static ContainsPoint: (A: Box2d, B: VecLike, margin?: number) => boolean;
+    static Common: (boxes: Box2d[]) => Box2d;
+    static Sides: (A: Box2d, inset?: number) => Vec2d[][];
+    static Resize(box: Box2d, handle: SelectionCorner | SelectionEdge | string, dx: number, dy: number, isAspectRatioLocked?: boolean): {
+        box: Box2d;
+        scaleX: number;
+        scaleY: number;
+    };
+    equals(other: Box2d | Box2dModel): boolean;
+    static Equals(a: Box2d | Box2dModel, b: Box2d | Box2dModel): boolean;
+    zeroFix(): this;
+    static ZeroFix(other: Box2d | Box2dModel): Box2d;
+}
+/** @public */
+export declare function flipSelectionHandleY(handle: SelectionHandle): "top" | "bottom" | "left" | "right" | "top_left" | "top_right" | "bottom_right" | "bottom_left";
+/** @public */
+export declare function flipSelectionHandleX(handle: SelectionHandle): "top" | "bottom" | "left" | "right" | "top_left" | "top_right" | "bottom_right" | "bottom_left";
+/** @public */
+export declare function rotateSelectionHandle(handle: SelectionHandle, rotation: number): SelectionHandle;
+/** @public */
+export declare function isSelectionCorner(selection: string): selection is SelectionCorner;
+/** @public */
+export declare const ROTATE_CORNER_TO_SELECTION_CORNER: {
+    readonly top_left_rotate: "top_left";
+    readonly top_right_rotate: "top_right";
+    readonly bottom_right_rotate: "bottom_right";
+    readonly bottom_left_rotate: "bottom_left";
+    readonly mobile_rotate: "top_left";
+};

package/dist/core/utils/primitives/Point2d.d.ts

@@ -0,0 +1,71 @@
+import { Vec2d, Vec2dSimple, VecLike } from "./Vec2d";
+/**
+ * A serializable model for 2D vectors.
+ *
+ * @public */
+export interface Point2dModel extends Vec2dSimple {
+    /** 压力值 */
+    z: number;
+    /** 基于上一点的向量 */
+    v?: VecLike;
+    /** 时间戳 */
+    t?: number;
+    /** 当前点基于前后两个点的夹角度数(0-360) */
+    a?: number;
+}
+/** @public */
+export type PointLike = Point2d | Point2dModel;
+/** @public */
+export declare class Point2d extends Vec2d {
+    x: number;
+    y: number;
+    z: number;
+    v: {
+        x: number;
+        y: number;
+    };
+    t: number;
+    a: number;
+    constructor(x?: number, y?: number, z?: number, v?: {
+        x: number;
+        y: number;
+    }, t?: number, a?: number);
+    get timestamp(): number;
+    get pressure(): number;
+    get angleNum(): number;
+    get XY(): [number, number];
+    setA(a: number): void;
+    setT(t: number): void;
+    setv(v: Vec2dSimple): this;
+    set(x?: number, y?: number, z?: number, v?: {
+        x: number;
+        y: number;
+    }, t?: number, a?: number): this;
+    clone(): Point2d;
+    distance(p: Point2d): number;
+    isNear(p: Point2d, tolerance: number): boolean;
+    getAngleByPoints(pre: Point2d, next: Point2d): number;
+    static Sub(A: PointLike, B: VecLike): Point2d;
+    static Add(A: PointLike, B: VecLike): Point2d;
+    static GetDistance(p0: Point2d, p1: Point2d): number;
+    static GetAngleByPoints(pre: Point2d, cur: Point2d, next: Point2d): number;
+    static IsNear(p0: Point2d, p1: Point2d, tolerance: number): boolean;
+    static RotWith(A: Point2d | Vec2d, C: Point2d | Vec2d, r: number, decimal?: number): Point2d;
+    /**
+     * 根据圆心和半径，获取圆上的等份点
+     * @param o 圆心
+     * @param radius 半径
+     * @param average 均分数
+     * @returns
+     */
+    static GetDotStroke(o: Point2d, radius: number, average?: number): Point2d[];
+    /**
+     * 根据圆心和圆上的起始点，获取半圆上的等份点
+     * @param o 圆心
+     * @param p 圆弧起始点
+     * @param radian 1，逆时针180度 -1，顺时针
+     * @param average 均分数
+     * @returns
+     */
+    static GetSemicircleStroke(o: Point2d, p: Point2d, radian?: number, average?: number): Point2d[];
+}