@ohos-ports/nitrots-nitro-renderer 1.6.6-beta.0

package/dist/nitro/utils/HabboWebTools.js

@@ -0,0 +1,217 @@
+import { NitroLogger } from '../../api';
+import { LegacyExternalInterface } from '../externalInterface/LegacyExternalInterface';
+export class HabboWebTools {
+    static logEventLog(data) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('logEventLog', data);
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working, failed to log event log.');
+        }
+    }
+    static openPage(pageUrl) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('openPage', pageUrl);
+            }
+            else {
+                NitroLogger.log('External interface not available, openPage failed.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to open web page', pageUrl);
+        }
+    }
+    static openWebPage(pageUrl) {
+        window.open(pageUrl);
+    }
+    static sendHeartBeat() {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('heartBeat');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to send heartbeat');
+        }
+    }
+    static openWebPageAndMinimizeClient(pageUrl) {
+        try {
+            if (LegacyExternalInterface.available) {
+                HabboWebTools.openPage(pageUrl);
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to open web page', pageUrl);
+        }
+    }
+    static closeWebPageAndRestoreClient() {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('closeWebPageAndRestoreClient');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to close web page and restore client!');
+        }
+    }
+    static openHabblet(name, param = null) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('openHabblet', name, param);
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to open Habblet', name);
+        }
+    }
+    static closeHabblet(name, param = null) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('closeHabblet', name, param);
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to close Habblet', name);
+        }
+    }
+    static send(reasonCode, reasonString) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('disconnect', reasonCode, reasonString);
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to close send ');
+        }
+    }
+    static showGame(gameUrl) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.callGame('showGame', gameUrl);
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to open game', e);
+        }
+    }
+    static hideGame() {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.callGame('hideGame');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('Failed to hide game');
+        }
+    }
+    static open(url) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('openExternalLink', escape(url));
+            }
+            else {
+                NitroLogger.log(('External interface not available. Could not request to open: ' + url));
+            }
+        }
+        catch (e) {
+            NitroLogger.log(('External interface not working. Could not request to open: ' + url));
+        }
+    }
+    static roomVisited(roomId) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('roomVisited', roomId);
+            }
+            else {
+                NitroLogger.log('External interface not available. Could not store last room visit.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working. Could not store last room visit.');
+        }
+    }
+    static openMinimail(target) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('openMinimail', target);
+            }
+            else {
+                NitroLogger.log('External interface not available. Could not open minimail.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working. Could not open minimail.');
+        }
+    }
+    static openNews() {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('openNews');
+            }
+            else {
+                NitroLogger.log('External interface not available. Could not open news.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working. Could not open news.');
+        }
+    }
+    static closeNews() {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('closeNews');
+            }
+            else {
+                NitroLogger.log('External interface not available. Could not close news.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working. Could not close news.');
+        }
+    }
+    static openAvatars() {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('openAvatars');
+            }
+            else {
+                NitroLogger.log('External interface not available. Could not open avatars.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working. Could not open avatars.');
+        }
+    }
+    static openRoomEnterAd() {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('openRoomEnterAd');
+            }
+            else {
+                NitroLogger.log('External interface not available. Could not open roomenterad.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working. Could not open roomenterad.');
+        }
+    }
+    static updateFigure(figure) {
+        try {
+            if (LegacyExternalInterface.available) {
+                LegacyExternalInterface.call('updateFigure', figure);
+            }
+            else {
+                NitroLogger.log('External interface not available. Could not update figure.');
+            }
+        }
+        catch (e) {
+            NitroLogger.log('External interface not working. Could not update figure.');
+        }
+    }
+}
+HabboWebTools.ADVERTISEMENT = 'advertisement';
+HabboWebTools.OPENLINK = 'openlink';
+HabboWebTools.OPENROOM = 'openroom';

package/dist/nitro/utils/Int32.d.ts

@@ -0,0 +1 @@
+export declare const ToInt32: (x: number) => number;

package/dist/nitro/utils/Int32.js

@@ -0,0 +1,8 @@
+const toUint32 = (x) => x >>> 0;
+export const ToInt32 = (x) => {
+    const uint32 = toUint32(x);
+    if (uint32 >= Math.pow(2, 31)) {
+        return uint32 - Math.pow(2, 32);
+    }
+    return uint32;
+};

package/dist/nitro/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './FigureDataContainer';
+export * from './FixedSizeStack';
+export * from './FriendlyTime';
+export * from './FurniId';
+export * from './HabboWebTools';
+export * from './Int32';

package/dist/nitro/utils/index.js

@@ -0,0 +1,6 @@
+export * from './FigureDataContainer';
+export * from './FixedSizeStack';
+export * from './FriendlyTime';
+export * from './FurniId';
+export * from './HabboWebTools';
+export * from './Int32';

package/dist/nitro/window/index.d.ts

@@ -0,0 +1 @@
+export * from './motion';

package/dist/nitro/window/index.js

@@ -0,0 +1 @@
+export * from './motion';

package/dist/nitro/window/motion/Callback.d.ts

@@ -0,0 +1,7 @@
+import { Motion } from './Motion';
+export declare class Callback extends Motion {
+    protected _callback: Function;
+    constructor(k: Function);
+    get running(): boolean;
+    tick(k: number): void;
+}

package/dist/nitro/window/motion/Callback.js

@@ -0,0 +1,17 @@
+import { Motion } from './Motion';
+export class Callback extends Motion {
+    constructor(k) {
+        super(null);
+        this._callback = k;
+    }
+    get running() {
+        return (this._running && !!this._callback);
+    }
+    tick(k) {
+        super.tick(k);
+        if (this._callback) {
+            this._callback();
+            this._callback = null;
+        }
+    }
+}

package/dist/nitro/window/motion/Combo.d.ts

@@ -0,0 +1,8 @@
+import { Motion } from './Motion';
+export declare class Combo extends Motion {
+    private _runningMotions;
+    private _removedMotions;
+    constructor(...motions: Motion[]);
+    start(): void;
+    tick(k: number): void;
+}

package/dist/nitro/window/motion/Combo.js

@@ -0,0 +1,41 @@
+import { Motion } from './Motion';
+export class Combo extends Motion {
+    constructor(...motions) {
+        super((motions && motions.length) ? motions[0].target : null);
+        this._runningMotions = [];
+        this._removedMotions = [];
+        for (const motion of motions)
+            this._runningMotions.push(motion);
+    }
+    start() {
+        super.start();
+        for (const motion of this._runningMotions)
+            motion.start();
+    }
+    tick(k) {
+        super.tick(k);
+        let motion = null;
+        while (((motion = this._removedMotions.pop()) !== null)) {
+            this._runningMotions.splice(this._removedMotions.indexOf(motion), 1);
+            if (motion.running)
+                motion.stop();
+        }
+        for (const motion of this._runningMotions) {
+            if (motion.running)
+                motion.tick(k);
+            if (motion.complete)
+                this._removedMotions.push(motion);
+        }
+        if (this._runningMotions.length > 0) {
+            for (const motion of this._runningMotions) {
+                this._target = motion.target;
+                if (this._target)
+                    break;
+            }
+            this._complete = false;
+        }
+        else {
+            this._complete = true;
+        }
+    }
+}

package/dist/nitro/window/motion/Dispose.d.ts

@@ -0,0 +1,5 @@
+import { Motion } from './Motion';
+export declare class Dispose extends Motion {
+    constructor(k: HTMLElement);
+    tick(k: number): void;
+}

package/dist/nitro/window/motion/Dispose.js

@@ -0,0 +1,13 @@
+import { Motion } from './Motion';
+export class Dispose extends Motion {
+    constructor(k) {
+        super(k);
+    }
+    tick(k) {
+        super.tick(k);
+        if (this.target) {
+            this.target.remove();
+            this.target = null;
+        }
+    }
+}

package/dist/nitro/window/motion/DropBounce.d.ts

@@ -0,0 +1,10 @@
+import { Interval } from './Interval';
+export declare class DropBounce extends Interval {
+    private _height;
+    private _offset;
+    constructor(target: HTMLElement, duration: number, height: number);
+    start(): void;
+    update(time: number): void;
+    protected getBounceOffset(k: number): number;
+    stop(): void;
+}

package/dist/nitro/window/motion/DropBounce.js

@@ -0,0 +1,34 @@
+import { Interval } from './Interval';
+export class DropBounce extends Interval {
+    constructor(target, duration, height) {
+        super(target, duration);
+        this._height = height;
+    }
+    start() {
+        super.start();
+        this._offset = 0;
+        this.target.style.top = ((this._offset - this._height) + 'px');
+    }
+    update(time) {
+        super.update(time);
+        this.target.style.top = (((this._offset - this._height) + (this.getBounceOffset(time) * this._height)) + 'px');
+    }
+    getBounceOffset(k) {
+        if (k < 0.364)
+            return (7.5625 * k) * k;
+        if (k < 0.727) {
+            k = (k - 0.545);
+            return ((7.5625 * k) * k) + 0.75;
+        }
+        if (k < 0.909) {
+            k = (k - 0.9091);
+            return ((7.5625 * k) * k) + 0.9375;
+        }
+        k = (k - 0.955);
+        return ((7.5625 * k) * k) + 0.984375;
+    }
+    stop() {
+        this.target.style.top = (this._offset + 'px');
+        super.stop();
+    }
+}

package/dist/nitro/window/motion/Ease.d.ts

@@ -0,0 +1,8 @@
+import { Interval } from './Interval';
+export declare class Ease extends Interval {
+    protected _interval: Interval;
+    constructor(k: Interval);
+    start(): void;
+    update(k: number): void;
+    stop(): void;
+}

package/dist/nitro/window/motion/Ease.js

@@ -0,0 +1,19 @@
+import { Interval } from './Interval';
+export class Ease extends Interval {
+    constructor(k) {
+        super(k.target, k.duration);
+        this._interval = k;
+    }
+    start() {
+        super.start();
+        this._interval.start();
+    }
+    update(k) {
+        super.update(k);
+        this._interval.update(k);
+    }
+    stop() {
+        super.stop();
+        this._interval.stop();
+    }
+}

package/dist/nitro/window/motion/EaseOut.d.ts

@@ -0,0 +1,6 @@
+import { EaseRate } from './EaseRate';
+import { Interval } from './Interval';
+export declare class EaseOut extends EaseRate {
+    constructor(k: Interval, _arg_2: number);
+    update(k: number): void;
+}

package/dist/nitro/window/motion/EaseOut.js

@@ -0,0 +1,9 @@
+import { EaseRate } from './EaseRate';
+export class EaseOut extends EaseRate {
+    constructor(k, _arg_2) {
+        super(k, _arg_2);
+    }
+    update(k) {
+        this._interval.update(Math.pow(k, (1 / this._rate)));
+    }
+}

package/dist/nitro/window/motion/EaseRate.d.ts

@@ -0,0 +1,6 @@
+import { Ease } from './Ease';
+import { Interval } from './Interval';
+export declare class EaseRate extends Ease {
+    protected _rate: number;
+    constructor(k: Interval, _arg_2: number);
+}

package/dist/nitro/window/motion/EaseRate.js

@@ -0,0 +1,7 @@
+import { Ease } from './Ease';
+export class EaseRate extends Ease {
+    constructor(k, _arg_2) {
+        super(k);
+        this._rate = _arg_2;
+    }
+}

package/dist/nitro/window/motion/Interval.d.ts

@@ -0,0 +1,9 @@
+import { Motion } from './Motion';
+export declare class Interval extends Motion {
+    private _startTimeMs;
+    private _duration;
+    constructor(target: HTMLElement, duration: number);
+    get duration(): number;
+    start(): void;
+    tick(time: number): void;
+}

package/dist/nitro/window/motion/Interval.js

@@ -0,0 +1,28 @@
+import { GetTickerTime } from '../../../pixi-proxy';
+import { Motion } from './Motion';
+export class Interval extends Motion {
+    constructor(target, duration) {
+        super(target);
+        this._complete = false;
+        this._duration = duration;
+    }
+    get duration() {
+        return this._duration;
+    }
+    start() {
+        super.start();
+        this._complete = false;
+        this._startTimeMs = GetTickerTime();
+    }
+    tick(time) {
+        super.tick(time);
+        const elapsed = ((time - this._startTimeMs) / this._duration);
+        if (elapsed < 1) {
+            this.update(elapsed);
+        }
+        else {
+            this.update(1);
+            this._complete = true;
+        }
+    }
+}

package/dist/nitro/window/motion/JumpBy.d.ts

@@ -0,0 +1,12 @@
+import { Interval } from './Interval';
+export declare class JumpBy extends Interval {
+    protected _startX: number;
+    protected _startY: number;
+    protected _deltaX: number;
+    protected _deltaY: number;
+    protected _height: number;
+    protected _numJumps: number;
+    constructor(target: HTMLElement, duration: number, deltaX: number, deltaY: number, height: number, numJumps: number);
+    start(): void;
+    update(k: number): void;
+}

package/dist/nitro/window/motion/JumpBy.js

@@ -0,0 +1,20 @@
+import { Interval } from './Interval';
+export class JumpBy extends Interval {
+    constructor(target, duration, deltaX, deltaY, height, numJumps) {
+        super(target, duration);
+        this._deltaX = deltaX;
+        this._deltaY = deltaY;
+        this._height = -(height);
+        this._numJumps = numJumps;
+    }
+    start() {
+        super.start();
+        this._startX = this.target.offsetLeft;
+        this._startY = this.target.offsetTop;
+    }
+    update(k) {
+        super.update(k);
+        this.target.style.left = ((this._startX + (this._deltaX * k)) + 'px');
+        this.target.style.top = (((this._startY + (this._height * Math.abs(Math.sin(((k * Math.PI) * this._numJumps))))) + (this._deltaY * k)) + 'px');
+    }
+}

package/dist/nitro/window/motion/Motion.d.ts

@@ -0,0 +1,17 @@
+export declare class Motion {
+    protected _target: HTMLElement;
+    protected _running: boolean;
+    protected _complete: boolean;
+    protected _tag: string;
+    constructor(target: HTMLElement);
+    get running(): boolean;
+    get complete(): boolean;
+    set target(k: HTMLElement);
+    get target(): HTMLElement;
+    set tag(k: string);
+    get tag(): string;
+    start(): void;
+    update(k: number): void;
+    stop(): void;
+    tick(k: number): void;
+}

package/dist/nitro/window/motion/Motion.js

@@ -0,0 +1,35 @@
+export class Motion {
+    constructor(target) {
+        this._complete = true;
+        this._target = target;
+    }
+    get running() {
+        return ((this._running) && (!!this._target));
+    }
+    get complete() {
+        return this._complete;
+    }
+    set target(k) {
+        this._target = k;
+    }
+    get target() {
+        return this._target;
+    }
+    set tag(k) {
+        this._tag = k;
+    }
+    get tag() {
+        return this._tag;
+    }
+    start() {
+        this._running = true;
+    }
+    update(k) {
+    }
+    stop() {
+        this._target = null;
+        this._running = false;
+    }
+    tick(k) {
+    }
+}

package/dist/nitro/window/motion/Motions.d.ts

@@ -0,0 +1,20 @@
+import { Motion } from './Motion';
+export declare class Motions {
+    private static _QUEUED_MOTIONS;
+    private static _RUNNING_MOTIONS;
+    private static _REMOVED_MOTIONS;
+    private static _TIMER;
+    private static _IS_UPDATING;
+    static get TIMER_TIME(): number;
+    static runMotion(k: Motion): Motion;
+    static removeMotion(k: Motion): void;
+    static getMotionByTag(k: string): Motion;
+    static getMotionByTarget(k: HTMLElement): Motion;
+    static getMotionByTagAndTarget(k: string, _arg_2: HTMLElement): Motion;
+    static get isRunning(): boolean;
+    static get isUpdating(): boolean;
+    private static onTick;
+    private static startTimer;
+    private static stopTimer;
+    getNumRunningMotions(k: HTMLElement): number;
+}