@adaas/a-concept 0.0.2

package/src/global/A-Namespace/A_Namespace.types.ts

@@ -0,0 +1,24 @@
+/**
+ * Namespace Constructor Interface
+ */
+export type A_TYPES__NamespaceConstructor = {
+    name?: string,
+}
+
+
+/**
+ * Namespace Interface 
+ */
+export interface A_TYPES__INamespace {
+    name: string;
+    ready: Promise<void>
+}
+
+
+/**
+ * Global Namespace Interface uses for extending the Namespace from other modules or SDKs
+ * 
+ */
+export interface A_TYPES__IGlobalNamespace extends A_TYPES__INamespace {
+
+}

package/src/storage/A_Concept.storage.ts

@@ -0,0 +1,45 @@
+
+
+// --------------------------------------------------------------
+// ----- A Concept -> Module Declaration -> Main Config ---------
+// --------------------------------------------------------------
+export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Config = Symbol('a-concept-modules-declaration');
+
+
+
+// -------------------------------------------------------------------------------
+// ----- A Concept -> Module Declaration -> Concept Lifecycle Extension_ --------- 
+// -------------------------------------------------------------------------------
+export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootRun = Symbol('a-concept-modules-declaration-lifecycle-root-run');
+export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootLoad = Symbol('a-concept-modules-declaration-lifecycle-root-load');
+export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootBuild = Symbol('a-concept-modules-declaration-lifecycle-root-build');
+export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootPublish = Symbol('a-concept-modules-declaration-lifecycle-root-publish');
+export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootTest = Symbol('a-concept-modules-declaration-lifecycle-root-test');
+
+
+
+
+/**
+ * Storage to keep the module declarations across all modules
+ */
+export const A_CONCEPT_ModulesDeclarationStorage: WeakMap<
+    any,
+    Map<string | Symbol, any>
+> = new WeakMap();
+
+
+
+/**
+ * Storage to keep the lifecycle declarations across all modules
+ */
+export const A_CONCEPT_LifecycleDeclarationsStorage: Map<Symbol, any> = new Map();
+
+
+
+
+
+/**
+ * The simplest way to store the decorators
+ * If any extra API is needed, it can be added here or replaced with a new class
+ */
+export const A_CONCEPT_Storage = new WeakMap();

package/src/types/A_Module.types.ts

@@ -0,0 +1,23 @@
+export enum A_TYPES__ModuleState {
+    INIT = 'INIT',
+    LOADING = 'LOADING',
+    READY = 'READY',
+    FAILED = 'FAILED'
+}
+
+export enum A_TYPES__ModuleTypes {
+    /**
+     * Custom module type allows additional external control over the module
+     */
+    CUSTOM = 'CUSTOM',
+
+    /**
+     * Default module type is a module that is used by default and has no additional control.
+     */
+    DEFAULT = 'DEFAULT'
+}
+
+
+export type A_TYPES__ModuleConstructor = {
+  
+}

package/tests/context.test.ts

@@ -0,0 +1,124 @@
+// import { A_CONSTANTS__ERROR_CODES } from '@adaas/a-concept/constants/errors.constants';
+// import { A_ContextClass } from '@adaas/a-concept/global/A-Namespace/A_Namespace.class';
+// import { A_Error } from '@adaas/a-concept/global/A_Error.class';
+// import { config } from 'dotenv';
+// config();
+// jest.retryTimes(0);
+
+// describe('Context Tests', () => {
+
+//     it('Should load default context ', async () => {
+//         const testContext = new A_ContextClass({
+//             namespace: 'test',
+//         });
+
+//         await testContext.ready;
+//     });
+
+
+//     it('Should log data ', async () => {
+//         const testContext = new A_ContextClass({
+//             namespace: 'test',
+//         });
+
+//         await testContext.ready;
+
+//         testContext.Logger.log('Test Log');
+//     });
+
+//     it('Should throw Error ', async () => {
+
+//         const namespace = 'test-namespace';
+//         const testContext = new A_ContextClass({
+//             namespace,
+//         });
+
+//         await testContext.ready;
+
+//         try {
+//             testContext.Errors.throw(A_CONSTANTS__ERROR_CODES.METHOD_NOT_IMPLEMENTED);
+//         } catch (error) {
+//             testContext.Logger.error(error);
+
+//             expect(error).toBeDefined();
+//             expect(error).toBeInstanceOf(A_Error);
+//             expect((error as A_Error).code).toBe(
+//                 `${namespace}@error:${A_CONSTANTS__ERROR_CODES.METHOD_NOT_IMPLEMENTED}`
+//             );
+//         }
+//     });
+
+//     it('Should log original error ', async () => {
+
+//         const namespace = 'test-error-namespace';
+//         const testContext = new A_ContextClass({
+//             namespace,
+//         });
+
+//         await testContext.ready;
+//         try {
+//             try {
+//                 throw new Error('Test Error');
+//             } catch (error) {
+//                 throw testContext.Errors.wrap(error);
+//             }
+//         } catch (error) {
+//             testContext.Logger.error(error);
+
+
+//             expect(error).toBeDefined();
+//             expect(error).toBeInstanceOf(A_Error);
+//         }
+//     });
+
+//     it('Should read allowed configuration property ', async () => {
+
+//         const namespace = 'test-config-read-ok';
+//         const testContext = new A_ContextClass({
+//             namespace,
+//         });
+
+//         const ignoreErrors = testContext.getConfigurationProperty('CONFIG_IGNORE_ERRORS');
+
+//         expect(ignoreErrors).toBe(false);
+//     });
+
+//     it('Should fail to read unknown property', async () => {
+
+//         const namespace = 'test-config-read-fail';
+//         const testContext = new A_ContextClass({
+//             namespace,
+//         });
+
+//         try {
+//             testContext.getConfigurationProperty('TEST_PROPERTY' as any);
+//         } catch (error) {
+//             testContext.Logger.error(error);
+
+//             expect(error).toBeDefined();
+//             expect(error).toBeInstanceOf(A_Error);
+//             expect((error as A_Error).code).toBe(
+//                 `${namespace}@error:${A_CONSTANTS__ERROR_CODES.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ}`
+//             );
+//         }
+
+//     });
+
+//     it('Should Log data properly', async () => {
+
+//         const namespace = 'test-config-read-fail';
+//         const testContext = new A_ContextClass({
+//             namespace,
+//         });
+
+//         testContext.Logger.log(`
+//             Some Suff that should be done`, {
+//             test: 'data',
+//             test2: {
+//                 test: 'data'
+//             }
+//         });
+
+//     });
+
+// });

package/tests/default.test.ts

@@ -0,0 +1,159 @@
+// import { A_CommonHelper } from '@adaas/a-concept/helpers/Common.helper';
+// import { A_TYPES__DeepPartial } from '@adaas/a-concept/types/common.types';
+// import { config } from 'dotenv';
+// config();
+// jest.retryTimes(0);
+
+// describe('CommonHelper Tests', () => {
+
+//     it('Schedule Should execute promise and await it ', async () => {
+
+//         const start = Date.now();
+//         let res = '';
+
+//         try {
+//             const scheduler = A_CommonHelper.schedule(3000, async () => {
+//                 return 'RESOLVED';
+//             });
+
+
+//             res = await scheduler.promise;
+
+//         } catch (error) {
+//             // Handle error if any
+//         } finally {
+//             const end = Date.now();
+//             const duration = end - start;
+
+//             expect(res).toBe('RESOLVED');
+//             // Check if the duration exceeds 3 seconds
+//             expect(duration).toBeGreaterThan(3000);
+//         }
+
+//     });
+
+//     it('Schedule Should be canceled and rejected', async () => {
+
+//         const start = Date.now();
+//         let res = '';
+
+//         try {
+//             const scheduler = A_CommonHelper.schedule(3000, async () => {
+//                 return 'RESOLVED';
+//             });
+
+
+//             scheduler.clear();
+//             res = await scheduler.promise;
+//         } catch (error) {
+//             // Handle error if any
+//         } finally {
+//             const end = Date.now();
+//             const duration = end - start;
+
+//             expect(res).toBe('');
+//             // Check if the duration exceeds 3 seconds
+//             expect(duration).toBeLessThan(3000);
+//         }
+
+//     });
+
+//     it('Deep Clone and  Merge ', async () => {
+
+//         type TestType = {
+//             a: string,
+//             b: string,
+//             c: {
+//                 d: string
+//             },
+//             f: (name: string) => string
+//             s: Date
+//         }
+
+//         const t: TestType = {
+//             a: 'a',
+//             b: 'b',
+//             c: {
+//                 d: 'd'
+//             },
+//             f: (name: string) => { return name },
+//             s: new Date()
+//         }
+
+//         const t2: A_TYPES__DeepPartial<TestType> = {
+//             a: 'aa',
+//             c: {
+//                 d: 'dd'
+//             },
+//             f: (name: string) => { return name + '2' }
+//         }
+
+//         const merged = A_CommonHelper.deepCloneAndMerge(t2, t);
+
+
+//         const name = merged.f('names');
+
+
+//         expect(merged.a).toBe('aa');
+//         expect(merged.b).toBe('b');
+//         expect(merged.c.d).toBe('dd');
+//         expect(name).toBe('names2');
+//         expect(t).not.toEqual(merged);
+//         expect(t2).not.toEqual(merged);
+//     });
+
+//     it('Deep Clone Different Types', async () => {
+
+//         type TestType = {
+//             a: string,
+//             b: string,
+//             c: {
+//                 d: string
+//             },
+//             bool:{
+//                 a: boolean
+//             },
+//             f: (name: string) => string
+//             s: Date
+//         }
+
+//         const t: TestType = {
+//             a: 'a',
+//             b: 'b',
+//             c: {
+//                 d: 'd'
+//             },
+//             bool:{
+//                 a: true
+//             },
+//             f: (name: string) => { return name },
+//             s: new Date()
+//         }
+
+//         const t2: any = {
+//             e: 'foo',
+//             b: 'bb',
+//             c:{
+//                 d: 'ddd'
+//             },
+//             bool:{
+//                 a: false
+//             },
+//             some: {
+//                 d: 'dd'
+//             },
+//         }
+
+//         const merged = A_CommonHelper.deepCloneAndMerge(t2, t);
+
+//         console.log('merged: ', merged)
+
+//         expect(merged.a).toBe('a');
+//         expect(merged.b).toBe('bb');
+//         expect(merged.c.d).toBe('ddd');
+//         expect(merged.bool.a).toBe(false);
+//         expect((merged as any).e).toBe('foo');
+//         expect((merged as any).some.d).toBe('dd');
+//         expect(merged.f('names')).toBe('names');
+//     });
+// });

package/tests/log.ts

@@ -0,0 +1,54 @@
+// import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-concept/constants/errors.constants";
+// import { A_Context } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class"
+// import { A_Error } from "@adaas/a-concept/global/A_Error.class";
+// import rl from 'readline';
+
+
+// (async () => {
+
+//     await A_Context.ready;
+
+//     A_Context.configure({
+//         verbose: true
+//     })
+
+//     A_Context.Logger.log('Test Log', {
+//         test: 'test',
+//         test2: 'test2',
+//         foo: {
+//             bar: 'bar',
+//             baz: {
+//                 qux: 'qux'
+//             }
+//         }
+//     }, 'Maybe its a hige update');
+
+//     A_Context.Logger.error(new Error('Test Error'), new A_Error(A_CONSTANTS__DEFAULT_ERRORS.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ));
+//     A_Context.Logger.error(new A_Error(A_CONSTANTS__DEFAULT_ERRORS.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ));
+//     A_Context.Logger.log(new A_Error(A_CONSTANTS__DEFAULT_ERRORS.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ));
+
+//     const rlInterface = rl.createInterface({
+//         input: process.stdin,
+//         output: process.stdout
+//     });
+
+//     const answer = await new Promise<string>(resolve => rlInterface
+//         .question(
+//             A_Context.Logger.compile('pink', 'What is your name?', '(1,2,3,4)').join(' ') + '\n' +
+//             A_Context.Logger.compile('pink', 'Answer (1,2,3,4)').join(' '),
+//             resolve));
+
+//     rl.moveCursor(process.stdout, 0, -1); // Move cursor to the beginning of the previous line
+//     rl.clearLine(process.stdout, 0); // Clear the current line
+
+//     const answer2 = await new Promise<string>(resolve => rlInterface
+//         .question(
+//             A_Context.Logger.compile('pink', 'Answer (1,2,3,4)').join(' '),
+//             resolve));
+
+//     rl.moveCursor(process.stdout, 0, -1); // Move cursor to the beginning of the previous line
+//     rl.clearLine(process.stdout, 0); // Clear the current line
+//     // console.log('Asnwer: ', answer);
+
+
+// })()

package/tests/polyfill.test.ts

@@ -0,0 +1,37 @@
+// import { config } from 'dotenv';
+// import { A_Polyfills } from '../src/lib/A_Polyfills'
+// config();
+// jest.retryTimes(0);
+
+// describe('Polyfill Tests', () => {
+
+//     it('It Should return fs', async () => {
+
+//         const fs = await A_Polyfills.fs();
+
+
+//         console.log('fs: ', fs)
+
+
+//     });
+//     it('It Should return crypto', async () => {
+
+//         const crypto = await A_Polyfills.crypto();
+
+//         console.log('crypto: ', crypto)
+
+//     });
+
+//     it('Crypto should calculate Hash', async () => {
+
+//         const crypto = await A_Polyfills.crypto();
+
+//         const hash = await crypto.createFileHash('./index.ts', 'sha-256');
+
+//         console.log('hash: ', hash)
+
+        
+//     });
+
+
+// });

package/tsconfig.json

@@ -0,0 +1,61 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "outDir": "dist",
+    "strict": true,
+    "noImplicitAny": false,
+    "noFallthroughCasesInSwitch": true,
+    "downlevelIteration": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noErrorTruncation": true,
+    "jsx": "react",
+    "target": "es2015",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "removeComments": false,
+    "preserveConstEnums": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "experimentalDecorators": true,
+    "skipLibCheck": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "paths": {
+      "@adaas/a-concept/constants/*": ["src/constants/*"],
+      "@adaas/a-concept/global/*": ["src/global/*"],
+      "@adaas/a-concept/types/*": ["src/types/*"],
+      "@adaas/a-concept/helpers/*": ["src/helpers/*"],
+      "@adaas/a-concept/decorators/*": ["src/decorators/*"],
+      "@adaas/a-concept/managers/*": ["src/managers/*"],
+      "@adaas/a-concept/providers/*": ["src/providers/*"],
+      "@adaas/a-concept/modules/*": ["src/modules/*"]
+    },
+    "lib": [
+      "dom",
+      "esnext.asynciterable",
+      "es2015",
+      "es2016",
+      "es2017.object"
+    ]
+  },
+  "include": [
+    "src/**/*",
+    "tests/**/*", 
+    "examples/**/*", 
+    "index.ts"  
+  ],
+  "exclude": [
+    "node_modules/**/*",
+    "dist/**/*",
+    "node_modules/@types/mocha/index.d.ts"
+  ]
+}

package/tslint.json

@@ -0,0 +1,98 @@
+{
+    "extends": [
+      "tslint-react",
+      "tslint-config-standard",
+      "tslint-microsoft-contrib",
+      "tslint-config-prettier"
+    ],
+    "rules": {
+      "array-bracket-spacing": [true, "never"],
+      "arrow-return-shorthand": true,
+      "no-backbone-get-set-outside-model": false,
+      "completed-docs": false,
+      "curly": [true, "ignore-same-line"],
+      "cyclomatic-complexity": [true, 24],
+      "eofline": true,
+      "export-name": false,
+      "function-name": false,
+      "import-name": false,
+      "import-spacing": true,
+      "interface-name": [true, "never-prefix"],
+      "jsx-alignment": false,
+      "jsx-boolean-value": false,
+      "jsx-curly-spacing": false,
+      "jsx-no-multiline-js": false,
+      "match-default-export-name": false,
+      "max-func-body-length": 200,
+      "member-access": [true, "no-public"],
+      "member-ordering": {"options": [{"order": "fields-first"}]},
+      "missing-jsdoc": false,
+      "mocha-no-side-effect-code": false,
+      "no-arg": true,
+      "no-bitwise": true,
+      "no-console": false,
+      "no-construct": true,
+      "no-default-export": false,
+      "no-duplicate-switch-case": true,
+      "no-duplicate-variable": true,
+      "no-empty-interface": false,
+      "no-eval": true,
+      "no-function-expression": false,
+      "no-http-string": false,
+      "no-implicit-dependencies": false,
+      "no-multiline-string": false,
+      "no-non-null-assertion": true,
+      "no-relative-imports": false,
+      "no-require-imports": {"severity": "warning"},
+      "no-reserved-keywords": false,
+      "no-return-await": true,
+      "no-single-line-block-comment": false,
+      "no-string-throw": true,
+      "no-submodule-imports": false,
+      "no-suspicious-comment": false,
+      "no-unsafe-any": false,
+      "no-unused-variable": false,
+      "no-var-requires": true,
+      "no-void-expression": false,
+      "object-curly-spacing": [true, "never"],
+      "ordered-imports": false,
+      "prefer-for-of": true,
+      "prefer-object-spread": true,
+      "prefer-type-cast": false,
+      "quotemark": [true, "single", "jsx-double", "avoid-escape"],
+      "semicolon": [true, "never"],
+      "strict-boolean-expressions": false,
+      "strict-type-predicates": false,
+      "ter-func-call-spacing": [true, "never"],
+      "trailing-comma": [true, "always"],
+      "type-literal-delimiter": false,
+      "typedef": false,
+      "typedef-whitespace": [
+        true,
+        {
+          "call-signature": "nospace",
+          "index-signature": "nospace",
+          "parameter": "nospace",
+          "property-declaration": "nospace",
+          "variable-declaration": "nospace"
+        },
+        {
+          "call-signature": "onespace",
+          "index-signature": "onespace",
+          "parameter": "onespace",
+          "property-declaration": "onespace",
+          "variable-declaration": "onespace"
+        }
+      ],
+      "unified-signatures": true,
+      "variable-name": false,
+      "whitespace": [
+        true,
+        "check-branch",
+        "check-operator",
+        "check-typecast",
+        "check-rest-spread",
+        "check-type-operator"
+      ]
+    }
+  }