@akylas/nativescript-app-utils 2.2.1 → 2.2.3

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.2.3](https://github.com/akylas/nativescript-app-utils/compare/v2.2.2...v2.2.3) (2025-01-31)
+
+**Note:** Version bump only for package @akylas/nativescript-app-utils
+
+## [2.2.2](https://github.com/akylas/nativescript-app-utils/compare/v2.2.1...v2.2.2) (2025-01-27)
+
+**Note:** Version bump only for package @akylas/nativescript-app-utils
+
 ## [2.2.1](https://github.com/akylas/nativescript-app-utils/compare/v2.2.0...v2.2.1) (2024-12-18)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@akylas/nativescript-app-utils",
-    "version": "2.2.1",
+    "version": "2.2.3",
     "description": "Provides API for changing the styles of SystemUI (StatusBar, NavigationBar...) on iOS.",
     "main": "index",
     "sideEffects": false,
@@ -66,5 +66,5 @@
     "dependencies": {
         "@nativescript-community/ui-share-file": "1.3.3"
     },
-    "gitHead": "83d8799e538f6dae600c486a122b6bbafefd7e4a"
+    "gitHead": "a4acea396bce45159bcc13904cec638a444bc618"
 }

package/worker/BaseWorker.d.ts

@@ -0,0 +1,47 @@
+import type { Optional } from '@nativescript/core/utils/typescript-utils';
+import { EventData, Observable } from '@nativescript/core';
+export type WorkerEventType = 'event' | 'error' | 'started' | 'terminate';
+export interface WorkerPostOptions {
+    id?: number;
+    messageData?: string;
+}
+export type WorkerPostEvent = {
+    type: string;
+} & WorkerPostOptions;
+export interface WorkerEvent {
+    data: {
+        messageData?: any;
+        error?: Error;
+        nativeData?: {
+            [k: string]: any;
+        };
+        type: string;
+        id?: number;
+    };
+}
+export interface IWorker extends BaseWorker {
+    onmessage: Function;
+    postMessage(event: WorkerPostEvent): any;
+}
+export declare abstract class BaseWorker extends Observable {
+    protected context: any;
+    constructor(context: any);
+    onmessage: Function;
+    postMessage(event: WorkerPostEvent): void;
+    abstract receivedMessage(event: WorkerEvent): any;
+    receivedMessageBase(event: WorkerEvent): boolean;
+    messagePromises: {
+        [key: string]: {
+            resolve: Function;
+            reject: Function;
+            timeoutTimer: number;
+        }[];
+    };
+    postPromiseMessage<T = any>(type: string, messageData: any, id?: number, timeout?: number, nativeData?: any): Promise<T>;
+    stop(error?: any, id?: any): Promise<void>;
+    notify<T extends Optional<EventData & {
+        error?: Error;
+    }, 'object'>>(data: T): void;
+    notifyAndAwait<T = any>(eventName: any, data: any): Promise<T>;
+    sendError(error: any): Promise<void>;
+}

package/worker/BaseWorker.js

@@ -0,0 +1,126 @@
+import { time } from '@nativescript/core/profiling';
+import { getWorkerContextValue, setWorkerContextValue } from '@akylas/nativescript-app-utils';
+import { Observable } from '@nativescript/core';
+export class BaseWorker extends Observable {
+    constructor(context) {
+        super();
+        this.context = context;
+        this.messagePromises = {};
+        context.onmessage = (event) => {
+            // DEV_LOG && console.log(TAG, 'onmessage', Date.now(), event);
+            if (typeof event.data.messageData === 'string') {
+                try {
+                    event.data.messageData = JSON.parse(event.data.messageData);
+                }
+                catch (error) { }
+            }
+            if (Array.isArray(event.data.nativeData)) {
+                event.data.nativeData = event.data.nativeData.reduce((acc, key) => {
+                    const actualKey = key.split('$$$')[1];
+                    acc[actualKey] = getWorkerContextValue(key);
+                    setWorkerContextValue(key, null);
+                    return acc;
+                }, {});
+            }
+            if (typeof event.data.error === 'string') {
+                try {
+                    event.data.error = JSON.parse(event.data.error);
+                }
+                catch (error) { }
+            }
+            const handled = this.receivedMessageBase(event);
+            if (!handled) {
+                this.receivedMessage(event);
+            }
+        };
+        this.postMessage({
+            type: 'started'
+        });
+    }
+    postMessage(event) {
+        global.postMessage(event);
+    }
+    receivedMessageBase(event) {
+        const data = event.data;
+        const id = data.id;
+        // DEV_LOG && console.log(TAG, 'receivedMessage', data.type, id, id && this.messagePromises.hasOwnProperty(id), Object.keys(this.messagePromises), data);
+        if (data.type === 'terminate') {
+            this.context.close();
+            return true;
+        }
+        if (id && this.messagePromises.hasOwnProperty(id)) {
+            this.messagePromises[id].forEach(function (executor) {
+                executor.timeoutTimer && clearTimeout(executor.timeoutTimer);
+                const messageData = data.messageData;
+                if (!!messageData?.error) {
+                    executor.reject(messageData.error);
+                }
+                else {
+                    executor.resolve(messageData);
+                }
+            });
+            delete this.messagePromises[id];
+            return true;
+        }
+        return false;
+    }
+    postPromiseMessage(type, messageData, id = 0, timeout = 0, nativeData) {
+        return new Promise((resolve, reject) => {
+            id = id || time();
+            // DEV_LOG && console.warn(TAG, 'postPromiseMessage', type, id, timeout, messageData);
+            if (id || timeout) {
+                this.messagePromises[id] = this.messagePromises[id] || [];
+                let timeoutTimer;
+                if (timeout > 0) {
+                    timeoutTimer = setTimeout(() => {
+                        // we need to try catch because the simple fact of creating a new Error actually throws.
+                        // so we will get an uncaughtException
+                        try {
+                            reject(new Error('timeout'));
+                        }
+                        catch { }
+                        delete this.messagePromises[id];
+                    }, timeout);
+                }
+                this.messagePromises[id].push({ reject, resolve, timeoutTimer });
+            }
+            const mData = {
+                id,
+                messageData: JSON.stringify(messageData),
+                type
+            };
+            // DEV_LOG && console.log(TAG, 'postMessage', mData, this.messagePromises[id]);
+            this.postMessage(mData);
+        });
+    }
+    async stop(error, id) {
+        this.postMessage({
+            type: 'terminate'
+        });
+        this.context.close();
+    }
+    notify(data) {
+        // DEV_LOG && console.log(TAG, 'notify', data.eventName);
+        //we are a fake observable
+        if (data.error) {
+            // Error is not really serializable so we need custom handling
+            const { nativeException, ...error } = data.error;
+            data.error = { message: data.error.toString(), stack: data.error.stack, ...data.error };
+        }
+        this.postMessage({
+            messageData: JSON.stringify(data),
+            type: 'event'
+        });
+    }
+    async notifyAndAwait(eventName, data) {
+        return this.postPromiseMessage('event', { data, eventName });
+    }
+    async sendError(error) {
+        const { nativeException, ...realError } = error;
+        this.postMessage({
+            messageData: JSON.stringify({ error: { message: error.toString(), stack: error.stack, ...error } }),
+            type: 'error'
+        });
+    }
+}
+//# sourceMappingURL=BaseWorker.js.map

package/worker/BaseWorkerHandler.d.ts

@@ -0,0 +1,31 @@
+import { Observable } from '@nativescript/core';
+import type { BaseWorker, WorkerEventType, WorkerPostEvent } from './BaseWorker';
+import Queue from './queue';
+export default abstract class BaseWorkerHandler<T extends BaseWorker> extends Observable {
+    private createWorker;
+    constructor(createWorker: () => Worker);
+    worker: T;
+    messagePromises: {
+        [key: string]: {
+            resolve: Function;
+            reject: Function;
+            timeoutTimer: number;
+        }[];
+    };
+    abstract onWorkerEvent(eventData: any): any;
+    onWorkerMessage(event: {
+        data: {
+            id?: number;
+            type: WorkerEventType;
+            messageData?: string;
+            nativeDatas?: {
+                [k: string]: any;
+            };
+        };
+    }): Promise<void>;
+    abstract handleError(error: any): any;
+    abstract handleWorkerError(error: any): any;
+    queue: Queue;
+    internalSendMessageToWorker(data: WorkerPostEvent): Promise<unknown>;
+    sendMessageToWorker<T = any>(type: string, messageData?: any, id?: number, error?: any, isResponse?: boolean, timeout?: number, nativeData?: any): Promise<T>;
+}

package/worker/BaseWorkerHandler.js

@@ -0,0 +1,143 @@
+import { setWorkerContextValue } from '@akylas/nativescript-app-utils';
+import { Observable } from '@nativescript/core';
+import { time } from '@nativescript/core/profiling';
+import Queue from './queue';
+export default class BaseWorkerHandler extends Observable {
+    constructor(createWorker) {
+        super();
+        this.createWorker = createWorker;
+        this.messagePromises = {};
+        this.queue = new Queue();
+    }
+    async onWorkerMessage(event) {
+        // DEV_LOG && console.log('onWorkerMessage', event);
+        const data = event.data;
+        const id = data.id;
+        try {
+            let messageData = data.messageData;
+            if (typeof messageData === 'string') {
+                try {
+                    messageData = JSON.parse(messageData);
+                }
+                catch (error) { }
+            }
+            // DEV_LOG && console.error(TAG, 'onWorkerMessage', id, data.type, id && this.messagePromises.hasOwnProperty(id), Object.keys(this.messagePromises), messageData);
+            if (id && this.messagePromises.hasOwnProperty(id)) {
+                this.messagePromises[id].forEach(function (executor) {
+                    executor.timeoutTimer && clearTimeout(executor.timeoutTimer);
+                    executor.resolve(messageData);
+                });
+                delete this.messagePromises[id];
+            }
+            const eventData = messageData;
+            switch (data.type) {
+                case 'event':
+                    await this.onWorkerEvent(eventData);
+                    break;
+                case 'error':
+                    this.handleWorkerError(eventData.error);
+                    // showError(CustomError.fromObject(eventData.error));
+                    break;
+                case 'started':
+                    this.notify({ eventName: 'worker_started' });
+                    break;
+                case 'terminate':
+                    // console.info('worker stopped');
+                    this.worker = null;
+                    break;
+            }
+        }
+        catch (error) {
+            console.error(error, error.stack);
+            this.handleError(error);
+        }
+    }
+    async internalSendMessageToWorker(data) {
+        return this.queue.add(async () => {
+            // DEV_LOG && console.warn('internalSendMessageToWorker', data.type, !!this.worker);
+            if (!this.worker) {
+                await new Promise((resolve, reject) => {
+                    this.once('worker_started', () => {
+                        if (timeoutTimer) {
+                            clearTimeout(timeoutTimer);
+                        }
+                        resolve();
+                    });
+                    const worker = (this.worker = this.createWorker());
+                    worker.onmessage = this.onWorkerMessage.bind(this);
+                    worker.onerror = (e) => {
+                        reject(e);
+                        this.worker = null;
+                    };
+                    const timeoutTimer = setTimeout(() => {
+                        reject(new Error('failed_to_start_worker'));
+                    }, 2000);
+                });
+            }
+            this.worker.postMessage(data);
+        });
+    }
+    async sendMessageToWorker(type, messageData, id, error, isResponse = false, timeout = 0, nativeData) {
+        // DEV_LOG && console.info('Sync', 'sendMessageToWorker', type, id, timeout, isResponse, !isResponse && (id || timeout), messageData, nativeData, this.worker);
+        if (!isResponse && (id || timeout)) {
+            return new Promise(async (resolve, reject) => {
+                // const id = Date.now().valueOf();
+                id = id || time();
+                this.messagePromises[id] = this.messagePromises[id] || [];
+                let timeoutTimer;
+                if (timeout > 0) {
+                    timeoutTimer = setTimeout(() => {
+                        // we need to try catch because the simple fact of creating a new Error actually throws.
+                        // so we will get an uncaughtException
+                        try {
+                            reject(new Error('timeout'));
+                        }
+                        catch { }
+                        delete this.messagePromises[id];
+                    }, timeout);
+                }
+                this.messagePromises[id].push({ reject, resolve, timeoutTimer });
+                const keys = Object.keys(nativeData);
+                const nativeDataKeysPrefix = Date.now() + '$$$';
+                keys.forEach((k) => {
+                    setWorkerContextValue(nativeDataKeysPrefix + k, nativeData[k]._native || nativeData[k]);
+                });
+                const data = {
+                    error: !!error ? JSON.stringify(error.toJSON() ? error.toJSON() : { message: error.toString(), ...error }) : undefined,
+                    id,
+                    nativeDataKeysPrefix,
+                    messageData: !!messageData ? JSON.stringify(messageData) : undefined,
+                    nativeData: keys.map((k) => nativeDataKeysPrefix + k),
+                    type
+                };
+                // DEV_LOG && console.info('Sync', 'postMessage', JSON.stringify(data));
+                try {
+                    await this.internalSendMessageToWorker(data);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else {
+            // DEV_LOG && console.info('Sync', 'postMessage', 'test');
+            const keys = Object.keys(nativeData);
+            const nativeDataKeysPrefix = Date.now() + '$$$';
+            keys.forEach((k) => {
+                setWorkerContextValue(nativeDataKeysPrefix + k, nativeData[k]._native || nativeData[k]);
+            });
+            const data = {
+                error: !!error ? JSON.stringify({ message: error.toString(), ...error }) : undefined,
+                id,
+                nativeDataKeysPrefix,
+                messageData: !!messageData ? JSON.stringify(messageData) : undefined,
+                nativeData: keys.map((k) => nativeDataKeysPrefix + k),
+                type
+            };
+            // DEV_LOG && console.info('Sync', 'postMessage', JSON.stringify(data));
+            await this.internalSendMessageToWorker(data);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=BaseWorkerHandler.js.map

package/worker/queue.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from '@nativescript/core';
+export default class Queue extends Observable {
+    private workingOnPromise;
+    private queue;
+    add(promise: any): Promise<unknown>;
+    dequeue(): boolean;
+}

package/worker/queue.js

@@ -0,0 +1,49 @@
+import { Observable } from '@nativescript/core';
+export default class Queue extends Observable {
+    constructor() {
+        super(...arguments);
+        this.workingOnPromise = false;
+        this.queue = [];
+    }
+    add(promise) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                promise,
+                resolve,
+                reject
+            });
+            this.dequeue();
+        });
+    }
+    dequeue() {
+        if (this.workingOnPromise) {
+            return false;
+        }
+        const item = this.queue.shift();
+        if (!item) {
+            this.notify({ eventName: 'done' });
+            return false;
+        }
+        try {
+            this.workingOnPromise = true;
+            item.promise()
+                .then((value) => {
+                this.workingOnPromise = false;
+                item.resolve(value);
+                this.dequeue();
+            })
+                .catch((err) => {
+                this.workingOnPromise = false;
+                item.reject(err);
+                this.dequeue();
+            });
+        }
+        catch (err) {
+            this.workingOnPromise = false;
+            item.reject(err);
+            this.dequeue();
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=queue.js.map