@adaas/a-utils 0.1.10 → 0.1.11

package/src/lib/A-Polyfill/A-Polyfill.component.ts

@@ -1,20 +1,90 @@
-import { A_Component } from "@adaas/a-concept";
-import { A_PolyfillClass } from "./A-Polyfills.class";
+import { A_Component, A_Concept, A_Context, A_Inject } from "@adaas/a-concept";
+import { A_Logger } from "../A-Logger/A-Logger.component";
+import { A_FSPolyfillClass } from "./classes/A-FS-Polyfill.class";
+import { A_CryptoPolyfillClass } from "./classes/A-Crypto-Polyfill.class";
+import { A_HttpPolyfillClass } from "./classes/A-Http-Polyfill.class";
+import { A_HttpsPolyfillClass } from "./classes/A-Https-Polyfill.class";
+import { A_PathPolyfillClass } from "./classes/A-Path-Polyfill.class";
+import { A_UrlPolyfillClass } from "./classes/A-Url-Polyfill.class";
+import { A_BufferPolyfillClass } from "./classes/A-Buffer-Polyfill.class";
+import { A_ProcessPolyfillClass } from "./classes/A-Process-Polyfill.class";
 
+export class A_Polyfill extends A_Component {
 
+    protected _fsPolyfill!: A_FSPolyfillClass;
+    protected _cryptoPolyfill!: A_CryptoPolyfillClass;
+    protected _httpPolyfill!: A_HttpPolyfillClass;
+    protected _httpsPolyfill!: A_HttpsPolyfillClass;
+    protected _pathPolyfill!: A_PathPolyfillClass;
+    protected _urlPolyfill!: A_UrlPolyfillClass;
+    protected _bufferPolyfill!: A_BufferPolyfillClass;
+    protected _processPolyfill!: A_ProcessPolyfillClass;
 
-export class A_Polyfill extends A_Component {
+    protected _initializing: Promise<void> | null = null;
+    /**
+     * Indicates whether the channel is connected
+     */
+    protected _initialized?: Promise<void>;
 
-    protected _polyfill!: A_PolyfillClass;
 
+    constructor(
+        @A_Inject(A_Logger) protected logger: A_Logger
+    ) {
+        super();
+    }
+
+    /**
+     * Indicates whether the channel is connected
+     */
+    get ready(): Promise<void> {
+        if (!this._initialized) {
+            this._initialized = this._loadInternal();
+        }
+        return this._initialized;
+    }
+
+
+
+    @A_Concept.Load()
     async load() {
-        this._polyfill = new A_PolyfillClass();
+        await this.ready;
+    }
+
+    @A_Concept.Load()
+    async attachToWindow() {
+        if (A_Context.environment !== 'browser') return;
+
+
+        (globalThis as any).A_Polyfill = this;
+        // attach env variables
+        (globalThis as any).process = { env: { NODE_ENV: 'production' }, cwd: () => "/" };
+        (globalThis as any).__dirname = "/";
 
-        await this._polyfill.fs();
-        await this._polyfill.crypto();
     }
 
 
+    protected async _loadInternal() {
+
+        this._fsPolyfill = new A_FSPolyfillClass(this.logger);
+        this._cryptoPolyfill = new A_CryptoPolyfillClass(this.logger);
+        this._httpPolyfill = new A_HttpPolyfillClass(this.logger);
+        this._httpsPolyfill = new A_HttpsPolyfillClass(this.logger);
+        this._pathPolyfill = new A_PathPolyfillClass(this.logger);
+        this._urlPolyfill = new A_UrlPolyfillClass(this.logger);
+        this._bufferPolyfill = new A_BufferPolyfillClass(this.logger);
+        this._processPolyfill = new A_ProcessPolyfillClass(this.logger);
+
+        // Initialize all polyfills to ensure they're ready
+        await this._fsPolyfill.get();
+        await this._cryptoPolyfill.get(await this._fsPolyfill.get());
+        await this._httpPolyfill.get();
+        await this._httpsPolyfill.get();
+        await this._pathPolyfill.get();
+        await this._urlPolyfill.get();
+        await this._bufferPolyfill.get();
+        await this._processPolyfill.get();
+    }
+
     /**
      * Allows to use the 'fs' polyfill methods regardless of the environment
      * This method loads the 'fs' polyfill and returns its instance
@@ -22,11 +92,9 @@ export class A_Polyfill extends A_Component {
      * @returns 
      */
     async fs() {
-        if (!this._polyfill) {
-            await this.load();
-        }
+        await this.ready;
 
-        return await this._polyfill.fs();
+        return await this._fsPolyfill.get();
     }
 
     /**
@@ -36,10 +104,80 @@ export class A_Polyfill extends A_Component {
      * @returns 
      */
     async crypto() {
-        if (!this._polyfill) {
-            await this.load();
-        }
+        await this.ready;
+
+        return await this._cryptoPolyfill.get();
+    }
+
+    /**
+     * Allows to use the 'http' polyfill methods regardless of the environment
+     * This method loads the 'http' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async http() {
+        await this.ready;
+
+        return await this._httpPolyfill.get();
+    }
+
+    /**
+     * Allows to use the 'https' polyfill methods regardless of the environment
+     * This method loads the 'https' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async https() {
+        await this.ready;
+
+        return await this._httpsPolyfill.get();
+    }
+
+    /**
+     * Allows to use the 'path' polyfill methods regardless of the environment
+     * This method loads the 'path' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async path() {
+        await this.ready;
+
+        return await this._pathPolyfill.get();
+    }
+
+    /**
+     * Allows to use the 'url' polyfill methods regardless of the environment
+     * This method loads the 'url' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async url() {
+        await this.ready;
+
+        return await this._urlPolyfill.get();
+    }
+
+    /**
+     * Allows to use the 'buffer' polyfill methods regardless of the environment
+     * This method loads the 'buffer' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async buffer() {
+        await this.ready;
+
+        return await this._bufferPolyfill.get();
+    }
+
+    /**
+     * Allows to use the 'process' polyfill methods regardless of the environment
+     * This method loads the 'process' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async process() {
+        await this.ready;
 
-        return await this._polyfill.crypto();
+        return await this._processPolyfill.get();
     }
 }

package/src/lib/A-Polyfill/A-Polyfill.types.ts

@@ -7,4 +7,58 @@ export interface Ifspolyfill {
 export interface IcryptoInterface {
     createTextHash(text: string, algorithm: string): Promise<string>
     createFileHash(filePath: string, algorithm: string): Promise<string>
+}
+
+export interface IhttpInterface {
+    request: (options: any, callback?: (res: any) => void) => any;
+    get: (url: string | any, callback?: (res: any) => void) => any;
+    createServer: (requestListener?: (req: any, res: any) => void) => any;
+}
+
+export interface IhttpsInterface {
+    request: (options: any, callback?: (res: any) => void) => any;
+    get: (url: string | any, callback?: (res: any) => void) => any;
+    createServer: (options: any, requestListener?: (req: any, res: any) => void) => any;
+}
+
+export interface IpathInterface {
+    join: (...paths: string[]) => string;
+    resolve: (...paths: string[]) => string;
+    dirname: (path: string) => string;
+    basename: (path: string, ext?: string) => string;
+    extname: (path: string) => string;
+    relative: (from: string, to: string) => string;
+    normalize: (path: string) => string;
+    isAbsolute: (path: string) => boolean;
+    parse: (path: string) => any;
+    format: (pathObject: any) => string;
+    sep: string;
+    delimiter: string;
+}
+
+export interface IurlInterface {
+    parse: (urlString: string) => any;
+    format: (urlObject: any) => string;
+    resolve: (from: string, to: string) => string;
+    URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
+}
+
+export interface IbufferInterface {
+    from: (data: any, encoding?: string) => any;
+    alloc: (size: number, fill?: any) => any;
+    allocUnsafe: (size: number) => any;
+    isBuffer: (obj: any) => boolean;
+    concat: (list: any[], totalLength?: number) => any;
+}
+
+export interface IprocessInterface {
+    env: Record<string, string | undefined>;
+    argv: string[];
+    platform: string;
+    version: string;
+    versions: Record<string, string>;
+    cwd: () => string;
+    exit: (code?: number) => never;
+    nextTick: (callback: Function, ...args: any[]) => void;
 }

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

@@ -0,0 +1,85 @@
+import { A_Context } from "@adaas/a-concept";
+import { IbufferInterface } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+export class A_BufferPolyfillClass {
+    private _buffer!: IbufferInterface;
+    private _initialized: boolean = false;
+
+    constructor(
+        protected logger: A_Logger
+    ) {
+
+    }
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+
+    async get(): Promise<IbufferInterface> {
+        if (!this._initialized) {
+            await this.init();
+        }
+        return this._buffer;
+    }
+
+    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 bufferModule = await import('buffer');
+        this._buffer = {
+            from: bufferModule.Buffer.from,
+            alloc: bufferModule.Buffer.alloc,
+            allocUnsafe: bufferModule.Buffer.allocUnsafe,
+            isBuffer: bufferModule.Buffer.isBuffer,
+            concat: bufferModule.Buffer.concat
+        };
+    }
+
+    private initBrowser(): 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/classes/A-Crypto-Polyfill.class.ts

@@ -0,0 +1,87 @@
+import { A_Context } from "@adaas/a-concept";
+import { IcryptoInterface, Ifspolyfill } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+export class A_CryptoPolyfillClass {
+    private _crypto!: IcryptoInterface;
+    private _initialized: boolean = false;
+    private _fsPolyfill?: Ifspolyfill;
+
+    constructor(
+        protected logger: A_Logger
+    ) {
+    }
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+    async get(fsPolyfill?: Ifspolyfill): Promise<IcryptoInterface> {
+        if (!this._initialized) {
+            this._fsPolyfill = fsPolyfill;
+            await this.init();
+        }
+        return this._crypto;
+    }
+
+    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 crypto = await import('crypto');
+        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);
+                }
+            })
+        };
+    }
+
+    private initBrowser(): 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/classes/A-FS-Polyfill.class.ts

@@ -0,0 +1,61 @@
+import { A_Context } from "@adaas/a-concept";
+import { Ifspolyfill } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+export class A_FSPolyfillClass {
+    private _fs!: Ifspolyfill;
+    private _initialized: boolean = false;
+
+    constructor(
+        protected logger: A_Logger
+    ) {
+
+    }
+
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+
+    async get(): Promise<Ifspolyfill> {
+        if (!this._initialized) {
+            await this.init();
+        }
+        return this._fs;
+    }
+
+    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._fs = await import('fs') as Ifspolyfill;
+    }
+
+    private initBrowser(): 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

@@ -0,0 +1,100 @@
+import { A_Context } from "@adaas/a-concept";
+import { IhttpInterface } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+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
+        };
+    }
+
+    private initBrowser(): void {
+        this._http = {
+            request: (options: any, callback?: (res: any) => void) => {
+                this.logger.warning('http.request not available in browser/test environment, use fetch instead');
+                return this.createMockRequest(options, callback, false);
+            },
+            get: (url: string | any, callback?: (res: any) => void) => {
+                this.logger.warning('http.get not available in browser/test environment, use fetch instead');
+                return this.createMockRequest(typeof url === 'string' ? { hostname: url } : url, callback, false);
+            },
+            createServer: () => {
+                this.logger.error('http.createServer not available in browser/test environment');
+                return null;
+            }
+        };
+    }
+
+    private createMockRequest(options: any, callback?: (res: any) => void, isHttps: boolean = false) {
+        // Return a mock request that doesn't make real network calls
+        const request = {
+            end: () => {
+                // Mock response for all environments
+                if (callback) {
+                    const mockResponse = {
+                        statusCode: 200,
+                        headers: {},
+                        on: (event: string, handler: Function) => {
+                            if (event === 'data') {
+                                setTimeout(() => handler('mock data'), 0);
+                            } else if (event === 'end') {
+                                setTimeout(() => handler(), 0);
+                            }
+                        },
+                        pipe: (dest: any) => {
+                            if (dest.write) dest.write('mock data');
+                            if (dest.end) dest.end();
+                        }
+                    };
+                    setTimeout(() => callback(mockResponse), 0);
+                }
+            },
+            write: (data: any) => {
+                // Mock write
+            },
+            on: (event: string, handler: Function) => {
+                // Mock event handling
+            }
+        };
+
+        return request;
+    }
+}

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

@@ -0,0 +1,100 @@
+import { A_Context } from "@adaas/a-concept";
+import { IhttpsInterface } from "../A-Polyfill.types";
+import { A_Logger } from "../../A-Logger/A-Logger.component";
+
+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
+        };
+    }
+
+    private initBrowser(): void {
+        this._https = {
+            request: (options: any, callback?: (res: any) => void) => {
+                this.logger.warning('https.request not available in browser/test environment, use fetch instead');
+                return this.createMockRequest(options, callback, true);
+            },
+            get: (url: string | any, callback?: (res: any) => void) => {
+                this.logger.warning('https.get not available in browser/test environment, use fetch instead');
+                return this.createMockRequest(typeof url === 'string' ? { hostname: url } : url, callback, true);
+            },
+            createServer: () => {
+                this.logger.error('https.createServer not available in browser/test environment');
+                return null;
+            }
+        };
+    }
+
+    private createMockRequest(options: any, callback?: (res: any) => void, isHttps: boolean = true) {
+        // Return a mock request that doesn't make real network calls
+        const request = {
+            end: () => {
+                // Mock response for all environments
+                if (callback) {
+                    const mockResponse = {
+                        statusCode: 200,
+                        headers: {},
+                        on: (event: string, handler: Function) => {
+                            if (event === 'data') {
+                                setTimeout(() => handler('mock data'), 0);
+                            } else if (event === 'end') {
+                                setTimeout(() => handler(), 0);
+                            }
+                        },
+                        pipe: (dest: any) => {
+                            if (dest.write) dest.write('mock data');
+                            if (dest.end) dest.end();
+                        }
+                    };
+                    setTimeout(() => callback(mockResponse), 0);
+                }
+            },
+            write: (data: any) => {
+                // Mock write
+            },
+            on: (event: string, handler: Function) => {
+                // Mock event handling
+            }
+        };
+
+        return request;
+    }
+}