@vived/app 4.7.0 → 4.8.1

package/lib/Components/Ease/Entites/AllLinearEase.d.ts

@@ -0,0 +1,22 @@
+import { AppObject } from "../../../AppObject";
+import { EaseEntity } from "./EaseEntity";
+export declare class AllLinearEase extends EaseEntity {
+    linearFn: (val: number) => number;
+    linear: (val: number) => number;
+    quadIn: (val: number) => number;
+    quadOut: (val: number) => number;
+    quadInOut: (val: number) => number;
+    cubicIn: (val: number) => number;
+    cubicOut: (val: number) => number;
+    cubicInOut: (val: number) => number;
+    sinIn: (val: number) => number;
+    sinOut: (val: number) => number;
+    sinInOut: (val: number) => number;
+    expIn: (val: number) => number;
+    expOut: (val: number) => number;
+    expInOut: (val: number) => number;
+    circleIn: (val: number) => number;
+    circleOut: (val: number) => number;
+    circleInOut: (val: number) => number;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Ease/Entites/AllLinearEase.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllLinearEase = void 0;
+const EaseEntity_1 = require("./EaseEntity");
+class AllLinearEase extends EaseEntity_1.EaseEntity {
+    constructor(appObject) {
+        super(appObject, EaseEntity_1.EaseEntity.type);
+        this.linearFn = (val) => {
+            return val;
+        };
+        this.linear = this.linearFn;
+        this.quadIn = this.linearFn;
+        this.quadOut = this.linearFn;
+        this.quadInOut = this.linearFn;
+        this.cubicIn = this.linearFn;
+        this.cubicOut = this.linearFn;
+        this.cubicInOut = this.linearFn;
+        this.sinIn = this.linearFn;
+        this.sinOut = this.linearFn;
+        this.sinInOut = this.linearFn;
+        this.expIn = this.linearFn;
+        this.expOut = this.linearFn;
+        this.expInOut = this.linearFn;
+        this.circleIn = this.linearFn;
+        this.circleOut = this.linearFn;
+        this.circleInOut = this.linearFn;
+    }
+}
+exports.AllLinearEase = AllLinearEase;

package/lib/Components/Ease/Entites/EaseEntity.d.ts

@@ -0,0 +1,21 @@
+import { AppObjectEntity } from "../../../AppObject";
+import { EaseFn } from "../../../Types";
+export declare abstract class EaseEntity extends AppObjectEntity {
+    static type: string;
+    abstract linear: EaseFn;
+    abstract quadIn: EaseFn;
+    abstract quadOut: EaseFn;
+    abstract quadInOut: EaseFn;
+    abstract cubicIn: EaseFn;
+    abstract cubicOut: EaseFn;
+    abstract cubicInOut: EaseFn;
+    abstract sinIn: EaseFn;
+    abstract sinOut: EaseFn;
+    abstract sinInOut: EaseFn;
+    abstract expIn: EaseFn;
+    abstract expOut: EaseFn;
+    abstract expInOut: EaseFn;
+    abstract circleIn: EaseFn;
+    abstract circleOut: EaseFn;
+    abstract circleInOut: EaseFn;
+}

package/lib/Components/Ease/Entites/EaseEntity.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EaseEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+class EaseEntity extends AppObject_1.AppObjectEntity {
+}
+exports.EaseEntity = EaseEntity;
+EaseEntity.type = "EaseEntity";

package/lib/Components/Ease/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entites/EaseEntity";
+export * from "./Entites/AllLinearEase";

package/lib/Components/Ease/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Entites/EaseEntity"), exports);
+__exportStar(require("./Entites/AllLinearEase"), exports);

package/lib/Utilities/easeFunctions.d.ts

@@ -0,0 +1,19 @@
+export declare function easeLinear(x: number): number;
+export declare function quadIn(x: number): number;
+export declare function quadOut(x: number): number;
+export declare function quadInOut(x: number): number;
+export declare function cubicIn(x: number): number;
+export declare function cubicOut(x: number): number;
+export declare function cubicInOut(x: number): number;
+export declare function expoIn(x: number): number;
+export declare function expoOut(x: number): number;
+export declare function expoInOut(x: number): number;
+export declare function sinIn(x: number): number;
+export declare function sinOut(x: number): number;
+export declare function sinInOut(x: number): number;
+export declare function quartIn(x: number): number;
+export declare function quartOut(x: number): number;
+export declare function quartInOut(x: number): number;
+export declare function quintIn(x: number): number;
+export declare function quintOut(x: number): number;
+export declare function quintInOut(x: number): number;

package/lib/Utilities/easeFunctions.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quintInOut = exports.quintOut = exports.quintIn = exports.quartInOut = exports.quartOut = exports.quartIn = exports.sinInOut = exports.sinOut = exports.sinIn = exports.expoInOut = exports.expoOut = exports.expoIn = exports.cubicInOut = exports.cubicOut = exports.cubicIn = exports.quadInOut = exports.quadOut = exports.quadIn = exports.easeLinear = void 0;
+function easeLinear(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return x;
+}
+exports.easeLinear = easeLinear;
+function quadIn(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return x * x;
+}
+exports.quadIn = quadIn;
+function quadOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return x * (2 - x);
+}
+exports.quadOut = quadOut;
+function quadInOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    if (x < 0.5) {
+        return 2 * x * x;
+    }
+    else {
+        return 1 - Math.pow(-2 * x + 2, 2) / 2;
+    }
+}
+exports.quadInOut = quadInOut;
+function cubicIn(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return x * x * x;
+}
+exports.cubicIn = cubicIn;
+function cubicOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return --x * x * x + 1;
+}
+exports.cubicOut = cubicOut;
+function cubicInOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    x *= 2;
+    if (x <= 1) {
+        return (x * x * x) / 2;
+    }
+    else {
+        return ((x -= 2) * x * x + 2) / 2;
+    }
+}
+exports.cubicInOut = cubicInOut;
+function expoIn(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return Math.pow(2, 10 * x - 10);
+}
+exports.expoIn = expoIn;
+function expoOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return 1 - Math.pow(2, -10 * x);
+}
+exports.expoOut = expoOut;
+function expoInOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return x < 0.5
+        ? Math.pow(2, 20 * x - 10) / 2
+        : (2 - Math.pow(2, -20 * x + 10)) / 2;
+}
+exports.expoInOut = expoInOut;
+function sinIn(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return 1 - Math.cos((x * Math.PI) / 2);
+}
+exports.sinIn = sinIn;
+function sinOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return Math.sin((x * Math.PI) / 2);
+}
+exports.sinOut = sinOut;
+function sinInOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return -(Math.cos(Math.PI * x) - 1) / 2;
+}
+exports.sinInOut = sinInOut;
+function quartIn(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return x * x * x * x;
+}
+exports.quartIn = quartIn;
+function quartOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return 1 - Math.pow(1 - x, 4);
+}
+exports.quartOut = quartOut;
+function quartInOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    if (x < 0.5) {
+        return 8 * x * x * x * x;
+    }
+    else {
+        return 1 - Math.pow(-2 * x + 2, 4) / 2;
+    }
+}
+exports.quartInOut = quartInOut;
+function quintIn(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return x * x * x * x * x;
+}
+exports.quintIn = quintIn;
+function quintOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    return 1 - Math.pow(1 - x, 5);
+}
+exports.quintOut = quintOut;
+function quintInOut(x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    if (x < 0.5) {
+        return 16 * x * x * x * x * x;
+    }
+    else {
+        return 1 - Math.pow(-2 * x + 2, 5) / 2;
+    }
+}
+exports.quintInOut = quintInOut;

package/lib/Utilities/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./degreesToRadians";
 export * from "./LengthConverters";
 export * from "./generateUniqueID";
+export * from "./easeFunctions";

package/lib/Utilities/index.js

@@ -13,3 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./degreesToRadians"), exports);
 __exportStar(require("./LengthConverters"), exports);
 __exportStar(require("./generateUniqueID"), exports);
+__exportStar(require("./easeFunctions"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "4.7.0",
+  "version": "4.8.1",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",