@adaas/a-utils 0.2.8 → 0.3.1

package/src/lib/A-Config/components/ConfigReader.component.ts

@@ -1,9 +1,13 @@
-import { A_Component, A_Concept, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_Container, A_Context, A_Dependency, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
+import {
+    A_Component, A_CONCEPT_ENV,
+    A_Concept, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY,
+    A_Container, A_Dependency,
+    A_Inject, A_Scope
+} from "@adaas/a-concept";
+import { A_Frame } from "@adaas/a-frame";
 import { A_Config } from "../A-Config.context";
+import { A_Polyfill } from "@adaas/a-utils/a-polyfill";
 import { A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY } from "../A-Config.constants";
-import { A_Polyfill } from "../../A-Polyfill/A-Polyfill.component";
-import { A_Memory } from "../../A-Memory/A-Memory.component";
-import { A_Frame } from "@adaas/a-frame";
 
 /**
  * Config Reader
@@ -40,10 +44,8 @@ export class ConfigReader extends A_Component {
 
             container.scope.register(config);
         }
-
-        const rootDir = await this.getProjectRoot();
-
-        config.set('A_CONCEPT_ROOT_FOLDER', rootDir);
+        
+        config.set('A_CONCEPT_ROOT_FOLDER', A_CONCEPT_ENV.A_CONCEPT_ROOT_FOLDER);
     }
 
     @A_Concept.Load()
@@ -76,17 +78,4 @@ export class ConfigReader extends A_Component {
     ): Promise<Record<T, any>> {
         return {} as Record<T, any>;
     }
-
-
-    /**
-     * Finds the root directory of the project by locating the folder containing package.json
-     * 
-     * @param {string} startPath - The initial directory to start searching from (default is __dirname)
-     * @returns {string|null} - The path to the root directory or null if package.json is not found
-     */
-    protected async getProjectRoot(startPath = __dirname) {
-        const process = await this.polyfill.process();
-
-        return process.cwd();
-    }
 }

package/src/lib/A-Config/components/ENVConfigReader.component.ts

@@ -1,10 +1,12 @@
-import { A_Concept, A_Feature, A_FormatterHelper, A_Inject, A_TYPES__ConceptENVVariables } from "@adaas/a-concept";
+import {
+    A_Concept, A_CONCEPT_ENV,
+    A_Feature,
+    A_FormatterHelper, A_Inject, A_TYPES__ConceptENVVariables
+} from "@adaas/a-concept";
 import { ConfigReader } from "./ConfigReader.component";
 import { A_Config } from "../A-Config.context";
-import { A_Polyfill } from "../../A-Polyfill/A-Polyfill.component";
 import { A_Frame } from "@adaas/a-frame";
-
-
+import { A_Polyfill } from "@adaas/a-utils/a-polyfill";
 
 @A_Frame.Component({
     namespace: 'A-Utils',
@@ -21,7 +23,6 @@ export class ENVConfigReader extends ConfigReader {
         @A_Inject(A_Config) config: A_Config<A_TYPES__ConceptENVVariables>,
         @A_Inject(A_Polyfill) polyfill: A_Polyfill,
         @A_Inject(A_Feature) feature: A_Feature,
-
     ) {
         const fs = await polyfill.fs();
 
@@ -29,7 +30,7 @@ export class ENVConfigReader extends ConfigReader {
             fs.readFileSync(`${config.get('A_CONCEPT_ROOT_FOLDER')}/.env`, 'utf-8').split('\n').forEach(line => {
                 const [key, value] = line.split('=');
                 if (key && value) {
-                    process.env[key.trim()] = value.trim();
+                    A_CONCEPT_ENV.set(key.trim(), value.trim());
                 }
             });
     }
@@ -45,22 +46,22 @@ export class ENVConfigReader extends ConfigReader {
 
 
     resolve<_ReturnType = any>(property: string): _ReturnType {
-        return process.env[this.getConfigurationProperty_ENV_Alias(property)] as _ReturnType;
+        return A_CONCEPT_ENV.get(this.getConfigurationProperty_ENV_Alias(property)) as _ReturnType;
     }
 
 
     async read<T extends string>(variables: Array<T> = []): Promise<Record<T, any>> {
         const allVariables = [
             ...variables,
-            ...Object.keys(process.env),
-        ]
+            ...A_CONCEPT_ENV.getAllKeys()
+        ] as const;
 
-        const config: Record<T, any> = {} as Record<T, any>;
+        const config: Record<string, any> = {};
 
-        allVariables.forEach(variable => {
+        allVariables.forEach((variable) => {
             config[variable] = this.resolve(variable);
         });
 
-        return config;
+        return config as Record<T, any>;
     }
 } 

package/src/lib/A-Config/index.ts

@@ -0,0 +1,9 @@
+// A-Config Component Entry Point
+export { A_ConfigLoader } from './A-Config.container';
+export { A_Config } from './A-Config.context';
+export { A_ConfigError } from './A-Config.error';
+export { ConfigReader } from './components/ConfigReader.component';
+export { ENVConfigReader } from './components/ENVConfigReader.component';
+export { FileConfigReader } from './components/FileConfigReader.component';
+export * from './A-Config.types';
+export * from './A-Config.constants';

package/src/lib/A-Execution/index.ts

@@ -0,0 +1,3 @@
+// A-Execution Component Entry Point
+export { A_ExecutionContext } from './A-Execution.context';
+// export * from '../lib/A-Execution/A-Execution.types';

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

@@ -1,5 +1,6 @@
 import { A_Component, A_Context, A_Error, A_Inject, A_Scope } from "@adaas/a-concept";
-import { A_Config } from "../A-Config/A-Config.context";
+
+import { A_Config } from "@adaas/a-utils/a-config";
 import { A_LoggerEnvVariablesType } from "./A-Logger.env";
 import { A_LoggerLevel, A_LoggerColorName } from "./A-Logger.types";
 import {
@@ -14,6 +15,7 @@ import {
 } from "./A-Logger.constants";
 import { A_Frame } from "@adaas/a-frame";
 
+
 /**
  * A_Logger - Advanced Logging Component with Scope-based Output Formatting
  * 

package/src/lib/A-Logger/index.ts

@@ -0,0 +1,5 @@
+// A-Logger Component Entry Point
+export * from './A-Logger.component';
+export * from './A-Logger.types';
+export * from './A-Logger.constants';
+export * from './A-Logger.env';

package/src/lib/A-Manifest/index.ts

@@ -0,0 +1,5 @@
+// A-Manifest Component Entry Point
+export { A_Manifest } from './A-Manifest.context';
+export { A_ManifestError } from './A-Manifest.error';
+export { A_ManifestChecker } from './classes/A-ManifestChecker.class';
+export * from './A-Manifest.types';

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

@@ -2,7 +2,7 @@ import { A_Component, A_Inject, A_Scope, A_Feature, A_Dependency, A_Context } fr
 import { A_MemoryFeatures } from "./A-Memory.constants";
 import { A_MemoryContext } from "./A-Memory.context";
 import { A_MemoryError } from "./A-Memory.error";
-import { A_OperationContext } from "../A-Operation/A-Operation.context";
+import { A_OperationContext } from "@adaas/a-utils/a-operation";
 import { A_MemoryOperationContext } from "./A-Memory.types";
 import { A_Frame } from "@adaas/a-frame";
 

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

@@ -1,5 +1,5 @@
 import { A_Error } from "@adaas/a-concept"
-import { A_OperationContext } from "../A-Operation/A-Operation.context";
+import { A_OperationContext } from "@adaas/a-utils/a-operation";
 
 
 export type A_MemoryContextMeta<T extends Record<string, any> = Record<string, any>> = Omit<T, 'error'> & {

package/src/lib/A-Memory/index.ts

@@ -0,0 +1,6 @@
+// A-Memory Component Entry Point
+export { A_Memory } from './A-Memory.component';
+export { A_MemoryContext } from './A-Memory.context';
+export { A_MemoryError } from './A-Memory.error';
+export * from './A-Memory.constants';
+export * from './A-Memory.types';

package/src/lib/A-Operation/A-Operation.context.ts

@@ -1,6 +1,6 @@
 import { A_Error, A_Fragment } from "@adaas/a-concept";
 import { A_Operation_Serialized, A_Operation_Storage } from "./A-Operation.types";
-import { A_ExecutionContext } from "../A-Execution/A-Execution.context";
+import { A_ExecutionContext } from "@adaas/a-utils/a-execution";
 import { A_Frame } from "@adaas/a-frame";
 
 

package/src/lib/A-Operation/index.ts

@@ -0,0 +1,3 @@
+// A-Operation Component Entry Point
+export { A_OperationContext } from './A-Operation.context';
+export * from './A-Operation.types';

package/src/lib/A-Polyfill/{A-Polyfill.component.ts → A-Polyfill.component.env-browser.ts}

@@ -1,13 +1,13 @@
 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";
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_FSPolyfill } from "./browser/A-FS-Polyfill";
+import { A_CryptoPolyfill } from "./browser/A-Crypto-Polyfill";
+import { A_HttpPolyfill } from "./browser/A-Http-Polyfill";
+import { A_HttpsPolyfill } from "./browser/A-Https-Polyfill";
+import { A_PathPolyfill } from "./browser/A-Path-Polyfill";
+import { A_UrlPolyfill } from "./browser/A-Url-Polyfill";
+import { A_BufferPolyfill } from "./browser/A-Buffer-Polyfill";
+import { A_ProcessPolyfill } from "./browser/A-Process-Polyfill";
 import { A_Frame } from "@adaas/a-frame";
 
 
@@ -20,14 +20,14 @@ import { A_Frame } from "@adaas/a-frame";
 })
 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;
+    protected _fsPolyfill!: A_FSPolyfill;
+    protected _cryptoPolyfill!: A_CryptoPolyfill;
+    protected _httpPolyfill!: A_HttpPolyfill;
+    protected _httpsPolyfill!: A_HttpsPolyfill;
+    protected _pathPolyfill!: A_PathPolyfill;
+    protected _urlPolyfill!: A_UrlPolyfill;
+    protected _bufferPolyfill!: A_BufferPolyfill;
+    protected _processPolyfill!: A_ProcessPolyfill;
 
     protected _initializing: Promise<void> | null = null;
     /**
@@ -37,7 +37,7 @@ export class A_Polyfill extends A_Component {
 
 
     constructor(
-        @A_Inject(A_Logger) protected logger: A_Logger
+        @A_Inject('A_Logger') protected logger: A_Logger
     ) {
         super();
     }
@@ -68,20 +68,19 @@ export class A_Polyfill extends A_Component {
         // attach env variables
         (globalThis as any).process = { env: { NODE_ENV: 'production' }, cwd: () => "/" };
         (globalThis as any).__dirname = "/";
-
     }
 
 
     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);
+        this._fsPolyfill = new A_FSPolyfill(this.logger);
+        this._cryptoPolyfill = new A_CryptoPolyfill(this.logger);
+        this._httpPolyfill = new A_HttpPolyfill(this.logger);
+        this._httpsPolyfill = new A_HttpsPolyfill(this.logger);
+        this._pathPolyfill = new A_PathPolyfill(this.logger);
+        this._urlPolyfill = new A_UrlPolyfill(this.logger);
+        this._bufferPolyfill = new A_BufferPolyfill(this.logger);
+        this._processPolyfill = new A_ProcessPolyfill(this.logger);
 
         // Initialize all polyfills to ensure they're ready
         await this._fsPolyfill.get();

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

@@ -0,0 +1,184 @@
+import { A_Component, A_Concept, A_Context, A_Inject } from "@adaas/a-concept";
+import type { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_CryptoPolyfill } from "./node/A-Crypto-Polyfill";
+import { A_HttpPolyfill } from "./node/A-Http-Polyfill";
+import { A_HttpsPolyfill } from "./node/A-Https-Polyfill";
+import { A_PathPolyfill } from "./node/A-Path-Polyfill";
+import { A_UrlPolyfill } from "./node/A-Url-Polyfill";
+import { A_BufferPolyfill } from "./node/A-Buffer-Polyfill";
+import { A_ProcessPolyfill } from "./node/A-Process-Polyfill";
+import { A_FSPolyfill } from "./node/A-FS-Polyfill";
+import { A_Frame } from "@adaas/a-frame";
+
+
+
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'A-Polyfill',
+    description: 'Polyfill component that provides cross-environment compatibility for Node.js core modules such as fs, crypto, http, https, path, url, buffer, and process. It dynamically loads appropriate polyfills based on the execution environment (Node.js or browser), enabling seamless usage of these modules in different contexts.'
+})
+export class A_Polyfill extends A_Component {
+
+    protected _fsPolyfill!: A_FSPolyfill;
+    protected _cryptoPolyfill!: A_CryptoPolyfill;
+    protected _httpPolyfill!: A_HttpPolyfill;
+    protected _httpsPolyfill!: A_HttpsPolyfill;
+    protected _pathPolyfill!: A_PathPolyfill;
+    protected _urlPolyfill!: A_UrlPolyfill;
+    protected _bufferPolyfill!: A_BufferPolyfill;
+    protected _processPolyfill!: A_ProcessPolyfill;
+
+    protected _initializing: Promise<void> | null = null;
+    /**
+     * Indicates whether the channel is connected
+     */
+    protected _initialized?: Promise<void>;
+
+
+    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() {
+        await this.ready;
+    }
+
+    @A_Concept.Load()
+    async attachToWindow() {
+        if (A_Context.environment !== 'browser') return;
+    }
+
+
+    protected async _loadInternal() {
+
+        this._fsPolyfill = new A_FSPolyfill(this.logger);
+        this._cryptoPolyfill = new A_CryptoPolyfill(this.logger);
+        this._httpPolyfill = new A_HttpPolyfill(this.logger);
+        this._httpsPolyfill = new A_HttpsPolyfill(this.logger);
+        this._pathPolyfill = new A_PathPolyfill(this.logger);
+        this._urlPolyfill = new A_UrlPolyfill(this.logger);
+        this._bufferPolyfill = new A_BufferPolyfill(this.logger);
+        this._processPolyfill = new A_ProcessPolyfill(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
+     * 
+     * @returns 
+     */
+    async fs() {
+        await this.ready;
+
+        return await this._fsPolyfill.get();
+    }
+
+    /**
+     * Allows to use the 'crypto' polyfill methods regardless of the environment
+     * This method loads the 'crypto' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async crypto() {
+        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._processPolyfill.get();
+    }
+}

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

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

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

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

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

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

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

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

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

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