@adaas/a-frame 0.0.2

package/tests/A-Frame.test.ts

@@ -0,0 +1,91 @@
+import { A_Component, A_Container, A_Context, A_Entity, A_Fragment } from "@adaas/a-concept";
+import { A_Frame, A_Frame_IndexError, A_Frame_IndexMeta, A_Frame_IndexTargetType } from "../src/index";
+describe('A-Frame Tests', () => {
+    it('Standard basic test ', async () => {
+
+
+        @A_Frame.Namespace('MyTestNamespace')
+        @A_Frame.Component()
+        class MyComponent extends A_Component {
+        }
+
+
+        @A_Frame.Entity({
+            name: 'MyTestEntity',
+            description: 'This entity is uses for the test purpose'
+        })
+        class MyEntity extends A_Entity {
+
+            @A_Frame.Namespace('MethodNamespace')
+            @A_Frame.Describe('MethodNamespace')
+            @A_Frame.Method()
+            async testMethod() {
+                return 'test';
+            }
+
+        }
+
+        @A_Frame.Container()
+        class MyContainer extends A_Container {
+
+        }
+
+        @A_Frame.Describe('This is a test fragment for demonstration purposes')
+        @A_Frame.Fragment()
+        class MyFragment extends A_Fragment {
+
+
+        }
+
+        try {
+            // Test standalone decorators (without index decorators)
+            @A_Frame.Namespace('StandaloneNamespace')
+            @A_Frame.Describe('Standalone description')
+            class StandaloneClass { }
+        } catch (error) {
+            //  SHould trow error because standalone decorators should not create index entries
+            expect(error).toBeInstanceOf(A_Frame_IndexError);
+        }
+
+
+        // Test that components are properly registered
+        const indexMeta = A_Context.meta<A_Frame_IndexMeta>(A_Frame);
+        const registeredComponents = indexMeta.getMetaFor(MyFragment);
+
+        expect(registeredComponents).toBeDefined();
+        expect(registeredComponents.name).toBe('MyFragment');
+        expect(registeredComponents.type).toBe(A_Frame_IndexTargetType.FRAGMENT);
+        expect(registeredComponents.description).toBe('This is a test fragment for demonstration purposes');
+
+        const registeredEntity = indexMeta.getMetaFor(MyEntity);
+
+        expect(registeredEntity).toBeDefined();
+        expect(registeredEntity.name).toBe('MyTestEntity');
+        expect(registeredEntity.type).toBe(A_Frame_IndexTargetType.ENTITY);
+        expect(registeredEntity.description).toBe('This entity is uses for the test purpose');
+
+        const registeredComponent = indexMeta.getMetaFor(MyComponent);
+
+        expect(registeredComponent).toBeDefined();
+        expect(registeredComponent.name).toBe('MyComponent');
+        expect(registeredComponent.type).toBe(A_Frame_IndexTargetType.COMPONENT);
+        expect(registeredComponent.description).toBeUndefined();
+
+        const registeredContainer = indexMeta.getMetaFor(MyContainer);
+
+        expect(registeredContainer).toBeDefined();
+        expect(registeredContainer.name).toBe('MyContainer');
+        expect(registeredContainer.type).toBe(A_Frame_IndexTargetType.CONTAINER);
+        expect(registeredContainer.description).toBeUndefined();
+
+        // Test that method is properly registered
+        const registeredMethod = registeredEntity.methods.get('testMethod');
+
+        console.log('registeredEntity.methods: ', registeredEntity.methods)
+
+        expect(registeredMethod).toBeDefined();
+        expect(registeredMethod?.name).toBe('testMethod');
+        expect(registeredMethod?.description).toBe('MethodNamespace');
+       
+    });
+});

package/tests/jest.setup.ts

@@ -0,0 +1,30 @@
+import { A_Context } from '@adaas/a-concept';
+import fs from 'fs';
+
+/**
+ * Base hooks for tests
+ */
+beforeAll(async () => {
+
+    return Promise.resolve();
+});
+
+afterAll(async () => {
+    try {
+        fs.unlinkSync('a-concept.conf.json');
+
+    } catch (error) {
+
+    }
+    return Promise.resolve();
+});
+
+beforeEach(async () => {
+    A_Context.reset();
+    return Promise.resolve();
+});
+
+afterEach(async () => {
+    A_Context.reset();
+    return Promise.resolve();
+});

package/tsconfig.json

@@ -0,0 +1,60 @@
+{
+  "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-frame/constants/*": ["src/constants/*"],
+      "@adaas/a-frame/lib/*": ["src/lib/*"],
+      "@adaas/a-frame/types/*": ["src/types/*"],
+      "@adaas/a-frame/helpers/*": ["src/helpers/*"],
+      "@adaas/a-frame/decorators/*": ["src/decorators/*"],
+      "@adaas/a-frame/utils/*": ["src/utils/*"]
+    },
+    "lib": [
+      "dom",
+      "esnext.asynciterable",
+      "es2015",
+      "es2016",
+      "es2017.object"
+    ]
+  },
+  "include": [
+    "src/**/*",
+    "tests/**/*",
+    "examples/**/*",
+    "src/index.ts",
+    "./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"
+      ]
+    }
+  }

package/tsup.config.ts

@@ -0,0 +1,32 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig((options) => ({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: !options.watch,
+  sourcemap: true,
+  target: "es2020",
+  minify: !options.watch,
+  treeshake: "recommended",
+  skipNodeModulesBundle: true,
+  splitting: false,
+  silent: false,
+  platform: "neutral",
+  // Add hash to filenames for cache busting in production builds
+  outExtension({ format }) {
+    return {
+      js: format === "esm" ? `.mjs` : `.cjs`,
+    };
+  },
+  // Extra optimization options (for 2025 esbuild)
+  esbuildOptions(options) {
+    options.keepNames = true; // Preserve class/function names for better debugging
+    options.charset = "utf8";
+  },
+
+  // Enable minification for output size (production only)
+  minifyWhitespace: !options.watch,
+  minifyIdentifiers: !options.watch,
+  minifySyntax: !options.watch,
+}));