@adaas/a-utils 0.1.10 → 0.1.12

package/src/lib/A-Polyfill/classes/A-Path-Polyfill.class.ts

@@ -0,0 +1,97 @@
+import { A_Context } from "@adaas/a-concept";
+import { IpathInterface } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+export class A_PathPolyfillClass {
+    private _path!: IpathInterface;
+    private _initialized: boolean = false;
+
+    constructor(
+        protected logger: A_Logger
+    ) {
+
+    }
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+
+    async get(): Promise<IpathInterface> {
+        if (!this._initialized) {
+            await this.init();
+        }
+        return this._path;
+    }
+
+    private async init(): Promise<void> {
+        try {
+            if (A_Context.environment === 'server') {
+                await this.initServer();
+            } else {
+                this.initBrowser();
+            }
+            this._initialized = true;
+        } catch (error) {
+            this.initBrowser();
+            this._initialized = true;
+        }
+    }
+
+    private async initServer(): Promise<void> {
+        this._path = await import('path') as IpathInterface;
+    }
+
+    private initBrowser(): void {
+        this._path = {
+            join: (...paths: string[]) => {
+                return paths.join('/').replace(/\/+/g, '/');
+            },
+            resolve: (...paths: string[]) => {
+                let resolvedPath = '';
+                for (const path of paths) {
+                    if (path.startsWith('/')) {
+                        resolvedPath = path;
+                    } else {
+                        resolvedPath = this._path.join(resolvedPath, path);
+                    }
+                }
+                return resolvedPath || '/';
+            },
+            dirname: (path: string) => {
+                const parts = path.split('/');
+                return parts.slice(0, -1).join('/') || '/';
+            },
+            basename: (path: string, ext?: string) => {
+                const base = path.split('/').pop() || '';
+                return ext && base.endsWith(ext) ? base.slice(0, -ext.length) : base;
+            },
+            extname: (path: string) => {
+                const parts = path.split('.');
+                return parts.length > 1 ? '.' + parts.pop() : '';
+            },
+            relative: (from: string, to: string) => {
+                // Simplified relative path calculation
+                return to.replace(from, '').replace(/^\//, '');
+            },
+            normalize: (path: string) => {
+                return path.replace(/\/+/g, '/').replace(/\/$/, '') || '/';
+            },
+            isAbsolute: (path: string) => {
+                return path.startsWith('/') || /^[a-zA-Z]:/.test(path);
+            },
+            parse: (path: string) => {
+                const ext = this._path.extname(path);
+                const base = this._path.basename(path);
+                const name = this._path.basename(path, ext);
+                const dir = this._path.dirname(path);
+                return { root: '/', dir, base, ext, name };
+            },
+            format: (pathObject: any) => {
+                return this._path.join(pathObject.dir || '', pathObject.base || '');
+            },
+            sep: '/',
+            delimiter: ':'
+        };
+    }
+}

package/src/lib/A-Polyfill/classes/A-Process-Polyfill.class.ts

@@ -0,0 +1,73 @@
+import { A_Context } from "@adaas/a-concept";
+import { IprocessInterface } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+export class A_ProcessPolyfillClass {
+    private _process!: IprocessInterface;
+    private _initialized: boolean = false;
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+    constructor(
+        protected logger: A_Logger
+    ) {
+
+    }
+
+    async get(): Promise<IprocessInterface> {
+        if (!this._initialized) {
+            await this.init();
+        }
+        return this._process;
+    }
+
+    private async init(): Promise<void> {
+        try {
+            if (A_Context.environment === 'server') {
+                this.initServer();
+            } else {
+                this.initBrowser();
+            }
+            this._initialized = true;
+        } catch (error) {
+            this.initBrowser();
+            this._initialized = true;
+        }
+    }
+
+    private initServer(): void {
+        this._process = {
+            env: process.env as Record<string, string>,
+            argv: process.argv,
+            platform: process.platform,
+            version: process.version,
+            versions: process.versions as Record<string, string>,
+            cwd: process.cwd,
+            exit: process.exit,
+            nextTick: process.nextTick
+        };
+    }
+
+    private initBrowser(): void {
+        this._process = {
+            env: {
+                NODE_ENV: 'browser',
+                ...((globalThis as any).process?.env || {})
+            },
+            argv: ['browser'],
+            platform: 'browser',
+            version: 'browser',
+            versions: { node: 'browser' },
+            cwd: () => '/',
+            exit: (code?: number) => {
+                this.logger.warning('process.exit not available in browser');
+                throw new Error(`Process exit with code ${code}`);
+            },
+            nextTick: (callback: Function, ...args: any[]) => {
+                setTimeout(() => callback(...args), 0);
+            }
+        };
+    }
+}

package/src/lib/A-Polyfill/classes/A-Url-Polyfill.class.ts

@@ -0,0 +1,88 @@
+import { A_Context } from "@adaas/a-concept";
+import { IurlInterface } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+export class A_UrlPolyfillClass {
+    private _url!: IurlInterface;
+    private _initialized: boolean = false;
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+    constructor(
+        protected logger: A_Logger
+    ) {
+
+    }
+
+    async get(): Promise<IurlInterface> {
+        if (!this._initialized) {
+            await this.init();
+        }
+        return this._url;
+    }
+
+    private async init(): Promise<void> {
+        try {
+            if (A_Context.environment === 'server') {
+                await this.initServer();
+            } else {
+                this.initBrowser();
+            }
+            this._initialized = true;
+        } catch (error) {
+            this.initBrowser();
+            this._initialized = true;
+        }
+    }
+
+    private async initServer(): Promise<void> {
+        const urlModule = await import('url');
+        this._url = {
+            parse: urlModule.parse,
+            format: urlModule.format,
+            resolve: urlModule.resolve,
+            URL: (urlModule.URL || globalThis.URL) as any,
+            URLSearchParams: (urlModule.URLSearchParams || globalThis.URLSearchParams) as any
+        };
+    }
+
+    private initBrowser(): void {
+        this._url = {
+            parse: (urlString: string) => {
+                try {
+                    const url = new URL(urlString);
+                    return {
+                        protocol: url.protocol,
+                        hostname: url.hostname,
+                        port: url.port,
+                        pathname: url.pathname,
+                        search: url.search,
+                        hash: url.hash,
+                        host: url.host,
+                        href: url.href
+                    };
+                } catch {
+                    return {};
+                }
+            },
+            format: (urlObject: any) => {
+                try {
+                    return new URL('', urlObject.href || `${urlObject.protocol}//${urlObject.host}${urlObject.pathname}${urlObject.search}${urlObject.hash}`).href;
+                } catch {
+                    return '';
+                }
+            },
+            resolve: (from: string, to: string) => {
+                try {
+                    return new URL(to, from).href;
+                } catch {
+                    return to;
+                }
+            },
+            URL: globalThis.URL,
+            URLSearchParams: globalThis.URLSearchParams
+        };
+    }
+}