@xviewer.js/core 1.0.0-beta.2 → 1.0.0

package/types/plugins/PerformanceMonitor.d.ts

@@ -0,0 +1,48 @@
+import { Mount } from "../Mount";
+type PerformanceMonitorProps = {
+    /** How much time in milliseconds to collect an average fps, 250 */
+    ms?: number;
+    /** How many interations of averages to collect, 10 */
+    iterations?: number;
+    /** The percentage of iterations that are matched against the lower and upper bounds, 0.75 */
+    threshold?: number;
+    /** A function that receive the max device refreshrate to determine lower and upper bounds which create a margin where neither incline nor decline should happen, (refreshrate) => (refreshrate > 90 ? [50, 90] : [50, 60]) */
+    bounds?: (refreshrate: number) => [lower: number, upper: number];
+    /** How many times it can inline or decline before onFallback is called, Infinity */
+    flipflops?: number;
+    /** The factor increases and decreases between 0-1, this prop sets the starting value, 0.5 */
+    factor?: number;
+    /** The step that gets added or subtracted to or from the factor on each incline/decline, 0.1 */
+    step?: number;
+    /** When performance is higher than the upper bound (good!) */
+    onIncline?: (monitor: PerformanceMonitor) => void;
+    /** When performance is lower than the upper bound (bad!) */
+    onDecline?: (monitor: PerformanceMonitor) => void;
+    /** Incline and decline will change the factor, this will trigger when that happened */
+    onChange?: (monitor: PerformanceMonitor) => void;
+    /** Called after when the number of flipflops is reached, it indicates instability, use the function to set a fixed baseline */
+    onFallback?: (monitor: PerformanceMonitor) => void;
+};
+type PerformanceMonitorSubscriber = {
+    onIncline?: (monitor: PerformanceMonitor) => void;
+    /** When performance is lower than the upper bound (bad!) */
+    onDecline?: (monitor: PerformanceMonitor) => void;
+    /** Incline and decline will change the factor, this will trigger when that happened */
+    onChange?: (monitor: PerformanceMonitor) => void;
+    /** Called after when the number of flipflops is reached, it indicates instability, use the function to set a fixed baseline */
+    onFallback?: (monitor: PerformanceMonitor) => void;
+};
+export declare class PerformanceMonitor extends Mount {
+    fps: number;
+    index: number;
+    factor: number;
+    flipped: number;
+    refreshrate: number;
+    fallback: boolean;
+    frames: any[];
+    averages: any[];
+    subscriptions: Map<any, any>;
+    subscribe(subscriber: PerformanceMonitorSubscriber): void;
+    constructor({ iterations, ms, threshold, step, factor: _factor, flipflops, bounds, onIncline, onDecline, onChange, onFallback, }: PerformanceMonitorProps);
+}
+export {};

package/types/plugins/PerformanceMonitorPlugin.d.ts

@@ -0,0 +1,48 @@
+import { Plugin } from "../Plugin";
+type PerformanceMonitorProps = {
+    /** How much time in milliseconds to collect an average fps, 250 */
+    ms?: number;
+    /** How many interations of averages to collect, 10 */
+    iterations?: number;
+    /** The percentage of iterations that are matched against the lower and upper bounds, 0.75 */
+    threshold?: number;
+    /** A function that receive the max device refreshrate to determine lower and upper bounds which create a margin where neither incline nor decline should happen, (refreshrate) => (refreshrate > 90 ? [50, 90] : [50, 60]) */
+    bounds?: (refreshrate: number) => [lower: number, upper: number];
+    /** How many times it can inline or decline before onFallback is called, Infinity */
+    flipflops?: number;
+    /** The factor increases and decreases between 0-1, this prop sets the starting value, 0.5 */
+    factor?: number;
+    /** The step that gets added or subtracted to or from the factor on each incline/decline, 0.1 */
+    step?: number;
+    /** When performance is higher than the upper bound (good!) */
+    onIncline?: (monitor: PerformanceMonitorPlugin) => void;
+    /** When performance is lower than the upper bound (bad!) */
+    onDecline?: (monitor: PerformanceMonitorPlugin) => void;
+    /** Incline and decline will change the factor, this will trigger when that happened */
+    onChange?: (monitor: PerformanceMonitorPlugin) => void;
+    /** Called after when the number of flipflops is reached, it indicates instability, use the function to set a fixed baseline */
+    onFallback?: (monitor: PerformanceMonitorPlugin) => void;
+};
+type PerformanceMonitorSubscriber = {
+    onIncline?: (monitor: PerformanceMonitorPlugin) => void;
+    /** When performance is lower than the upper bound (bad!) */
+    onDecline?: (monitor: PerformanceMonitorPlugin) => void;
+    /** Incline and decline will change the factor, this will trigger when that happened */
+    onChange?: (monitor: PerformanceMonitorPlugin) => void;
+    /** Called after when the number of flipflops is reached, it indicates instability, use the function to set a fixed baseline */
+    onFallback?: (monitor: PerformanceMonitorPlugin) => void;
+};
+export declare class PerformanceMonitorPlugin extends Plugin {
+    fps: number;
+    index: number;
+    factor: number;
+    flipped: number;
+    refreshrate: number;
+    fallback: boolean;
+    frames: any[];
+    averages: any[];
+    subscriptions: Map<any, any>;
+    subscribe(subscriber: PerformanceMonitorSubscriber): void;
+    constructor({ iterations, ms, threshold, step, factor: _factor, flipflops, bounds, onIncline, onDecline, onChange, onFallback, }: PerformanceMonitorProps);
+}
+export {};

package/types/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export { Environment } from "./Environment";
+export { BoxProjection } from "./BoxProjection";
+export { PerformanceMonitor } from "./PerformanceMonitor";
+export { DropFile } from "./DropFile";

package/types/tween/Easing.d.ts

@@ -0,0 +1,25 @@
+export type EasingFunction = (amount: number) => number;
+export type EasingFunctionGroup = {
+    In: EasingFunction;
+    Out: EasingFunction;
+    InOut: EasingFunction;
+};
+/**
+ * The Ease class provides a collection of easing functions for use with tween.js.
+ */
+export declare const Easing: Readonly<{
+    Linear: Readonly<EasingFunctionGroup & {
+        None: EasingFunction;
+    }>;
+    Quadratic: Readonly<EasingFunctionGroup>;
+    Cubic: Readonly<EasingFunctionGroup>;
+    Quartic: Readonly<EasingFunctionGroup>;
+    Quintic: Readonly<EasingFunctionGroup>;
+    Sinusoidal: Readonly<EasingFunctionGroup>;
+    Exponential: Readonly<EasingFunctionGroup>;
+    Circular: Readonly<EasingFunctionGroup>;
+    Elastic: Readonly<EasingFunctionGroup>;
+    Back: Readonly<EasingFunctionGroup>;
+    Bounce: Readonly<EasingFunctionGroup>;
+    generatePow(power?: number): EasingFunctionGroup;
+}>;

package/types/tween/Group.d.ts

@@ -0,0 +1,16 @@
+import type { Tween, UnknownProps } from './Tween';
+/**
+ * Controlling groups of tweens
+ *
+ * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
+ * In these cases, you may want to create your own smaller groups of tween
+ */
+export declare class Group {
+    private _tweens;
+    private _tweensAddedDuringUpdate;
+    getAll(): Array<Tween<UnknownProps>>;
+    removeAll(): void;
+    add(tween: Tween<UnknownProps>): void;
+    remove(tween: Tween<UnknownProps>): void;
+    update(time?: number, preserve?: boolean): boolean;
+}

package/types/tween/Interpolation.d.ts

@@ -0,0 +1,19 @@
+/**
+ *
+ */
+export type InterpolationFunction = (v: number[], k: number) => number;
+/**
+ *
+ */
+declare const Interpolation: {
+    Linear: (v: number[], k: number) => number;
+    Bezier: (v: number[], k: number) => number;
+    CatmullRom: (v: number[], k: number) => number;
+    Utils: {
+        Linear: (p0: number, p1: number, t: number) => number;
+        Bernstein: (n: number, i: number) => number;
+        Factorial: (n: number) => number;
+        CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+    };
+};
+export { Interpolation };

package/types/tween/Now.d.ts

@@ -0,0 +1,2 @@
+declare const now: () => number;
+export { now };

package/types/tween/Sequence.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utils
+ */
+export declare class Sequence {
+    private static _nextId;
+    static nextId(): number;
+}

package/types/tween/Tween.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ * ----------------------------------------------
+ *
+ * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
+ * Thank you all, you're awesome!
+ */
+import type { EasingFunction } from './Easing';
+import type { InterpolationFunction } from './Interpolation';
+import type { TweenGroup } from './TweenGroup';
+export declare class Tween<T extends UnknownProps> {
+    private _object;
+    private _group;
+    private _isPaused;
+    private _pauseStart;
+    private _valuesStart;
+    private _valuesEnd;
+    private _valuesStartRepeat;
+    private _duration;
+    private _isDynamic;
+    private _initialRepeat;
+    private _repeat;
+    private _repeatDelayTime?;
+    private _yoyo;
+    private _isPlaying;
+    private _reversed;
+    private _delayTime;
+    private _startTime;
+    private _easingFunction;
+    private _interpolationFunction;
+    private _chainedTweens;
+    private _onStartCallback?;
+    private _onStartCallbackFired;
+    private _onEveryStartCallback?;
+    private _onEveryStartCallbackFired;
+    private _onUpdateCallback?;
+    private _onRepeatCallback?;
+    private _onCompleteCallback?;
+    private _onStopCallback?;
+    private _onFinishCallback?;
+    private _id;
+    private _isChainStopped;
+    private _propertiesAreSetUp;
+    private _headTween;
+    private _tailTween;
+    private _headTweenStartFired;
+    constructor(_object: T, _group?: TweenGroup | false);
+    getId(): number;
+    getObject(): T;
+    getGroup(): false | TweenGroup;
+    isPlaying(): boolean;
+    isPaused(): boolean;
+    getDuration(): number;
+    from(properties: UnknownProps): this;
+    to(target: UnknownProps, duration?: number): this;
+    duration(duration?: number): this;
+    dynamic(dynamic?: boolean): this;
+    start(time: number, overrideStartingValues?: boolean): this;
+    startFromCurrentValues(time?: number): this;
+    private _setupProperties;
+    stop(): this;
+    end(): this;
+    pause(time: number): this;
+    resume(time: number): this;
+    stopChainedTweens(): this;
+    group(group?: TweenGroup): this;
+    call(callback: (object: T) => void): this;
+    delay(amount?: number): this;
+    union(headTween: Tween<T>, tailTween: Tween<T>): this;
+    repeat(times?: number): this;
+    repeatDelay(amount?: number): this;
+    yoyo(yoyo?: boolean): this;
+    easing(easingFunction?: EasingFunction): this;
+    interpolation(interpolationFunction?: InterpolationFunction): this;
+    chain(...tweens: Array<Tween<any>>): this;
+    unchain(...tweens: Array<Tween<any>>): this;
+    onStart(callback?: (object: T) => void): this;
+    onEveryStart(callback?: (object: T) => void): this;
+    onUpdate(callback?: (object: T, elapsed: number) => void): this;
+    onRepeat(callback?: (object: T) => void): this;
+    onComplete(callback?: (object: T) => void): this;
+    onStop(callback?: (object: T) => void): this;
+    private _goToEnd;
+    /**
+     * @returns true if the tween is still playing after the update, false
+     * otherwise (calling update on a paused tween still returns true because
+     * it is still playing, just paused).
+     */
+    update(time: number, autoStart?: boolean): boolean;
+    private _calculateElapsedPortion;
+    private _calculateCompletionStatus;
+    private _processRepetition;
+    private _updateProperties;
+    private _handleRelativeValue;
+    private _swapEndStartRepeatValues;
+}
+export type UnknownProps = Record<string, any>;

package/types/tween/TweenChain.d.ts

@@ -1,15 +1,26 @@
-import { Group, Tween } from "./tween";
+import { Tween } from "./Tween";
+import { TweenGroup } from "./TweenGroup";
 export declare class TweenChain {
-    private _object;
+    private _obj;
+    private _group;
     private _tween;
     private _chainedTween;
-    constructor(object: Object, group?: Group);
+    constructor(object: Object, group?: TweenGroup);
     start(): this;
+    pause(): this;
     stop(): this;
-    repeat(times: any): this;
+    repeat(times: number): this;
     union(): this;
-    call(callback: any): this;
-    delay(amount: any): this;
-    to(properties: any, duration: any, props: any): this;
+    call(callback: (object: Object) => void): this;
+    delay(amount: number): this;
+    to(properties: Record<string, any>, duration?: number, props?: {
+        from?: Record<string, any>;
+        easing?: (amount: number) => number;
+        onStart?: (object: Object) => void;
+        onStop?: (object: Object) => void;
+        onComplete?: (object: Object) => void;
+        onUpdate?: (object: Object, elapsed: number) => void;
+        onRepeat?: (object: Object) => void;
+    }): this;
     _chainTween(): Tween<Object>;
 }

package/types/tween/TweenGroup.d.ts

@@ -0,0 +1,17 @@
+import type { Tween, UnknownProps } from './Tween';
+/**
+ * Controlling groups of tweens
+ *
+ * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
+ * In these cases, you may want to create your own smaller groups of tween
+ */
+export declare class TweenGroup {
+    private _tweens;
+    private _tweensAddedDuringUpdate;
+    getAll(): Array<Tween<UnknownProps>>;
+    removeAll(): void;
+    removeOf(target: Object): void;
+    add(tween: Tween<UnknownProps>): void;
+    remove(tween: Tween<UnknownProps>): void;
+    update(time: number, preserve?: boolean): boolean;
+}

package/types/tween/TweenManager.d.ts

@@ -1,10 +1,8 @@
 import { TweenChain } from "./TweenChain";
-import { Tween } from "./tween";
 export declare class TweenManager {
     private _group;
-    destroy(): void;
-    update(time: number): void;
-    tween(target: Object): Tween<Object>;
+    update(dt: number): void;
     timeline(target: Object): TweenChain;
-    killTweensOf(target: Object): void;
+    killAll(): void;
+    killOf(target: Object): void;
 }

package/types/tween/Version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "23.1.2";

package/types/tween/index.d.ts

@@ -1,3 +1,6 @@
+export { TweenGroup } from "./TweenGroup";
 export { TweenChain } from "./TweenChain";
 export { TweenManager } from "./TweenManager";
-export { Tween } from "./tween";
+export { Tween } from "./Tween";
+export type { EasingFunction } from "./Easing";
+export { Easing } from "./Easing";

package/types/tween/mainGroup.d.ts

@@ -0,0 +1,2 @@
+import { TweenGroup } from './TweenGroup';
+export declare const mainGroup: TweenGroup;

package/types/types.d.ts

@@ -8,6 +8,10 @@ export type __Properties<T> = Omit<Partial<T>, __FunctionKeys<T>> & {
 };
 export type __C<T> = new (...args: any[]) => T;
 export type __P<T, K extends __C<T>> = __Properties<T> & {
+    /**
+     * Target node for component
+     */
+    node?: Object3D;
     /**
      * Set contructor parameters of node
      */
@@ -45,6 +49,10 @@ export type __P<T, K extends __C<T>> = __Properties<T> & {
      * Object's local rotation
      */
     rotation?: Euler;
+    /**
+     * Object's layer mask
+     */
+    layer?: number;
 };
 export type __Comp<T, K extends __C<T>> = __Properties<T> & {
     /**

package/types/loader/aGLTFLoader.d.ts

@@ -1,5 +0,0 @@
-import { LoadProperties, aLoader } from "../asset/aLoader";
-export declare class aGLTFLoader extends aLoader {
-    extension: string[];
-    load({ url, onLoad, onProgress, onError }: LoadProperties): void;
-}

package/types/material/glsl/copy.glsl.d.ts

@@ -1 +0,0 @@
-export declare const frag_Copy = "\nvarying vec2      vUv;\nuniform sampler2D tMain;\nuniform float     uLod;\n\nvoid main() {\n    gl_FragColor = texture(tMain, vUv, uLod);\n\t#include <encodings_fragment>\n}\n";