reacthub-pixitweenjs 0.2.109-alpha.7 → 0.3.0-alpha.3

package/dist/lib/pixi-essentials/bounds/AxisAlignedBounds.d.ts

@@ -0,0 +1,121 @@
+import { Point } from 'pixi.js';
+/**
+ * Rectangle object is an area defined by its position, as indicated by its top-left corner
+ * point (x, y) and by its width and its height.
+ *
+ * @public
+ */
+export declare class AxisAlignedBounds {
+    currentID: number;
+    dirtyID: number;
+    protected _x: number;
+    protected _y: number;
+    protected _width: number;
+    protected _height: number;
+    protected _hull: [Point, Point, Point, Point];
+    /**
+     * @param [x=0] - The X coordinate of the upper-left corner of the rectangle
+     * @param [y=0] - The Y coordinate of the upper-left corner of the rectangle
+     * @param [width=0] - The overall width of this rectangle
+     * @param [height=0] - The overall height of this rectangle
+     */
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get hull(): Point[];
+    get topLeft(): Point;
+    get topRight(): Point;
+    get bottomRight(): Point;
+    get bottomLeft(): Point;
+    protected isDirty(): boolean;
+    protected update(): void;
+    /**
+     * returns the left edge of the rectangle
+     *
+     * @member {number}
+     */
+    get left(): number;
+    /**
+     * returns the right edge of the rectangle
+     */
+    get right(): number;
+    /**
+     * returns the top edge of the rectangle
+     */
+    get top(): number;
+    /**
+     * returns the bottom edge of the rectangle
+     */
+    get bottom(): number;
+    /**
+     * Creates a clone of this Rectangle
+     *
+     * @return A copy of this AxisAlignedBounds.
+     */
+    clone(): AxisAlignedBounds;
+    /**
+     * Copies another rectangle to this one.
+     *
+     * @param rectangle - The rectangle to copy from.
+     * @return Returns itself.
+     */
+    copyFrom(rectangle: AxisAlignedBounds): AxisAlignedBounds;
+    /**
+     * Copies this rectangle to another one.
+     *
+     * @param rectangle - The rectangle to copy to.
+     * @return Returns given parameter.
+     */
+    copyTo(rectangle: AxisAlignedBounds): AxisAlignedBounds;
+    /**
+     * Checks whether the x and y coordinates given are contained within this Rectangle
+     *
+     * @param x - The X coordinate of the point to test
+     * @param y - The Y coordinate of the point to test
+     * @return Whether the x/y coordinates are within this Rectangle
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * Checks whether the given {@code bounds} are equal to this.
+     *
+     * @param bounds
+     */
+    equals(bounds: AxisAlignedBounds): boolean;
+    /**
+     * Pads the rectangle making it grow in all directions.
+     * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
+     *
+     * @param [paddingX=0] - The horizontal padding amount.
+     * @param [paddingY=0] - The vertical padding amount.
+     * @return Returns itself.
+     */
+    pad(paddingX?: number, paddingY?: number): this;
+    /**
+     * Fits this rectangle around the passed one.
+     *
+     * @param rectangle - The rectangle to fit.
+     * @return Returns itself.
+     */
+    fit(rectangle: AxisAlignedBounds): this;
+    /**
+     * Enlarges rectangle that way its corners lie on grid
+     *
+     * @param [resolution=1] - resolution
+     * @param [eps=0.001] - precision
+     * @return Returns itself.
+     */
+    ceil(resolution?: number, eps?: number): this;
+    /**
+     * Enlarges this rectangle to include the passed rectangle.
+     *
+     * @param rectangle - The rectangle to include.
+     * @return Returns itself.
+     */
+    enlarge(rectangle: AxisAlignedBounds): this;
+}

package/dist/lib/pixi-essentials/bounds/OrientedBounds.d.ts

@@ -0,0 +1,103 @@
+import { AxisAlignedBounds } from './AxisAlignedBounds';
+import { Matrix, Point } from 'pixi.js';
+/**
+ * An oriented bounding box is a rotated rectangle.
+ *
+ * An oriented bounding box is modelled by rotating its (axis-aligned) {@link OrientedBounds#innerBounds}
+ * by an angle {@link OrientedBounds#angle} around its center. The center of an oriented bounding box and
+ * its axis-aligned inner-bounds coincide.
+ *
+ * @public
+ */
+export declare class OrientedBounds {
+    innerBounds: AxisAlignedBounds;
+    currentID: number;
+    dirtyID: number;
+    protected _rotation: number;
+    protected _center: Point;
+    protected _hull: [Point, Point, Point, Point];
+    protected _matrix: Matrix;
+    /**
+     * @param innerBounds
+     * @param angle
+     */
+    constructor(innerBounds: AxisAlignedBounds, angle?: number);
+    /**
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @param angle
+     */
+    constructor(x?: number, y?: number, width?: number, height?: number, angle?: number);
+    /**
+     * The angle, in radians, by which this bounding box is tilted.
+     */
+    get rotation(): number;
+    set rotation(value: number);
+    /**
+     * The center of this bounding box.
+     *
+     * The center of this and {@code this.innerBounds} will always coincide.
+     */
+    get center(): Point;
+    set center(value: Point);
+    /**
+     * The four-corners of this bounding, in clockwise order starting from the top-left.
+     *
+     * @readonly
+     */
+    get hull(): [Point, Point, Point, Point];
+    /**
+     * The top-left corner of this bounding box. The returned instance should not be modified directly.
+     *
+     * @readonly
+     */
+    get topLeft(): Point;
+    /**
+     * The top-right corner of this bounding box. The returned instance should not be modified directly.
+     *
+     * @readonly
+     */
+    get topRight(): Point;
+    /**
+     * The bottom-right corner of this bounding box. The returned instance should not be modified directly.
+     */
+    get bottomRight(): Point;
+    /**
+     * The bottom-left corner of this bounding box. The returned instance should not be modified directly.
+     */
+    get bottomLeft(): Point;
+    /**
+     * Checks whether the given {@code bounds} are equal to this.
+     *
+     * @param bounds
+     */
+    equals(bounds: OrientedBounds): boolean;
+    /**
+     * Whether this bounding box contains the given point
+     *
+     * @param point
+     */
+    contains(point: Point | number, y?: number): boolean;
+    /**
+     * Copies {@code bounds} into this instance.
+     *
+     * @param bounds
+     */
+    copyFrom(bounds: OrientedBounds): this;
+    /**
+     * Whether any internal state needs to be recalculated.
+     */
+    protected isDirty(): boolean;
+    /**
+     * This will recalculate the center, orientation matrix, and the hull vertices. It should be called only if
+     * {@code this.isDirty} returns true.
+     */
+    protected update(): void;
+    /**
+     * This will translate {@link OrientedBounds#innerBounds} after {@link OrientedBounds#center} is
+     * changed to ensure consistency.
+     */
+    private updateCenter;
+}

package/dist/lib/pixi-essentials/bounds/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AxisAlignedBounds';
+export * from './OrientedBounds';

package/dist/lib/pixi-essentials/index.d.ts

@@ -0,0 +1,6 @@
+export { Transformer as TransformerImpl, TransformerHandle, TransformerWireframe, } from './transformer';
+export type { Handle, RotateHandle, ScaleHandle, SkewHandle, ITransformerOptions, ITransformerStyle, ITransformerCursors, ITransformerColorTheme, IRotatorAnchorConfig, ITransformerHandleStyle, ITransformCommitPayload, ITransformerElementDims, ITransformerGroupBoundsSnapshot, } from './transformer';
+export * from './object-pool';
+export * from './bounds';
+export { Transformer } from './react-bindings/Transformer';
+export type { TransformerProps } from './react-bindings/Transformer';

package/dist/lib/pixi-essentials/object-pool/AverageProvider.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Provides the exponential moving average of a sequence.
+ *
+ * Ignored because not directly exposed.
+ *
+ * @internal
+ * @ignore
+ * @class
+ */
+export declare class AverageProvider {
+    private _history;
+    private _decayRatio;
+    private _currentIndex;
+    private _average;
+    /**
+     * @ignore
+     * @param {number} windowSize - no. of inputs used to calculate window
+     * @param {number} decayRatio - quantifies the weight of previous values (b/w 0 and 1)
+     */
+    constructor(windowSize: number, decayRatio: number);
+    /**
+     * @ignore
+     * @param {number} input - the next value in the sequence
+     * @returns {number} - the moving average
+     */
+    next(input: number): number;
+    absDev(): number;
+}

package/dist/lib/pixi-essentials/object-pool/ObjectPool.d.ts

@@ -0,0 +1,103 @@
+import { Ticker } from 'pixi.js';
+/**
+ * @interface
+ * @public
+ */
+export interface IObjectPoolOptions {
+    capacityRatio?: number;
+    decayRatio?: number;
+    reserve?: number;
+}
+/**
+ * `ObjectPool` provides the framework necessary for pooling minus the object instantiation
+ * method. You can use `ObjectPoolFactory` for objects that can be created using a default
+ * constructor.
+ *
+ * @template T
+ * @class
+ * @public
+ */
+export declare abstract class ObjectPool<T> {
+    protected _freeList: Array<T>;
+    protected _freeCount: number;
+    protected _reserveCount: number;
+    protected _borrowRate: number;
+    protected _returnRate: number;
+    protected _flowRate: number;
+    protected _borrowRateAverage: number;
+    protected _marginAverage: number;
+    private _capacityRatio;
+    private _decayRatio;
+    private _borrowRateAverageProvider;
+    private _marginAverageProvider;
+    /**
+     * @param {IObjectPoolOptions} options
+     */
+    constructor(options?: IObjectPoolOptions);
+    /**
+     * Instantiates a new object of type `T`.
+     *
+     * @abstract
+     * @returns {T}
+     */
+    abstract create(): T;
+    /**
+     * The number of objects that can be stored in the pool without allocating more space.
+     *
+     * @member {number}
+     */
+    protected get capacity(): number;
+    protected set capacity(cp: number);
+    /**
+     * Obtains an instance from this pool.
+     *
+     * @returns {T}
+     */
+    allocate(): T;
+    /**
+     * Obtains an array of instances from this pool. This is faster than allocating multiple objects
+     * separately from this pool.
+     *
+     * @param {number | T[]} lengthOrArray - no. of objects to allocate OR the array itself into which
+     *      objects are inserted. The amount to allocate is inferred from the array's length.
+     * @returns {T[]} array of allocated objects
+     */
+    allocateArray(lengthOrArray: number | T[]): T[];
+    /**
+     * Returns the object to the pool.
+     *
+     * @param {T} object
+     */
+    release(object: T): void;
+    /**
+     * Releases all of the objects in the passed array. These need not be allocated using `allocateArray`, however.
+     *
+     * @param {T[]} array
+     */
+    releaseArray(array: T[]): void;
+    /**
+     * Preallocates objects so that the pool size is at least `count`.
+     *
+     * @param {number} count
+     */
+    reserve(count: number): void;
+    /**
+     * Dereferences objects for the GC to collect and brings the pool size down to `count`.
+     *
+     * @param {number} count
+     */
+    limit(count: number): void;
+    /**
+     * Install the GC on the shared ticker.
+     *
+     * @param {Ticker}[ticker=Ticker.shared]
+     */
+    startGC(ticker?: Ticker): void;
+    /**
+     * Stops running the GC on the pool.
+     *
+     * @param {Ticker}[ticker=Ticker.shared]
+     */
+    stopGC(ticker?: Ticker): void;
+    private _gcTick;
+}

package/dist/lib/pixi-essentials/object-pool/ObjectPoolFactory.d.ts

@@ -0,0 +1,40 @@
+import { ObjectPool } from './ObjectPool';
+/**
+ * Factory for creating pools of objects with default constructors. It will store the pool of
+ * a given type and reuse it on further builds.
+ *
+ * @class
+ * @public
+ * @example
+ * ```js
+ * import { ObjectPool, ObjectPoolFactory } from '@pixi-essentials/object-pool';
+ *
+ * class AABB {}
+ *
+ * const opool: ObjectPool<AABB> = ObjectPoolFactory.build(AABB) as ObjectPool<AABB>;
+ *
+ * const temp = opool.borrowObject();
+ * // do something
+ * opool.returnObject(temp);
+ * ```
+ */
+export declare class ObjectPoolFactory {
+    /**
+     * Builds an object-pool for objects constructed from the given class with a default constructor. If an
+     * object pool for that class was already created, an existing instance is returned.
+     *
+     * @param classConstructor
+     */
+    static build<T>(Type: {
+        new (): T;
+    }): ObjectPool<T>;
+    /**
+     * Builds an object-pool for objects built using a factory function. The factory function's context will be the
+     * object-pool.
+     *
+     * These types of pools are not cached and should only be used on internal data structures.
+     *
+     * @param factoryFunction
+     */
+    static buildFunctional<T>(factoryFunction: () => T): ObjectPool<T>;
+}

package/dist/lib/pixi-essentials/object-pool/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ObjectPoolFactory';
+export * from './ObjectPool';

package/dist/lib/pixi-essentials/react-bindings/Transformer.d.ts

@@ -0,0 +1,74 @@
+import { Container as ContainerImpl, Matrix } from 'pixi.js';
+import { Transformer as TransformerImpl, TransformerHandle as TransformerHandleImpl, Handle } from '../transformer/index';
+import { ITransformerCursors, ITransformerStyle, ITransformerColorTheme, IRotatorAnchorConfig, ITransformCommitPayload, ITransformerHandleStyle } from '../transformer';
+import * as React from 'react';
+/** @internal */
+export type TransformerProps = {
+    boundingBoxes?: 'all' | 'groupOnly' | 'none';
+    boxScalingEnabled?: boolean;
+    boxScalingTolerance?: number;
+    boxRotationEnabled?: boolean;
+    boxRotationTolerance?: number;
+    centeredScaling?: boolean;
+    clickThreshold?: number;
+    cursors?: Partial<ITransformerCursors>;
+    enabledHandles?: Array<string>;
+    group?: ContainerImpl[];
+    handleConstructor?: typeof TransformerHandleImpl;
+    handleStyle?: Partial<ITransformerHandleStyle>;
+    lockAspectRatio?: boolean;
+    projectionTransform?: Matrix;
+    rotateEnabled?: boolean;
+    rotationSnaps?: number[];
+    rotationSnapTolerance?: number;
+    scaleEnabled?: boolean;
+    skewEnabled?: boolean;
+    skewRadius?: number;
+    skewSnaps?: number[];
+    skewSnapTolerance?: number;
+    translateEnabled?: boolean;
+    transientGroupTilt?: boolean;
+    transformchange?: () => void;
+    transformstart?: (event: {
+        handle: Handle | null;
+        transformType: 'translate' | 'scale' | 'rotate' | 'skew' | 'none';
+    }) => void;
+    wireframeStyle?: Partial<ITransformerStyle>;
+    colorTheme?: Partial<ITransformerColorTheme>;
+    rotatorAnchor?: Partial<IRotatorAnchorConfig>;
+    nestedSelectionEnabled?: boolean;
+    focusedElementBorderColor?: number;
+    focusedElementBorderThickness?: number;
+    focusedElementBorderStyle?: 'solid' | 'dashed' | 'dotted';
+    focusedElementBorderDashPattern?: [number, number];
+    showNonFocusedBorders?: boolean;
+    individualBorderColor?: number;
+    individualBorderThickness?: number;
+    individualBorderAlpha?: number;
+    individualBorderStyle?: 'solid' | 'dashed' | 'dotted';
+    individualBorderDashPattern?: [number, number];
+    elementfocused?: (element: ContainerImpl, index: number) => void;
+    elementfocuscleared?: () => void;
+    transformcommit?: (payload: ITransformCommitPayload) => void;
+    focusedElementIndex?: number;
+    onFocusChange?: (index: number, element: ContainerImpl | null) => void;
+};
+/**
+ * Pixi v8 React binding for the imperative `Transformer` class.
+ *
+ * The v7 implementation used `@pixi/react`'s `PixiComponent('Name', { create,
+ * applyProps })` factory plus `applyDefaultProps`. Both are gone in
+ * `@pixi/react@8`: the new model registers custom intrinsics via `extend({})`,
+ * or mounts arbitrary Pixi display objects imperatively as children of a
+ * declarative `<pixiContainer>` via a ref.
+ *
+ * This component takes the **imperative** route: it renders an invisible
+ * `<pixiContainer ref={parentRef}>`, instantiates the `TransformerImpl` class
+ * once in a `useEffect`, attaches it to the parent's child list, and re-runs
+ * the `applyProps` body on every prop change. Cleanup removes the instance and
+ * destroys it.
+ *
+ * @see https://react.pixijs.io/getting-started/
+ * @see https://github.com/SukantPal/pixi-essentials/tree/master/packages/transformer
+ */
+export declare const Transformer: React.ForwardRefExoticComponent<TransformerProps & React.RefAttributes<TransformerImpl>>;

package/dist/lib/pixi-essentials/react-bindings/index.d.ts

@@ -0,0 +1,3 @@
+export { Transformer } from './Transformer';
+export type { TransformerProps } from './Transformer';
+export type { ITransformerColorTheme, IRotatorAnchorConfig } from '../transformer';

package/dist/lib/pixi-essentials/react-bindings/utils/applyEventProps.d.ts

@@ -0,0 +1,13 @@
+import { Container } from 'pixi.js';
+/**
+ * Removes old listeners and applies the new ones passed in the props.
+ *
+ * Pixi v8 removed `DisplayObject` — `Container` is the new base class and
+ * still extends `EventEmitter`, so the on/off API is identical.
+ *
+ * @param container - container emitting events
+ * @param events - object mapping handler prop-names to the fired events
+ * @param oldProps - old props. If calling on first props being passed, this should be `{}`.
+ * @param newProps - new props.
+ */
+export declare function applyEventProps(container: Container, events: Record<string, string>, oldProps: any, newProps: any): void;