@xviewer.js/core 1.0.1 → 1.0.3

package/types/Plugin.d.ts

@@ -1,4 +0,0 @@
-import { Component } from "./Component";
-export declare class Plugin extends Component {
-    isPlugin: boolean;
-}

package/types/PluginManager.d.ts

@@ -1,17 +0,0 @@
-import { Plugin } from "./Plugin";
-import { Viewer } from "./Viewer";
-import { __C } from "./types";
-export declare class PluginManager {
-    private _viewer;
-    private _plugins;
-    private _pluginsMap;
-    get viewer(): Viewer;
-    constructor(viewer: Viewer);
-    destroy(): void;
-    update(dt: number): void;
-    render(dt: number): void;
-    traversePlugins(callback: (plugin: Plugin) => void): void;
-    getPlugin<T extends Plugin>(plugin: new (...args: any[]) => T, autoAdd?: boolean): T;
-    addPlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>): T;
-    removePlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>): void;
-}

package/types/components/PerformanceMonitor.d.ts

@@ -1,48 +0,0 @@
-import { Component } from "../Component";
-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 Component {
-    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/BoxProjectionPlugin.d.ts

@@ -1,20 +0,0 @@
-import { Vector3, Vector4, WebGLProgramParametersWithUniforms } from "three";
-import { Plugin } from "../Plugin";
-export declare class BoxProjectionPlugin extends Plugin {
-    private _center;
-    private _boxMin;
-    private _boxMax;
-    private _helper;
-    private _debug;
-    get debug(): boolean;
-    set debug(v: boolean);
-    get center(): Vector4;
-    set center(v: Vector4);
-    get boxMin(): Vector3;
-    set boxMin(v: Vector3);
-    get boxMax(): Vector3;
-    set boxMax(v: Vector3);
-    constructor();
-    onUpdate(dt: number): void;
-    useBoxProjection(shader: WebGLProgramParametersWithUniforms): void;
-}

package/types/plugins/DebugPlugin.d.ts

@@ -1,10 +0,0 @@
-import { Object3D, Scene } from "three";
-import { Plugin } from "../Plugin";
-import { Viewer } from "../Viewer";
-export declare class DebugPlugin extends Plugin {
-    static Instance(viewer: Viewer): any;
-    scene: Scene;
-    add(node: Object3D): Object3D<import("three").Object3DEventMap>;
-    remove(node: Object3D): Object3D<import("three").Object3DEventMap>;
-    onRender(dt: number): void;
-}

package/types/plugins/DebugScene.d.ts

@@ -1,8 +0,0 @@
-import { Object3D, Scene } from "three";
-import { Mount } from "../Mount";
-export declare class DebugScene extends Mount {
-    scene: Scene;
-    add(node: Object3D): Object3D<import("three").Object3DEventMap>;
-    remove(node: Object3D): Object3D<import("three").Object3DEventMap>;
-    update(dt: number): void;
-}

package/types/plugins/DropFilePlugin.d.ts

@@ -1,18 +0,0 @@
-import { Plugin } from "../Plugin";
-export declare class DropFilePlugin extends Plugin {
-    private _onLoad;
-    private _onError;
-    private _extensions;
-    constructor({ onLoad, onError, extension, }?: {
-        onLoad?: Function;
-        onError?: Function;
-        extension?: string | string[];
-    });
-    install(): void;
-    uninstall(): void;
-    private _onDrogOver;
-    private _onDrop;
-    private _loadItemList;
-    private _loadFiles;
-    private _loadFile;
-}

package/types/plugins/EnvironmentPlugin.d.ts

@@ -1,41 +0,0 @@
-import { Object3D, Scene, Texture, TextureDataType, Vector3 } from "three";
-import { Plugin } from "../Plugin";
-export declare class EnvironmentPlugin extends Plugin {
-    static readonly Quality: {
-        LOW: number;
-        MEDIUM: number;
-        HIGH: number;
-        ULTRA: number;
-    };
-    private _scene;
-    private _cubeCamera;
-    private _reflectPass;
-    private _mipBlurPass;
-    private _mergeInfo;
-    private _debug;
-    private _debugNode;
-    private _elapsed;
-    get debug(): boolean;
-    set debug(v: boolean);
-    get envMap(): Texture;
-    quality: number;
-    envMapIntensity: number;
-    reflectExposure: number;
-    reflectBlurIntensity: number;
-    interval: number;
-    manual: boolean;
-    constructor({ envMap, scene, near, far, layer, resolution, floatType, position, }?: {
-        envMap?: Texture;
-        scene?: Scene | Object3D;
-        performance?: number;
-        resolution?: number;
-        layer?: number;
-        near?: number;
-        far?: number;
-        floatType?: boolean | TextureDataType;
-        position?: Vector3;
-    });
-    onRender(dt: number): void;
-    manualFrame(): void;
-    private _renderFrame;
-}

package/types/plugins/PerformanceMonitorPlugin.d.ts

@@ -1,48 +0,0 @@
-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/tween/Group.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,19 +0,0 @@
-/**
- *
- */
-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

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

package/types/tween/Sequence.d.ts

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

package/types/tween/Tween.d.ts

@@ -1,98 +0,0 @@
-/**
- * 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,26 +0,0 @@
-import { Tween } from "./Tween";
-import { TweenGroup } from "./TweenGroup";
-export declare class TweenChain {
-    private _obj;
-    private _group;
-    private _tween;
-    private _chainedTween;
-    constructor(object: Object, group?: TweenGroup);
-    start(): this;
-    pause(): this;
-    stop(): this;
-    repeat(times: number): this;
-    union(): 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

@@ -1,17 +0,0 @@
-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,8 +0,0 @@
-import { TweenChain } from "./TweenChain";
-export declare class TweenManager {
-    private _group;
-    update(dt: number): void;
-    timeline(target: Object): TweenChain;
-    killAll(): void;
-    killOf(target: Object): void;
-}

package/types/tween/Version.d.ts

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

package/types/tween/index.d.ts

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

package/types/tween/mainGroup.d.ts

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