@pilotlab/lux-types/src/types.ts

A luxurious user experience framework, developed by your friends at Pilot.

import is from '@pilotlab/lux-is';
import IColor from './interfaces/IColor';
import ICoordinateSystem from './interfaces/iCoordinateSystem';
import IMatrix2 from './interfaces/iMatrix2';
import IMatrix3 from './interfaces/iMatrix3';
import IMatrix4 from './interfaces/iMatrix4';
import IPoint from './interfaces/iPoint';
import IPoint3D from './interfaces/iPoint3D';
import IQuaternion from './interfaces/iQuaternion';
import IRectangle from './interfaces/iRectangle';
import ISize from './interfaces/iSize';
import IType from './interfaces/iType';
import IVector from './interfaces/iVector';


import {
    Animation,
    IAnimationEaseFunction,
    AnimationValue,
    IAnimationMultiple,
    AnimationMultiple,
    ISpeed,
    Speed,
    SpeedType
} from '@pilotlab/lux-animation';


export class Types {
    static get tolerance():number { return 0.0001; }


    static isLuxType(instance:any): instance is IType {
        return 'key' in instance && 'value' in instance && 'dataType' in instance;
    }


    static isColor(instance:any): instance is IColor {
        return this.isLuxType(instance) &&
            'r' in instance &&
            'g' in instance &&
            'b' in instance &&
            'a' in instance;
    }


    static isCoordinateSystem(instance:any): instance is ICoordinateSystem {
        return this.isPoint(instance) && 'zMax' in instance;
    }


    static isPoint(instance:any): instance is IPoint {
        return this.isLuxType(instance) && 'x' in instance && 'y' in instance;
    }


    static isPoint3D(instance:any): instance is IPoint3D {
        return this.isPoint(instance) && 'z' in instance;
    }


    static isMatrix2(instance:any): instance is IMatrix2 { return false; }
    static isMatrix3(instance:any): instance is IMatrix3 { return false; }
    static isMatrix4(instance:any): instance is IMatrix4 { return false; }
    static isQuaternion(instance:any): instance is IQuaternion { return false; }


    static isRectangle(instance:any): instance is IRectangle {
        return this.isPoint(instance) && this.isSize(instance);
    }


    static isSize(instance:any): instance is ISize {
        return this.isLuxType(instance) && 'width' in instance && 'height' in instance;
    }


    static isVector(instance:any): instance is IVector {
        return this.isPoint3D(instance) && 'w' in instance;
    }


    static goColor(
        startColor:IColor,
        targetColor:IColor,
        durationSpeed?:(number | ISpeed),
        ease?:IAnimationEaseFunction,
        repeatCount:number = 0,
        animationID?:string,
    ):IAnimationMultiple {
        let duration:number = 0;

        if (is.notEmpty(durationSpeed) && typeof durationSpeed === 'number' && durationSpeed >= 0) {
            duration = durationSpeed;
        } else if (durationSpeed instanceof Speed && (<ISpeed>durationSpeed).type === SpeedType.DURATION) {
            duration = (<ISpeed>durationSpeed).duration;
        } else {
            let diffR:number = Math.abs(targetColor.r - startColor.r);
            let diffG:number = Math.abs(targetColor.g - startColor.g);
            let diffB:number = Math.abs(targetColor.b - startColor.b);
            let diffA:number = Math.abs(targetColor.a - startColor.a);
            let diff:number = (diffR > diffG ? ((
                diffR > diffB ? (diffR > diffA ? diffR : diffA) : (diffB > diffA ? diffB : diffA)
            )) : ((
                diffG > diffB ? (diffG > diffA ? diffG : diffA) : (diffB > diffA ? diffB : diffA)
            )));

            duration = Animation.getDuration(durationSpeed, 0, diff);
        }

        if (is.empty(ease)) ease = Animation.validateSpeed(durationSpeed).ease;

        let animation:IAnimationMultiple = new AnimationMultiple(
            [
                new AnimationValue(startColor.r, targetColor.r),
                new AnimationValue(startColor.g, targetColor.g),
                new AnimationValue(startColor.b, targetColor.b),
                new AnimationValue(startColor.a, targetColor.a)
            ],
            duration,
            ease,
            repeatCount,
            animationID
        );

        animation.ticked.listen(() => {
            startColor.r = animation.values[0].current;
            startColor.g = animation.values[1].current;
            startColor.b= animation.values[2].current;
        });

        Animation.goAnimation(animation);
        return animation;
    }
} // End class


export default Types;