@adaas/a-utils 0.1.10 → 0.1.12

package/tests/A-Polyfill.test.ts

@@ -1,67 +1,484 @@
 import './jest.setup';
-import { A_Scope } from '@adaas/a-concept';
+import { A_Context, A_Scope } from '@adaas/a-concept';
+import { A_Logger } from '@adaas/a-utils/lib/A-Logger/A-Logger.component';
 import { A_Polyfill } from '@adaas/a-utils/lib/A-Polyfill/A-Polyfill.component';
 import { config } from 'dotenv';
 config();
 jest.retryTimes(0);
 
 describe('A-Polyfill Tests', () => {
-    it('It Should allow to create A-polyfill component', async () => {
-        const testScope = new A_Scope({
-            components: [A_Polyfill]
+    let testScope: A_Scope;
+    let polyfill: A_Polyfill;
+
+    beforeEach(async () => {
+        testScope = new A_Scope({
+            components: [A_Polyfill, A_Logger],
         });
+        polyfill = testScope.resolve(A_Polyfill);
+        await polyfill.load();
+    });
 
-        const polyfill = testScope.resolve(A_Polyfill);
+    describe('Basic Component Tests', () => {
+        it('Should create A-polyfill component', async () => {
+            expect(polyfill).toBeInstanceOf(A_Polyfill);
+        });
 
-        await polyfill.load();
+        it('Should detect environment correctly', () => {
+            const env = A_Context.environment;
+            expect(env).toMatch(/^(server|browser)$/);
+            expect(env).toBe('server');
+        });
+    });
 
-        expect(polyfill).toBeInstanceOf(A_Polyfill);
+    describe('FS Polyfill Tests', () => {
+        it('Should return fs polyfill', async () => {
+            const fs = await polyfill.fs();
+            expect(fs).toBeDefined();
+            expect(fs.readFileSync).toBeDefined();
+            expect(fs.existsSync).toBeDefined();
+            expect(fs.createReadStream).toBeDefined();
+        });
+
+        it('Should check if file exists', async () => {
+            const fs = await polyfill.fs();
+            const exists = fs.existsSync('./package.json');
+            expect(typeof exists).toBe('boolean');
+            expect(exists).toBe(true); // package.json should exist
+        });
 
+        it('Should read file content', async () => {
+            const fs = await polyfill.fs();
+            const content = fs.readFileSync('./package.json', 'utf8');
+            expect(typeof content).toBe('string');
+            expect(content.length).toBeGreaterThan(0);
+        });
     });
 
-    it('It Should return fs', async () => {
+    describe('Crypto Polyfill Tests', () => {
+        it('Should return crypto polyfill', async () => {
+            const crypto = await polyfill.crypto();
+            expect(crypto).toBeDefined();
+            expect(crypto.createTextHash).toBeDefined();
+            expect(crypto.createFileHash).toBeDefined();
+        });
 
-        const testScope = new A_Scope({
-            components: [A_Polyfill]
+        it('Should create text hash', async () => {
+            const crypto = await polyfill.crypto();
+            const hash = await crypto.createTextHash('test content', 'sha256');
+            expect(hash).toBeDefined();
+            expect(typeof hash).toBe('string');
+            expect(hash).toContain('sha256-');
         });
 
-        const polyfill = testScope.resolve(A_Polyfill);
-        await polyfill.load();
+        it('Should create file hash', async () => {
+            const crypto = await polyfill.crypto();
+            const hash = await crypto.createFileHash('./package.json', 'sha256');
+            expect(hash).toBeDefined();
+            expect(typeof hash).toBe('string');
+            expect(hash).toContain('sha256-');
+        });
+
+        it('Should create consistent hashes for same content', async () => {
+            const crypto = await polyfill.crypto();
+            const hash1 = await crypto.createTextHash('test', 'sha256');
+            const hash2 = await crypto.createTextHash('test', 'sha256');
+            expect(hash1).toBe(hash2);
+        });
+    });
+
+    describe('HTTP Polyfill Tests', () => {
+        it('Should return http polyfill', async () => {
+            const http = await polyfill.http();
+            expect(http).toBeDefined();
+            expect(http.request).toBeDefined();
+            expect(http.get).toBeDefined();
+            expect(http.createServer).toBeDefined();
+        });
+
+        it('Should create http request object', async () => {
+            const http = await polyfill.http();
+
+            let req;
+
+            const response = await new Promise((resolve, reject) => {
+                req = http.request(
+                    {
+                        hostname: "jsonplaceholder.typicode.com",
+                        path: "/posts/1",
+                        method: "GET",
+                        port: 80,
+                    },
+                    (res) => {
+                        let data = "";
+
+                        // Collect response chunks
+                        res.on("data", (chunk) => {
+                            data += chunk;
+                        });
+
+                        // When finished, resolve promise
+                        res.on("end", () => {
+                            try {
+                                resolve(data);
+                            } catch (err) {
+                                reject(err);
+                            }
+                        });
+                    }
+                );
+
+                req.on('error', (err) => {
+                    reject(err);
+                });
 
-        const fs = await polyfill.fs();
+                // Important: send the request
+                req.end();
+            });
 
-        expect(fs).toBeDefined();
+            // Parse and validate response
+            const json = JSON.parse(response as string);
+
+            expect(json).toBeDefined();
+            expect(json).toHaveProperty("id", 1);
+            expect(typeof json.title).toBe("string");
+
+            expect(req).toBeDefined();
+            expect(req.end).toBeDefined();
+            expect(req.write).toBeDefined();
+            expect(req.on).toBeDefined();
+            // Don't actually make the request in tests
+        });
     });
-    it('It Should return crypto', async () => {
 
-        const testScope = new A_Scope({
-            components: [A_Polyfill]
+    describe('HTTPS Polyfill Tests', () => {
+        it('Should return https polyfill', async () => {
+            const https = await polyfill.https();
+            expect(https).toBeDefined();
+            expect(https.request).toBeDefined();
+            expect(https.get).toBeDefined();
+            expect(https.createServer).toBeDefined();
         });
 
-        const polyfill = testScope.resolve(A_Polyfill);
-        await polyfill.load();
+        it('Should create https request object', async () => {
+            const https = await polyfill.https();
+            let req;
+
+            const response = await new Promise((resolve, reject) => {
+                req = https.request(
+                    {
+                        hostname: "jsonplaceholder.typicode.com",
+                        path: "/posts/1",
+                        method: "GET",
+                    },
+                    (res) => {
+                        let data = "";
+
+                        // Collect response chunks
+                        res.on("data", (chunk) => {
+                            data += chunk;
+                        });
+
+                        // When finished, resolve promise
+                        res.on("end", () => {
+                            try {
+                                resolve(data);
+                            } catch (err) {
+                                reject(err);
+                            }
+                        });
+                    }
+                );
 
-        const crypto = await polyfill.crypto();
+                req.on('error', (err) => {
+                    reject(err);
+                });
 
-        expect(crypto).toBeDefined();
+                // Important: send the request
+                req.end();
+            });
+
+            // Parse and validate response
+            const json = JSON.parse(response as string);
+
+            expect(json).toBeDefined();
+            expect(json).toHaveProperty("id", 1);
+            expect(typeof json.title).toBe("string");
+
+            expect(req).toBeDefined();
+            expect(req.end).toBeDefined();
+            expect(req.write).toBeDefined();
+            expect(req.on).toBeDefined();
+        });
     });
 
-    it('Crypto should calculate Hash', async () => {
+    describe('Path Polyfill Tests', () => {
+        it('Should return path polyfill', async () => {
+            const path = await polyfill.path();
+            expect(path).toBeDefined();
+            expect(path.join).toBeDefined();
+            expect(path.resolve).toBeDefined();
+            expect(path.dirname).toBeDefined();
+            expect(path.basename).toBeDefined();
+            expect(path.extname).toBeDefined();
+        });
 
-        const testScope = new A_Scope({
-            components: [A_Polyfill]
+        it('Should join paths correctly', async () => {
+            const path = await polyfill.path();
+            const joined = path.join('/', 'home', 'user', 'file.txt');
+            expect(joined).toBe('/home/user/file.txt');
         });
 
-        const polyfill = testScope.resolve(A_Polyfill);
-        await polyfill.load();
+        it('Should get dirname correctly', async () => {
+            const path = await polyfill.path();
+            const dir = path.dirname('/home/user/file.txt');
+            expect(dir).toBe('/home/user');
+        });
 
-        const crypto = await polyfill.crypto();
+        it('Should get basename correctly', async () => {
+            const path = await polyfill.path();
+            const base = path.basename('/home/user/file.txt');
+            expect(base).toBe('file.txt');
+        });
 
-        const hash = await crypto.createFileHash('./index.ts', 'sha-256');
+        it('Should get extension correctly', async () => {
+            const path = await polyfill.path();
+            const ext = path.extname('/home/user/file.txt');
+            expect(ext).toBe('.txt');
+        });
 
-        expect(hash).toBeDefined();
+        it('Should check if path is absolute', async () => {
+            const path = await polyfill.path();
+            expect(path.isAbsolute('/home/user')).toBe(true);
+            expect(path.isAbsolute('relative/path')).toBe(false);
+        });
 
+        it('Should parse path correctly', async () => {
+            const path = await polyfill.path();
+            const parsed = path.parse('/home/user/file.txt');
+            expect(parsed.dir).toBe('/home/user');
+            expect(parsed.base).toBe('file.txt');
+            expect(parsed.ext).toBe('.txt');
+            expect(parsed.name).toBe('file');
+        });
     });
 
+    describe('URL Polyfill Tests', () => {
+        it('Should return url polyfill', async () => {
+            const url = await polyfill.url();
+            expect(url).toBeDefined();
+            expect(url.parse).toBeDefined();
+            expect(url.format).toBeDefined();
+            expect(url.resolve).toBeDefined();
+            expect(url.URL).toBeDefined();
+            expect(url.URLSearchParams).toBeDefined();
+        });
+
+        it('Should parse URL correctly', async () => {
+            const url = await polyfill.url();
+            const parsed = url.parse('https://example.com:8080/path?query=value#fragment');
+            expect(parsed.protocol).toBe('https:');
+            expect(parsed.hostname).toBe('example.com');
+            expect(parsed.port).toBe('8080');
+            expect(parsed.pathname).toBe('/path');
+        });
+
+        it('Should resolve URLs correctly', async () => {
+            const url = await polyfill.url();
+            const resolved = url.resolve('https://example.com/path/', 'file.html');
+            expect(resolved).toBe('https://example.com/path/file.html');
+        });
 
+        it('Should work with URL constructor', async () => {
+            const url = await polyfill.url();
+            const urlObj = new url.URL('https://example.com/path');
+            expect(urlObj.hostname).toBe('example.com');
+            expect(urlObj.pathname).toBe('/path');
+        });
+    });
+
+    describe('Buffer Polyfill Tests', () => {
+        it('Should return buffer polyfill', async () => {
+            const buffer = await polyfill.buffer();
+            expect(buffer).toBeDefined();
+            expect(buffer.from).toBeDefined();
+            expect(buffer.alloc).toBeDefined();
+            expect(buffer.concat).toBeDefined();
+            expect(buffer.isBuffer).toBeDefined();
+        });
+
+        it('Should create buffer from string', async () => {
+            const buffer = await polyfill.buffer();
+            const buf = buffer.from('hello world', 'utf8');
+            expect(buf).toBeDefined();
+            expect(buf.length).toBeGreaterThan(0);
+        });
+
+        it('Should allocate buffer', async () => {
+            const buffer = await polyfill.buffer();
+            const buf = buffer.alloc(10);
+            expect(buf).toBeDefined();
+            expect(buf.length).toBe(10);
+        });
+
+        it('Should concatenate buffers', async () => {
+            const buffer = await polyfill.buffer();
+            const buf1 = buffer.from('hello ');
+            const buf2 = buffer.from('world');
+            const combined = buffer.concat([buf1, buf2]);
+            expect(combined).toBeDefined();
+            expect(combined.length).toBe(buf1.length + buf2.length);
+        });
+
+        it('Should identify buffers', async () => {
+            const buffer = await polyfill.buffer();
+            const buf = buffer.from('test');
+            expect(buffer.isBuffer(buf)).toBe(true);
+            expect(buffer.isBuffer('not a buffer')).toBe(false);
+        });
+    });
+
+    describe('Process Polyfill Tests', () => {
+        it('Should return process polyfill', async () => {
+            const process = await polyfill.process();
+            expect(process).toBeDefined();
+            expect(process.env).toBeDefined();
+            expect(process.argv).toBeDefined();
+            expect(process.platform).toBeDefined();
+            expect(process.version).toBeDefined();
+            expect(process.cwd).toBeDefined();
+        });
+
+        it('Should have environment variables', async () => {
+            const process = await polyfill.process();
+            expect(typeof process.env).toBe('object');
+            expect(process.env).not.toBeNull();
+        });
+
+        it('Should have argv array', async () => {
+            const process = await polyfill.process();
+            expect(Array.isArray(process.argv)).toBe(true);
+        });
+
+        it('Should have platform string', async () => {
+            const process = await polyfill.process();
+            expect(typeof process.platform).toBe('string');
+        });
+
+        it('Should have working cwd function', async () => {
+            const process = await polyfill.process();
+            const cwd = process.cwd();
+            expect(typeof cwd).toBe('string');
+            expect(cwd.length).toBeGreaterThan(0);
+        });
+
+        it('Should have nextTick function', async () => {
+            const process = await polyfill.process();
+            expect(typeof process.nextTick).toBe('function');
+
+            return new Promise<void>((resolve) => {
+                let called = false;
+                process.nextTick(() => {
+                    called = true;
+                    expect(called).toBe(true);
+                    resolve();
+                });
+            });
+        });
+    });
+
+    describe('Integration Tests', () => {
+        it('Should work with all polyfills simultaneously', async () => {
+            const [fs, crypto, http, https, path, url, buffer, process] = await Promise.all([
+                polyfill.fs(),
+                polyfill.crypto(),
+                polyfill.http(),
+                polyfill.https(),
+                polyfill.path(),
+                polyfill.url(),
+                polyfill.buffer(),
+                polyfill.process()
+            ]);
+
+            expect(fs).toBeDefined();
+            expect(crypto).toBeDefined();
+            expect(http).toBeDefined();
+            expect(https).toBeDefined();
+            expect(path).toBeDefined();
+            expect(url).toBeDefined();
+            expect(buffer).toBeDefined();
+            expect(process).toBeDefined();
+        });
+
+        it('Should handle file operations with path utilities', async () => {
+            const fs = await polyfill.fs();
+            const path = await polyfill.path();
+
+            const filePath = path.join('.', 'package.json');
+            const exists = fs.existsSync(filePath);
+            expect(exists).toBe(true);
+
+            if (exists) {
+                const content = fs.readFileSync(filePath, 'utf8');
+                expect(content.length).toBeGreaterThan(0);
+                expect(content).toContain('"name"');
+            }
+        });
+
+        it('Should create hash of existing file using multiple polyfills', async () => {
+            // Create a fresh polyfill instance to avoid interference
+            const freshScope = new A_Scope({
+                components: [A_Polyfill, A_Logger]
+            });
+            const freshPolyfill = freshScope.resolve(A_Polyfill);
+
+            // Only initialize the needed polyfills
+            const crypto = await freshPolyfill.crypto();
+            const path = await freshPolyfill.path();
+            const fs = await freshPolyfill.fs();
+
+            const filePath = path.resolve('./package.json');
+
+
+            const exists = fs.existsSync(filePath);
+
+            if (exists) {
+                const hash = await crypto.createFileHash(filePath, 'sha256');
+                expect(hash).toBeDefined();
+                expect(hash).toContain('sha256-');
+            } else {
+                // If package.json doesn't exist, create a test with text hash instead
+                const hash = await crypto.createTextHash('test content', 'sha256');
+                expect(hash).toBeDefined();
+                expect(hash).toContain('sha256-');
+            }
+        });
+    });
+
+    describe('Error Handling Tests', () => {
+        it('Should handle non-existent file gracefully', async () => {
+            const fs = await polyfill.fs();
+            const exists = fs.existsSync('./non-existent-file.txt');
+            expect(exists).toBe(false);
+        });
+
+        it('Should handle invalid hash algorithms gracefully', async () => {
+            const crypto = await polyfill.crypto();
+
+            try {
+                await crypto.createTextHash('test', 'invalid-algorithm');
+                // If it doesn't throw, it should still return a string
+            } catch (error) {
+                // Error is expected for invalid algorithms
+                expect(error).toBeDefined();
+            }
+        });
+
+        it('Should handle malformed URLs gracefully', async () => {
+            const url = await polyfill.url();
+            const parsed = url.parse('not-a-valid-url');
+
+            // Should return an object even for invalid URLs
+            expect(typeof parsed).toBe('object');
+        });
+    });
 });

package/tsconfig.json

@@ -49,7 +49,7 @@
     "tests/**/*", 
     "examples/**/*", 
     "examples/*", 
-    "index.ts"  
+    "src/index.ts"  
   ],
   "exclude": [
     "node_modules/**/*",

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],     // 👈 adjust if your main file is elsewhere
+  format: ["esm", "cjs"],      // both Node (CJS) and ESM builds
+  dts: true,                   // generate declaration files
+  sourcemap: true,             // helpful for debugging
+  clean: true,                 // clear dist/ before build
+  target: "es2020",            // good for both Node 18+ and browsers
+  treeshake: true,             // ✅ enable tree-shaking
+  skipNodeModulesBundle: true, // do NOT bundle node_modules (leave them external)
+  splitting: false,            // one file per format (simpler)
+  minify: false,               // optional: turn on if you want smaller bundle
+  platform: "neutral",         // 👈 important: works in Node & browser
+});

package/dist/src/constants/errors.constants.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=errors.constants.js.map

package/dist/src/constants/errors.constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.constants.js","sourceRoot":"","sources":["../../../src/constants/errors.constants.ts"],"names":[],"mappings":""}

package/dist/src/lib/A-Channel/A-Channel.component.d.ts

@@ -1,22 +0,0 @@
-import { A_Component } from "@adaas/a-concept";
-export declare class A_Channel extends A_Component {
-    /**
-     * Indicates whether the channel is processing requests
-     */
-    protected _processing: boolean;
-    /**
-     * Indicates whether the channel is connected
-     */
-    protected _initialized?: Promise<void>;
-    /**
-      * Indicates whether the channel is processing requests
-      */
-    get processing(): boolean;
-    /**
-     * Indicates whether the channel is connected
-     */
-    get initialize(): Promise<void>;
-    connect(): Promise<void>;
-    request(params: any): Promise<any>;
-    send(message: any): Promise<void>;
-}

package/dist/src/lib/A-Channel/A-Channel.component.js

@@ -1,84 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.A_Channel = void 0;
-const a_concept_1 = require("@adaas/a-concept");
-const A_Channel_error_1 = require("./A-Channel.error");
-class A_Channel extends a_concept_1.A_Component {
-    constructor() {
-        super(...arguments);
-        /**
-         * Indicates whether the channel is processing requests
-         */
-        this._processing = false;
-    }
-    /**
-      * Indicates whether the channel is processing requests
-      */
-    get processing() {
-        return this._processing;
-    }
-    /**
-     * Indicates whether the channel is connected
-     */
-    get initialize() {
-        if (!this._initialized) {
-            this._initialized = this.connect();
-        }
-        return this._initialized;
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new A_Channel_error_1.A_ChannelError(A_Channel_error_1.A_ChannelError.MethodNotImplemented, `The connect method is not implemented in ${this.constructor.name} channel. This method is required to initialize the channel before use. So please implement it in the derived class.`);
-        });
-    }
-    request(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new A_Channel_error_1.A_ChannelError(A_Channel_error_1.A_ChannelError.MethodNotImplemented, `The request method is not implemented in ${this.constructor.name} channel.`);
-        });
-    }
-    send(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new A_Channel_error_1.A_ChannelError(A_Channel_error_1.A_ChannelError.MethodNotImplemented, `The send method is not implemented in ${this.constructor.name} channel.`);
-        });
-    }
-}
-exports.A_Channel = A_Channel;
-__decorate([
-    a_concept_1.A_Feature.Define()
-    /**
-     * Initializes the channel before use
-     */
-], A_Channel.prototype, "connect", null);
-__decorate([
-    a_concept_1.A_Feature.Define()
-    /**
-     * Allows to send a request through the channel
-     *
-     * @param req - The request parameters
-     * @returns The response from the channel
-     */
-], A_Channel.prototype, "request", null);
-__decorate([
-    a_concept_1.A_Feature.Define()
-    /**
-     * Uses for Fire-and-Forget messaging through the channel
-     *
-     * @param message - can be of any type depending on the channel implementation
-     */
-], A_Channel.prototype, "send", null);
-//# sourceMappingURL=A-Channel.component.js.map

package/dist/src/lib/A-Channel/A-Channel.component.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"A-Channel.component.js","sourceRoot":"","sources":["../../../../src/lib/A-Channel/A-Channel.component.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,gDAA0D;AAC1D,uDAAmD;AAInD,MAAa,SAAU,SAAQ,uBAAW;IAA1C;;QAEI;;WAEG;QACO,gBAAW,GAAY,KAAK,CAAC;IAgE3C,CAAC;IA1DG;;QAEI;IACJ,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IACD;;OAEG;IACH,IAAI,UAAU;QACV,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QACvC,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAOK,OAAO;;YACT,MAAM,IAAI,gCAAc,CACpB,gCAAc,CAAC,oBAAoB,EACnC,4CAA4C,IAAI,CAAC,WAAW,CAAC,IAAI,sHAAsH,CAC1L,CAAC;QACN,CAAC;KAAA;IAUK,OAAO,CAAC,MAAW;;YACrB,MAAM,IAAI,gCAAc,CACpB,gCAAc,CAAC,oBAAoB,EACnC,4CAA4C,IAAI,CAAC,WAAW,CAAC,IAAI,WAAW,CAC/E,CAAC;QACN,CAAC;KAAA;IAUK,IAAI,CAAC,OAAY;;YACnB,MAAM,IAAI,gCAAc,CACpB,gCAAc,CAAC,oBAAoB,EACnC,yCAAyC,IAAI,CAAC,WAAW,CAAC,IAAI,WAAW,CAC5E,CAAC;QACN,CAAC;KAAA;CAEJ;AArED,8BAqEC;AArCS;IAJL,qBAAS,CAAC,MAAM,EAAE;IACnB;;OAEG;wCAMF;AAUK;IAPL,qBAAS,CAAC,MAAM,EAAE;IACnB;;;;;OAKG;wCAMF;AAUK;IANL,qBAAS,CAAC,MAAM,EAAE;IACnB;;;;OAIG;qCAMF"}

package/dist/src/lib/A-Channel/A-Channel.error.d.ts

@@ -1,4 +0,0 @@
-import { A_Error } from "@adaas/a-concept";
-export declare class A_ChannelError extends A_Error {
-    static readonly MethodNotImplemented = "A-Channel Method Not Implemented";
-}

package/dist/src/lib/A-Channel/A-Channel.error.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.A_ChannelError = void 0;
-const a_concept_1 = require("@adaas/a-concept");
-class A_ChannelError extends a_concept_1.A_Error {
-}
-exports.A_ChannelError = A_ChannelError;
-A_ChannelError.MethodNotImplemented = 'A-Channel Method Not Implemented';
-//# sourceMappingURL=A-Channel.error.js.map