@adaas/a-utils 0.2.7 → 0.2.9

package/src/lib/A-Polyfill/base/A-Path-Polyfill.base.ts

@@ -0,0 +1,34 @@
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { IpathInterface } from "../A-Polyfill.types";
+
+export abstract class A_PathPolyfillBase {
+    protected _path!: IpathInterface;
+    protected _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;
+    }
+
+    protected async init(): Promise<void> {
+        try {
+            await this.initImplementation();
+            this._initialized = true;
+        } catch (error) {
+            this.logger.error('Failed to initialize path polyfill', error);
+            throw error;
+        }
+    }
+
+    protected abstract initImplementation(): Promise<void>;
+}

package/src/lib/A-Polyfill/base/A-Process-Polyfill.base.ts

@@ -0,0 +1,34 @@
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { IprocessInterface } from "../A-Polyfill.types";
+
+export abstract class A_ProcessPolyfillBase {
+    protected _process!: IprocessInterface;
+    protected _initialized: boolean = false;
+
+    constructor(
+        protected logger: A_Logger
+    ) {}
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+    async get(): Promise<IprocessInterface> {
+        if (!this._initialized) {
+            await this.init();
+        }
+        return this._process;
+    }
+
+    protected async init(): Promise<void> {
+        try {
+            await this.initImplementation();
+            this._initialized = true;
+        } catch (error) {
+            this.logger.error('Failed to initialize process polyfill', error);
+            throw error;
+        }
+    }
+
+    protected abstract initImplementation(): Promise<void>;
+}

package/src/lib/A-Polyfill/base/A-Url-Polyfill.base.ts

@@ -0,0 +1,34 @@
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { IurlInterface } from "../A-Polyfill.types";
+
+export abstract class A_UrlPolyfillBase {
+    protected _url!: IurlInterface;
+    protected _initialized: boolean = false;
+
+    constructor(
+        protected logger: A_Logger
+    ) {}
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+    async get(): Promise<IurlInterface> {
+        if (!this._initialized) {
+            await this.init();
+        }
+        return this._url;
+    }
+
+    protected async init(): Promise<void> {
+        try {
+            await this.initImplementation();
+            this._initialized = true;
+        } catch (error) {
+            this.logger.error('Failed to initialize url polyfill', error);
+            throw error;
+        }
+    }
+
+    protected abstract initImplementation(): Promise<void>;
+}

package/src/lib/A-Polyfill/base/index.ts

@@ -0,0 +1,9 @@
+// Base classes for polyfill implementations
+export { A_BufferPolyfillBase } from './A-Buffer-Polyfill.base';
+export { A_CryptoPolyfillBase } from './A-Crypto-Polyfill.base';
+export { A_FSPolyfillBase } from './A-FS-Polyfill.base';
+export { A_HttpPolyfillBase } from './A-Http-Polyfill.base';
+export { A_HttpsPolyfillBase } from './A-Https-Polyfill.base';
+export { A_PathPolyfillBase } from './A-Path-Polyfill.base';
+export { A_ProcessPolyfillBase } from './A-Process-Polyfill.base';
+export { A_UrlPolyfillBase } from './A-Url-Polyfill.base';

package/src/lib/A-Polyfill/browser/A-Buffer-Polyfill.ts

@@ -0,0 +1,42 @@
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_BufferPolyfillBase } from "../base/A-Buffer-Polyfill.base";
+
+export class A_BufferPolyfill extends A_BufferPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._buffer = {
+            from: (data: any, encoding?: string) => {
+                if (typeof data === 'string') {
+                    return new TextEncoder().encode(data);
+                }
+                return new Uint8Array(data);
+            },
+            alloc: (size: number, fill?: any) => {
+                const buffer = new Uint8Array(size);
+                if (fill !== undefined) {
+                    buffer.fill(fill);
+                }
+                return buffer;
+            },
+            allocUnsafe: (size: number) => {
+                return new Uint8Array(size);
+            },
+            isBuffer: (obj: any) => {
+                return obj instanceof Uint8Array || obj instanceof ArrayBuffer;
+            },
+            concat: (list: any[], totalLength?: number) => {
+                const length = totalLength || list.reduce((sum, buf) => sum + buf.length, 0);
+                const result = new Uint8Array(length);
+                let offset = 0;
+                for (const buf of list) {
+                    result.set(buf, offset);
+                    offset += buf.length;
+                }
+                return result;
+            }
+        };
+    }
+}

package/src/lib/A-Polyfill/browser/A-Crypto-Polyfill.ts

@@ -0,0 +1,32 @@
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_CryptoPolyfillBase } from "../base/A-Crypto-Polyfill.base";
+
+export class A_CryptoPolyfill extends A_CryptoPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._crypto = {
+            createFileHash: () => {
+                this.logger.warning('File hash not available in browser environment');
+                return Promise.resolve('');
+            },
+            createTextHash: (text: string, algorithm: string = 'SHA-384') => new Promise<string>(async (resolve, reject) => {
+                try {
+                    if (!crypto.subtle) {
+                        throw new Error('SubtleCrypto not available');
+                    }
+                    const encoder = new TextEncoder();
+                    const data = encoder.encode(text);
+                    const hashBuffer = await crypto.subtle.digest(algorithm, data);
+                    const hashArray = Array.from(new Uint8Array(hashBuffer));
+                    const hashBase64 = btoa(String.fromCharCode(...hashArray));
+                    resolve(`${algorithm}-${hashBase64}`);
+                } catch (error) {
+                    reject(error);
+                }
+            })
+        };
+    }
+}

package/src/lib/A-Polyfill/browser/A-FS-Polyfill.ts

@@ -0,0 +1,25 @@
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_FSPolyfillBase } from "../base/A-FS-Polyfill.base";
+
+export class A_FSPolyfill extends A_FSPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._fs = {
+            readFileSync: (path: string, encoding: string) => {
+                this.logger.warning('fs.readFileSync not available in browser environment');
+                return '';
+            },
+            existsSync: (path: string) => {
+                this.logger.warning('fs.existsSync not available in browser environment');
+                return false;
+            },
+            createReadStream: (path: string) => {
+                this.logger.warning('fs.createReadStream not available in browser environment');
+                return null;
+            }
+        };
+    }
+}

package/src/lib/A-Polyfill/{classes/A-Http-Polyfill.class.ts → browser/A-Http-Polyfill.ts}

@@ -1,52 +1,12 @@
-import { A_Context } from "@adaas/a-concept";
-import { IhttpInterface } from "../A-Polyfill.types";
-import { A_Logger } from "../../A-Logger/A-Logger.component";
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_HttpPolyfillBase } from "../base/A-Http-Polyfill.base";
 
-export class A_HttpPolyfillClass {
-    private _http!: IhttpInterface;
-    private _initialized: boolean = false;
-
-    constructor(
-        protected logger: A_Logger
-    ) {
-
-    }
-
-    get isInitialized(): boolean {
-        return this._initialized;
-    }
-
-    async get(): Promise<IhttpInterface> {
-        if (!this._initialized) {
-            await this.init();
-        }
-        return this._http;
-    }
-
-    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 httpModule = await import('http');
-        this._http = {
-            request: httpModule.request,
-            get: httpModule.get,
-            createServer: httpModule.createServer
-        };
+export class A_HttpPolyfill extends A_HttpPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
     }
 
-    private initBrowser(): void {
+    protected async initImplementation(): Promise<void> {
         this._http = {
             request: (options: any, callback?: (res: any) => void) => {
                 this.logger.warning('http.request not available in browser/test environment, use fetch instead');

package/src/lib/A-Polyfill/{classes/A-Https-Polyfill.class.ts → browser/A-Https-Polyfill.ts}

@@ -1,52 +1,12 @@
-import { A_Context } from "@adaas/a-concept";
-import { IhttpsInterface } from "../A-Polyfill.types";
-import { A_Logger } from "../../A-Logger/A-Logger.component";
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_HttpsPolyfillBase } from "../base/A-Https-Polyfill.base";
 
-export class A_HttpsPolyfillClass {
-    private _https!: IhttpsInterface;
-    private _initialized: boolean = false;
-
-    constructor(
-        protected logger: A_Logger
-    ) {
-
-    }
-
-    get isInitialized(): boolean {
-        return this._initialized;
-    }
-
-    async get(): Promise<IhttpsInterface> {
-        if (!this._initialized) {
-            await this.init();
-        }
-        return this._https;
-    }
-
-    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 httpsModule = await import('https');
-        this._https = {
-            request: httpsModule.request,
-            get: httpsModule.get,
-            createServer: httpsModule.createServer
-        };
+export class A_HttpsPolyfill extends A_HttpsPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
     }
 
-    private initBrowser(): void {
+    protected async initImplementation(): Promise<void> {
         this._https = {
             request: (options: any, callback?: (res: any) => void) => {
                 this.logger.warning('https.request not available in browser/test environment, use fetch instead');

package/src/lib/A-Polyfill/{classes/A-Path-Polyfill.class.ts → browser/A-Path-Polyfill.ts}

@@ -1,48 +1,12 @@
-import { A_Context } from "@adaas/a-concept";
-import { IpathInterface } from "../A-Polyfill.types";
-import { A_Logger } from "../../A-Logger/A-Logger.component";
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_PathPolyfillBase } from "../base/A-Path-Polyfill.base";
 
-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;
+export class A_PathPolyfill extends A_PathPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
     }
 
-    private initBrowser(): void {
+    protected async initImplementation(): Promise<void> {
         this._path = {
             join: (...paths: string[]) => {
                 return paths.join('/').replace(/\/+/g, '/');

package/src/lib/A-Polyfill/browser/A-Process-Polyfill.ts

@@ -0,0 +1,29 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_ProcessPolyfillBase } from "../base/A-Process-Polyfill.base";
+
+export class A_ProcessPolyfill extends A_ProcessPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<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/browser/A-Url-Polyfill.ts

@@ -0,0 +1,46 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_UrlPolyfillBase } from "../base/A-Url-Polyfill.base";
+
+export class A_UrlPolyfill extends A_UrlPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<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
+        };
+    }
+}

package/src/lib/A-Polyfill/browser/index.ts

@@ -0,0 +1,8 @@
+export * from "./A-Crypto-Polyfill";
+export * from "./A-FS-Polyfill";
+// export * from "./A-HHttp-Polyfill";
+export * from "./A-Https-Polyfill";
+export * from "./A-Path-Polyfill";
+export * from "./A-Process-Polyfill";
+export * from "./A-Url-Polyfill";
+export * from "./A-Buffer-Polyfill";

package/src/lib/A-Polyfill/index.browser.ts

@@ -0,0 +1,5 @@
+// A-Polyfill Component Entry Point
+export { A_Polyfill } from './A-Polyfill.component.env-browser';
+export * from './base';
+export * from './A-Polyfill.types';
+export * from './browser'

package/src/lib/A-Polyfill/index.node.ts

@@ -0,0 +1,5 @@
+// A-Polyfill Component Entry Point
+export { A_Polyfill } from './A-Polyfill.component.env-node';
+export * from './base';
+export * from './A-Polyfill.types';
+export * from './node';

package/src/lib/A-Polyfill/node/A-Buffer-Polyfill.ts

@@ -0,0 +1,19 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_BufferPolyfillBase } from "../base/A-Buffer-Polyfill.base";
+import bufferModule from 'buffer';
+
+export class A_BufferPolyfill extends A_BufferPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._buffer = {
+            from: bufferModule.Buffer.from,
+            alloc: bufferModule.Buffer.alloc,
+            allocUnsafe: bufferModule.Buffer.allocUnsafe,
+            isBuffer: bufferModule.Buffer.isBuffer,
+            concat: bufferModule.Buffer.concat
+        };
+    }
+}

package/src/lib/A-Polyfill/node/A-Crypto-Polyfill.ts

@@ -0,0 +1,31 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_CryptoPolyfillBase } from "../base/A-Crypto-Polyfill.base";
+import crypto from 'crypto';
+
+export class A_CryptoPolyfill extends A_CryptoPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._crypto = {
+            createTextHash: (text: string, algorithm: string = 'sha384') => Promise.resolve(
+                `${algorithm}-${crypto.createHash(algorithm).update(text).digest('base64')}`
+            ),
+            createFileHash: (filePath: string, algorithm: string = 'sha384') => new Promise(async (resolve, reject) => {
+                try {
+                    if (!this._fsPolyfill) {
+                        throw new Error('FS polyfill is required for file hashing');
+                    }
+                    const hash = crypto.createHash(algorithm);
+                    const fileStream = this._fsPolyfill.createReadStream(filePath);
+                    fileStream.on('data', (data: any) => hash.update(data));
+                    fileStream.on('end', () => resolve(`${algorithm}-${hash.digest('base64')}`));
+                    fileStream.on('error', (err: any) => reject(err));
+                } catch (error) {
+                    reject(error);
+                }
+            })
+        };
+    }
+}

package/src/lib/A-Polyfill/node/A-FS-Polyfill.ts

@@ -0,0 +1,14 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_FSPolyfillBase } from "../base/A-FS-Polyfill.base";
+import { Ifspolyfill } from "../A-Polyfill.types";
+import fs from 'fs';
+
+export class A_FSPolyfill extends A_FSPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._fs = fs as Ifspolyfill;
+    }
+}

package/src/lib/A-Polyfill/node/A-Http-Polyfill.ts

@@ -0,0 +1,17 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_HttpPolyfillBase } from "../base/A-Http-Polyfill.base";
+import httpModule from 'http';
+
+export class A_HttpPolyfill extends A_HttpPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._http = {
+            request: httpModule.request,
+            get: httpModule.get,
+            createServer: httpModule.createServer
+        };
+    }
+}

package/src/lib/A-Polyfill/node/A-Https-Polyfill.ts

@@ -0,0 +1,18 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_HttpsPolyfillBase } from "../base/A-Https-Polyfill.base";
+import httpsModule from 'https';
+
+
+export class A_HttpsPolyfill extends A_HttpsPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._https = {
+            request: httpsModule.request,
+            get: httpsModule.get,
+            createServer: httpsModule.createServer
+        };
+    }
+}

package/src/lib/A-Polyfill/node/A-Path-Polyfill.ts

@@ -0,0 +1,27 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_PathPolyfillBase } from "../base/A-Path-Polyfill.base";
+import { IpathInterface } from "../A-Polyfill.types";
+import pathModule from 'path';
+
+export class A_PathPolyfill extends A_PathPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        this._path = {
+            basename: pathModule.basename,
+            dirname: pathModule.dirname,
+            extname: pathModule.extname,
+            join: pathModule.join,
+            resolve: pathModule.resolve,
+            relative: pathModule.relative,
+            normalize: pathModule.normalize,
+            isAbsolute: pathModule.isAbsolute,
+            parse: pathModule.parse,
+            format: pathModule.format,
+            sep: pathModule.sep,
+            delimiter: pathModule.delimiter
+        } as IpathInterface;
+    }
+}

package/src/lib/A-Polyfill/node/A-Process-Polyfill.ts

@@ -0,0 +1,21 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_ProcessPolyfillBase } from "../base/A-Process-Polyfill.base";
+
+export class A_ProcessPolyfill extends A_ProcessPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<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
+        };
+    }
+}

package/src/lib/A-Polyfill/node/A-Url-Polyfill.ts

@@ -0,0 +1,19 @@
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_UrlPolyfillBase } from "../base/A-Url-Polyfill.base";
+import urlModule from 'url';
+
+export class A_UrlPolyfill extends A_UrlPolyfillBase {
+    constructor(logger: A_Logger) {
+        super(logger);
+    }
+
+    protected async initImplementation(): Promise<void> {
+        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
+        };
+    }
+}