@urga-panel/ur-panels-core 1.0.0

package/dist/services/abstract/pageServices/pages/NsPageService.js

@@ -0,0 +1,66 @@
+import { Service } from "../../../../types/Service.js";
+export class NSPageService extends Service {
+    serviceInfo;
+    model;
+    page;
+    constructor(ots) {
+        super({ ...ots });
+    }
+    async onSetup(options) {
+        this.log.OK("onSetup called", options);
+        return { status: "success", message: "setup complete" };
+    }
+    async onStart() {
+        this.log.OK("onStart called");
+        return { status: "success", message: "started" };
+    }
+    async onStop() {
+        this.log.OK("onStop called");
+        return { status: "success", message: "stopped" };
+    }
+    async onDestroy() {
+        this.log.OK("onDestroy called");
+        return { status: "success", message: "destroyed" };
+    }
+    navigatingTo(callback, model, args) {
+        this.log.OK("navigatingTo called");
+        if (callback)
+            callback(args);
+        if (model) {
+            this.model = model;
+            //ts-ignore
+            const page = args.object;
+            page.bindingContext = model;
+            this.page = page;
+            this.log.OK("Model set:", model);
+        }
+        else {
+            this.log.WARN("No model provided");
+        }
+    }
+    navigatedTo(callback, args) {
+        this.log.OK("navigatedTo called");
+        if (callback)
+            callback(args);
+    }
+    onLoaded(callback, args) {
+        this.log.OK("onLoaded called");
+        if (callback)
+            callback(args);
+    }
+    onUnloaded(callback, args) {
+        this.log.OK("onUnloaded called");
+        if (callback)
+            callback(args);
+    }
+    navigatingFrom(callback, args) {
+        this.log.OK("navigatingFrom called");
+        if (callback)
+            callback(args);
+    }
+    navigatedFrom(callback, args) {
+        this.log.OK("navigatedFrom called");
+        if (callback)
+            callback(args);
+    }
+}

package/dist/services/abstract/project/ProjectInfoService.d.ts

@@ -0,0 +1,42 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+import { PageService } from "../pageServices/PageServices.js";
+export type ProjectsPages = {
+    [key: string]: {
+        icon: string;
+        title: string;
+        slug: string;
+        description: string;
+        showInMenu: boolean;
+        showInMobile: boolean;
+        order: number;
+        group?: string;
+        service?: PageService;
+        serviceRef: any;
+        userGroup?: string;
+    };
+};
+export type ProjectInfoOts = ServiceOts & {
+    usedService: {};
+};
+export declare abstract class ProjectInfoService extends Service {
+    ots: ProjectInfoOts;
+    static serviceInfo: {
+        name: string;
+        requiredServices: any[];
+    };
+    abstract pages: ProjectsPages;
+    constructor(ots: ProjectInfoOts);
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    getMenuPages(userGroup?: string): {
+        [key: string]: ProjectsPages[string];
+    };
+    getMobilePages(limit?: number): {
+        [key: string]: ProjectsPages[string];
+    };
+}

package/dist/services/abstract/project/ProjectInfoService.js

@@ -0,0 +1,72 @@
+import { Service } from "../../../types/Service.js";
+import { PageService } from "../pageServices/PageServices.js";
+export class ProjectInfoService extends Service {
+    ots;
+    static serviceInfo = {
+        name: "ProjectInfoService",
+        requiredServices: [],
+    };
+    constructor(ots) {
+        super({ ...ots });
+        this.ots = ots;
+    }
+    async onSetup(options) {
+        // Create a service for each page
+        Object.keys(this.pages).forEach(async (tag) => {
+            const service = this.ots.abilities.createChildService?.("ProjectPage-" + tag, this.pages[tag].serviceRef || PageService);
+            if (service) {
+                this.pages[tag].service = service;
+            }
+            await service.setup();
+        });
+        return { status: "success", message: "setup complete" };
+    }
+    async onStart() {
+        // Object.keys(this.pages).forEach(async tag => {
+        //     const service = this.ots.abilities.createChildService?.("ProjectPage-"+tag);
+        //     await service.start();
+        // });
+        return { status: "success", message: "started" };
+    }
+    async onStop() {
+        return { status: "success", message: "stopped" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "destroyed" };
+    }
+    getMenuPages(userGroup) {
+        const result = {};
+        Object.entries(this.pages).forEach(([key, page]) => {
+            if (page.showInMenu) {
+                if (userGroup && userGroup == 'admin') {
+                    result[key] = page;
+                }
+                else {
+                    if (userGroup) {
+                        // Check if the page is accessible by the user group
+                        if (page.userGroup === userGroup) {
+                            result[key] = page;
+                        }
+                    }
+                    else {
+                        result[key] = page;
+                    }
+                }
+            }
+        });
+        return result;
+    }
+    getMobilePages(limit = 4) {
+        const result = {};
+        let count = 0;
+        for (const [key, page] of Object.entries(this.pages)) {
+            if (page.showInMobile) {
+                result[key] = page;
+                count++;
+                if (count >= limit)
+                    break;
+            }
+        }
+        return result;
+    }
+}

package/dist/services/abstract/webviewServices/WVBackService.d.ts

@@ -0,0 +1,18 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type WVBackServiceOts = ServiceOts & {
+    usedService: {};
+};
+export declare class WVBackService extends Service {
+    static serviceInfo: {
+        name: string;
+        requiredServices: any[];
+    };
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    constructor(ots: WVBackServiceOts);
+}

package/dist/services/abstract/webviewServices/WVBackService.js

@@ -0,0 +1,22 @@
+import { Service } from "../../../types/Service.js";
+export class WVBackService extends Service {
+    static serviceInfo = {
+        name: "WVBackService",
+        requiredServices: [],
+    };
+    async onSetup(options) {
+        return { status: "success", message: "onSetup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "onStart complete" };
+    }
+    async onStop() {
+        return { status: "success", message: "onStop complete" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    constructor(ots) {
+        super({ ...ots });
+    }
+}

package/dist/services/abstract/webviewServices/WVFrontService.d.ts

@@ -0,0 +1,21 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+import { NSWebViewinterface } from "./nv.js";
+export type WVFrontServiceOts = ServiceOts & {
+    usedService: {};
+};
+export declare class WVFrontService extends Service {
+    static serviceInfo: {
+        name: string;
+        requiredServices: any[];
+    };
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    oWebViewInterface: NSWebViewinterface;
+    constructor(ots: WVFrontServiceOts);
+    sendFetchRequest(url: string, options?: RequestInit): Promise<any>;
+}

package/dist/services/abstract/webviewServices/WVFrontService.js

@@ -0,0 +1,54 @@
+import { Service } from "../../../types/Service.js";
+import { NSWebViewinterface } from "./nv.js";
+export class WVFrontService extends Service {
+    static serviceInfo = {
+        name: "WVFrontService",
+        requiredServices: [],
+    };
+    async onSetup(options) {
+        this.oWebViewInterface = new NSWebViewinterface();
+        //@ts-ignore
+        window.nsWebViewInterface = this.oWebViewInterface;
+        this.oWebViewInterface.emit("loadFinished", "");
+        return { status: "success", message: "onSetup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "onStart complete" };
+    }
+    async onStop() {
+        return { status: "success", message: "onStop complete" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    oWebViewInterface;
+    constructor(ots) {
+        super({ ...ots });
+    }
+    async sendFetchRequest(url, options) {
+        console.log("sendFetchRequest", url, options);
+        return new Promise((resolve) => {
+            const callback = (args) => {
+                const param = args;
+                // Convert param to a Response object
+                debugger;
+                //@ts-ignore
+                const byteArray = Object.values(param._bodyBlob._buffer);
+                //@ts-ignore
+                const uint8 = new Uint8Array(byteArray);
+                //@ts-ignore
+                const text = new TextDecoder().decode(uint8);
+                const response = new Response(text, {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+                debugger;
+                console.log("sendFetchRequest received", param);
+                this.oWebViewInterface.removeListener('sendFetchRequest', callback);
+                resolve(response);
+            };
+            this.oWebViewInterface.on('sendFetchRequest', callback);
+            this.oWebViewInterface.emit("sendFetchRequest", { url, options });
+        });
+    }
+}

package/dist/services/abstract/webviewServices/nv.d.ts

@@ -0,0 +1,26 @@
+type EventCallback = (data: any) => any;
+declare global {
+    interface Window {
+        androidWebViewInterface?: {
+            handleEventFromWebView: (eventName: string, data: any) => void;
+        };
+    }
+}
+declare class NSWebViewinterface {
+    private eventListenerMap;
+    private _iosResponseMap;
+    private _iosCntResponseId;
+    constructor();
+    private _onNativeEvent;
+    private _callJSFunction;
+    private _getResolvedFunction;
+    private _sendJSCallResponse;
+    private _createIFrame;
+    private _emitEventToIOS;
+    private _getIOSResponse;
+    private _emitEventToAndroid;
+    on(eventName: string, callback: EventCallback): void;
+    removeListener(eventName: string, callback: EventCallback): void;
+    emit(eventName: string, data: any): void;
+}
+export { NSWebViewinterface };

package/dist/services/abstract/webviewServices/nv.js

@@ -0,0 +1,99 @@
+class NSWebViewinterface {
+    eventListenerMap;
+    _iosResponseMap;
+    _iosCntResponseId;
+    constructor() {
+        this.eventListenerMap = {};
+        this._iosResponseMap = {};
+        this._iosCntResponseId = 0;
+    }
+    _onNativeEvent(eventName, data) {
+        const lstEvtListeners = this.eventListenerMap[eventName] || [];
+        for (let _i = 0; _i < lstEvtListeners.length; _i++) {
+            const listener = lstEvtListeners[_i];
+            const retnVal = listener && listener(data);
+            if (retnVal === false) {
+                break;
+            }
+        }
+    }
+    _callJSFunction(reqId, functionName, args) {
+        const resolvedFn = this._getResolvedFunction(functionName);
+        if (resolvedFn) {
+            const retnVal = resolvedFn.apply(window, args);
+            if (retnVal && retnVal.then) {
+                retnVal.then((value) => this._sendJSCallResponse(reqId, value), (error) => this._sendJSCallResponse(reqId, error, true));
+            }
+            else {
+                this._sendJSCallResponse(reqId, retnVal);
+            }
+        }
+    }
+    _getResolvedFunction(functionName) {
+        if (functionName && (functionName = functionName.trim()).length) {
+            functionName = functionName.indexOf('window.') === 0 ? functionName.replace('window.', '') : functionName;
+            const arrFnPath = functionName.split('.');
+            let fn = window;
+            for (let i = 0; i < arrFnPath.length; i++) {
+                if (!fn[arrFnPath[i]]) {
+                    fn = null;
+                    break;
+                }
+                fn = fn[arrFnPath[i]];
+            }
+            return typeof fn === 'function' ? fn : null;
+        }
+        return null;
+    }
+    _sendJSCallResponse(reqId, response, isError) {
+        const oResponse = {
+            reqId: reqId,
+            response: response ?? null,
+            isError: !!isError
+        };
+        this.emit('_jsCallResponse', oResponse);
+    }
+    _createIFrame(src) {
+        const rootElm = document.documentElement;
+        const newFrameElm = document.createElement("IFRAME");
+        newFrameElm.setAttribute("src", src);
+        rootElm.appendChild(newFrameElm);
+        return newFrameElm;
+    }
+    _emitEventToIOS(eventName, data) {
+        this._iosResponseMap[++this._iosCntResponseId] = data;
+        const metadata = { eventName: eventName, resId: this._iosCntResponseId };
+        const url = 'js2ios:' + JSON.stringify(metadata);
+        const iFrame = this._createIFrame(url);
+        iFrame.parentNode?.removeChild(iFrame);
+    }
+    _getIOSResponse(resId) {
+        const response = this._iosResponseMap[resId];
+        delete this._iosResponseMap[resId];
+        return response;
+    }
+    _emitEventToAndroid(eventName, data) {
+        window.androidWebViewInterface?.handleEventFromWebView(eventName, data);
+    }
+    on(eventName, callback) {
+        const lstListeners = this.eventListenerMap[eventName] || (this.eventListenerMap[eventName] = []);
+        lstListeners.push(callback);
+    }
+    removeListener(eventName, callback) {
+        const listeners = this.eventListenerMap[eventName];
+        if (listeners) {
+            // Belirtilen geri çağırma işlevini kaldır
+            this.eventListenerMap[eventName] = listeners.filter(listener => listener !== callback);
+        }
+    }
+    emit(eventName, data) {
+        const strData = typeof data === 'object' ? JSON.stringify(data) : data;
+        if (window.androidWebViewInterface) {
+            this._emitEventToAndroid(eventName, strData);
+        }
+        else {
+            this._emitEventToIOS(eventName, strData);
+        }
+    }
+}
+export { NSWebViewinterface };

package/dist/services/main/fetchServices/FetchBrowserService.d.ts

@@ -0,0 +1,19 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type FetchBrowserServiceOts = ServiceOts & {
+    usedService: {};
+};
+export declare class FetchBrowserService extends Service {
+    static serviceInfo: {
+        name: string;
+        requiredServices: any[];
+    };
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    constructor(ots: FetchBrowserServiceOts);
+    sendFetchRequest(url: string, options?: RequestInit): Promise<Response>;
+}

package/dist/services/main/fetchServices/FetchBrowserService.js

@@ -0,0 +1,26 @@
+import { Service } from "../../../types/Service.js";
+export class FetchBrowserService extends Service {
+    static serviceInfo = {
+        name: "FetchBrowserService",
+        requiredServices: [],
+    };
+    async onSetup(options) {
+        return { status: "success", message: "onSetup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "onStart complete" };
+    }
+    async onStop() {
+        return { status: "success", message: "onStop complete" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    constructor(ots) {
+        super({ ...ots });
+    }
+    async sendFetchRequest(url, options) {
+        const response = await fetch(url, options);
+        return response;
+    }
+}

package/dist/services/main/httpServices/RequestHandlerService.d.ts

@@ -0,0 +1,46 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type HandlerList = {
+    [key: string]: {
+        callback({ params, request, url, user }: {
+            params: any;
+            request: any;
+            url: any;
+            user?: any;
+        }): Promise<any>;
+        options?: {
+            auth?: boolean;
+            role?: string;
+        };
+    };
+};
+export declare class RequestHandlerService extends Service {
+    ots: any;
+    static serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    handlers: HandlerList;
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    constructor(ots: any);
+    addHandler(name: string, callback: ({ params, request, url, user }: {
+        params: any;
+        request: any;
+        url: any;
+        user: any;
+    }) => Promise<any>, options?: {
+        auth?: boolean;
+        role?: string;
+    }): Promise<void>;
+    requestCome({ params, request, url }: {
+        params: any;
+        request: any;
+        url: any;
+    }): Promise<any>;
+    getCookie(cookieHeader: string | null, name: string): string | undefined;
+    resposeHandler(response: any): Response;
+}