@adaas/are 0.0.2

package/src/lib/AreSyntax/AreSyntax.context.ts

@@ -0,0 +1,114 @@
+import { A_Fragment } from "@adaas/a-concept";
+import { A_Frame } from "@adaas/a-frame";
+import { AreSyntaxInitOptions } from "./AreSyntax.types";
+
+@A_Frame.Fragment({
+    namespace: 'A-ARE',
+    name: 'AreSyntaxContext',
+    description: 'Context that defines the syntax rules and structures for the A-Concept Rendering Engine (ARE). It provides mechanisms for parsing and interpreting templates, attributes, directives, interpolations, and event listeners, enabling dynamic and interactive UI rendering within the ARE framework.'
+})
+export class AreSyntaxContext extends A_Fragment {
+
+
+    constructor(
+        /**
+         * Initialization options for configuring the AreSyntax context.
+         */
+        protected readonly config: Partial<AreSyntaxInitOptions> = {}
+    ) {
+        super({ name: 'AreSyntaxContext' });
+
+    }
+
+
+    /**
+     * identifier of the root tag to use when compiling in browser context.
+     * 
+     * @return {string} The root tag identifier.
+     */
+    get rootTag(): string {
+        return this.config.rootTag || 'are-root';
+    }
+    /**
+     * List of standard HTML tags to recognize.
+     * [!] This is a set of tags that can be ignored when determining if a node is a custom component.
+     * 
+     * @return {Set<string>} A set of standard HTML tag names.
+     */
+    get standardTags(): Set<string> {
+        return new Set(this.config.standardTags || [])
+    };
+    /**
+     * Enable or disable debug mode for syntax parsing.
+     * When enabled, additional debug information will be logged during parsing.
+     * 
+     * @return {boolean} True if debug mode is enabled, false otherwise.
+     */
+    get debugMode(): boolean {
+        return this.config.debugMode || false;
+    }
+    /**
+     * Custom interpolation delimiters for template parsing.
+     * Default is ['{{', '}}'].
+     * 
+     * @return {[string, string]} The opening and closing interpolation delimiters.
+     */
+    get interpolationDelimiters(): [string, string] {
+        return this.config.interpolationDelimiters || ['{{', '}}'];
+    }
+    /**
+     * Custom binding delimiter for data binding parsing.
+     * Default is ':'.
+     * @return {string} The binding delimiter.
+     */
+    get bindingDelimiter(): string {
+        return this.config.bindingDelimiter || ':';
+    }
+    /**
+     * Custom listener delimiter for event binding parsing.
+     * Default is '@'.
+     * 
+     * @return {string} The listener delimiter.
+     */
+    get listenerDelimiter(): string {
+        return this.config.listenerDelimiter || '@';
+    }
+    /**
+     * Enable or disable strict mode for syntax parsing.
+     * When enabled, the parser will throw errors for any syntax violations.
+     * Default is true.
+     * 
+     * @return {boolean} True if strict mode is enabled, false otherwise.
+     */
+    get strictMode(): boolean {
+        return this.config.strictMode !== false;
+    }
+    /**
+     * Enable or disable whitespace trimming in templates.
+     * When enabled, leading and trailing whitespace in template expressions will be trimmed.
+     * Default is true.
+     * 
+     * @return {boolean} True if whitespace trimming is enabled, false otherwise.
+     */
+    get trimWhitespace(): boolean {
+        return this.config.trimWhitespace !== false;
+    }
+    /**
+     * Custom directive delimiter for directive parsing.
+     * Default is '$'.
+     * 
+     * @return {string} The directive delimiter.
+     */
+    get directiveDelimiter(): string {
+        return this.config.directiveDelimiter || '$';
+    }
+
+    /*
+     * A list of custom directives to be recognized by the syntax parser.
+     * Each directive should be a string representing the directive name.
+     * Default is an empty array.
+     */
+    get customDirectives(): string[] {
+        return this.config.customDirectives || [];
+    }
+}

package/src/lib/AreSyntax/AreSyntax.error.ts

@@ -0,0 +1,11 @@
+import { A_Error } from "@adaas/a-concept";
+
+
+
+export class AreSyntaxError extends A_Error {
+
+    static readonly SyntaxParseError = 'Are Syntax Parse Error';
+    static readonly SyntaxNotSupportedError = 'Are Syntax Not Supported Error';
+    static readonly MethodNotImplementedError = 'Are Syntax Method Not Implemented Error';
+
+}

package/src/lib/AreSyntax/AreSyntax.types.ts

@@ -0,0 +1,156 @@
+
+
+export type AreSyntaxInitOptions = {
+    /**
+     * Enable or disable debug mode for AreSyntax.
+     * When enabled, additional logging and debugging information will be available.
+     * Default is false.
+     */
+    debugMode?: boolean;
+
+    /**
+     * Custom interpolation delimiters for template parsing.
+     * Default is ['{{', '}}'].
+     */
+    interpolationDelimiters?: [string, string];
+
+    /**
+     * Custom binding delimiters for data binding parsing.
+     * Default is ':'.
+     */
+    bindingDelimiter?: string;
+
+
+    /**
+     * Custom listener delimiters for event binding parsing.
+     * Default is '@'.
+     */
+    listenerDelimiter?: string;
+
+
+
+    /**
+     * Enable or disable strict mode for syntax parsing.
+     * When enabled, the parser will throw errors for any syntax violations.
+     * Default is true.
+     */
+    strictMode?: boolean;
+
+    /**
+     * A list of custom directives to be recognized by the syntax parser.
+     * Each directive should be a string representing the directive name.
+     * Default is an empty array.
+     */
+    customDirectives?: string[];
+
+    /**
+     * Enable or disable whitespace trimming in templates.
+     * When enabled, leading and trailing whitespace in template expressions will be trimmed.
+     * Default is true.    
+     */
+    trimWhitespace?: boolean;
+
+
+    /**
+     * identifier of the root tag to use when compiling in browser context.
+     */
+    rootTag?: string;
+
+    /**
+     * Custom directive delimiter for directive parsing.
+     * Default is '$'.
+     */
+    directiveDelimiter?: string;
+
+    /**
+     * List of standard HTML tags to recognize.
+     */
+    standardTags?: string[]
+};
+
+
+// ==================================================================================
+// ========================= SYNTAX Structures TYPES ================================
+// ==================================================================================
+
+export type AreAttribute = {
+    /**
+     * Tag name where the attribute was found
+     */
+    tag: string;
+    /**
+     * Property name (e.g. "label")
+     */
+    name: string;
+    /**
+     * Full raw attribute (e.g. ' :label="buttonLabel" ')
+     */
+    raw: string;
+    /**
+     * Attribute value (e.g. "buttonLabel")
+     */
+    value: string;
+    /**
+     * True if the attribute is a binding (e.g. :prop), false otherwise (e.g. prop="value")
+     */
+    binding: boolean;
+};
+
+export type AreInterpolation = {
+    /**
+     * Tag name where the interpolation was found
+     */
+    raw: string;
+    /**
+     * Name of the interpolation (e.g. "userName")
+     */
+    name: string;
+    /**
+     * Position in the template where this interpolation was found 
+     */
+    position: number;
+}
+
+
+export type AreListener = {
+    /**
+     * tag name where listener was found
+     */
+    tag: string;
+    /**
+     * event name (e.g. "input")
+     */
+    name: string;
+    /**
+     * full raw attribute (e.g. ' @input="onChange"')
+     */
+    raw: string;
+    /**
+     * handler expression (e.g. "onChange")
+     */
+    handler: string;
+};
+
+
+export type AreDirective = {
+    /**
+     * The tag name where the directive was found
+     */
+    tag: string;
+    /**
+     * The name of the directive (e.g. "$if")
+     */
+    name: string;
+    /**
+     * The full raw attribute text (e.g. '$if="condition"')
+     */
+    raw: string;
+    /**
+     * The value expression associated with the directive (e.g. "condition")
+     */
+    value?: string;
+    /**
+     * The full tag template where the directive was found
+     */
+    template: string;
+};

package/src/lib/AreSyntax/index.ts

@@ -0,0 +1,4 @@
+export { AreSyntax } from './AreSyntax.component';
+export { AreSyntaxContext } from './AreSyntax.context';
+export { AreSyntaxError } from './AreSyntax.error';
+export * from './AreSyntax.types';

package/src/signals/AreInit.signal.ts

@@ -0,0 +1,7 @@
+import { A_Signal } from "@adaas/a-utils/a-signal";
+
+export class AreInitSignal extends A_Signal {
+    static async default(): Promise<A_Signal| undefined> {
+        return new AreInitSignal({ data: { ready: false } });
+    }
+}

package/src/signals/AreRoute.signal.ts

@@ -0,0 +1,25 @@
+import { A_Route } from "@adaas/a-utils/a-route";
+import { A_Signal } from "@adaas/a-utils/a-signal";
+
+
+
+export class AreRouteSignal extends A_Signal<{
+    route: A_Route;
+}> {
+
+    constructor(path: string | RegExp) {
+        super({
+            data: {
+                route: new A_Route(path)
+            }
+        });
+    }
+
+    get route(): A_Route {
+        return this.data.route;
+    }
+
+    static async default(): Promise<A_Signal | undefined> {
+        return new AreRouteSignal(document.location.href);
+    }
+}

package/src/signals/index.ts

@@ -0,0 +1,2 @@
+export { AreInitSignal } from './AreInit.signal';
+export { AreRouteSignal } from './AreRoute.signal'

package/tests/A-HttpChannel.test.ts

@@ -0,0 +1,204 @@
+// import { A_Context, A_Feature, A_Inject, A_Scope } from '@adaas/a-concept';
+// import { A_HTTPChannel } from '@adaas/a-server/channels/A-Http/A-Http.channel';
+// import { A_SERVER_CONSTANTS__A_HttpChannel_Lifecycle } from '@adaas/a-server/channels/A-Http/A-Http.channel.constants';
+// import { A_HTTPChannel_RequestContext } from '@adaas/a-server/context/A-HttpChannel/A-HttpChannel.context';
+
+// jest.retryTimes(0);
+
+
+// type MockResponse = Array<{ userId: number; id: number; title: string; body: string; customField: string }>
+
+// describe('A-HttpChannel Tests', () => {
+//     it('Should be possible to create a new HttpChannel', async () => {
+//         const scope = new A_Scope({
+//             components: [A_HTTPChannel]
+//         });
+
+
+//         const channel = scope.resolve(A_HTTPChannel);
+
+//         expect(channel).toBeInstanceOf(A_HTTPChannel);
+//         expect(channel.processing).toBe(false);
+//     });
+//     it('Should be possible to create a custom Channel', async () => {
+//         class myChannel extends A_HTTPChannel {
+//             custom = true;
+
+//             constructor() {
+//                 super();
+//                 this.baseUrl = "https://jsonplaceholder.typicode.com";
+//             }
+//         }
+
+//         const scope = new A_Scope({
+//             components: [myChannel]
+//         });
+
+//         const channel = scope.resolve(myChannel);
+//         expect(channel).toBeInstanceOf(myChannel);
+//         expect(channel.custom).toBe(true);
+//         expect(channel.processing).toBe(false);
+
+//         const response = await channel.get<MockResponse>(
+//             '/posts',
+//             { userId: 1 }
+//         );
+
+//         expect(Array.isArray(response.result)).toBe(true);
+//         expect(response.result?.length).toBeGreaterThan(0);
+//         expect(response.result?.[0].userId).toBe(1);
+//     });
+
+//     it('Should throw an error if baseUrl is not set', async () => {
+//         const scope = new A_Scope({
+//             components: [A_HTTPChannel]
+//         });
+
+//         const channel = scope.resolve(A_HTTPChannel);
+
+//         await expect(channel.get('/posts')).rejects.toThrow("Base URL is not set for HTTP Channel");
+//     });
+
+//     it('Should allow to extend response handler behavior', async () => {
+//         class myChannel extends A_HTTPChannel {
+//             custom = true;
+//             constructor() {
+//                 super();
+//                 this.baseUrl = "https://jsonplaceholder.typicode.com";
+//             }
+//         }
+
+//         class myChannelWithCustomResponseHandler extends myChannel {
+
+//             @A_Feature.Extend({
+//                 name: A_SERVER_CONSTANTS__A_HttpChannel_Lifecycle.onAfterRequest
+//             })
+//             protected async handleResponse<T>(
+//                 @A_Inject(A_HTTPChannel_RequestContext) context: A_HTTPChannel_RequestContext<MockResponse>
+//             ): Promise<void> {
+//                 context.result = context.result?.map(item => ({
+//                     ...item,
+//                     customField: 'customValue'
+//                 })) || [];
+//             }
+//         }
+
+//         const scope = new A_Scope({
+//             components: [myChannel, myChannelWithCustomResponseHandler]
+//         });
+
+//         const channel = scope.resolve(myChannelWithCustomResponseHandler);
+//         expect(channel).toBeInstanceOf(myChannelWithCustomResponseHandler);
+//         expect(channel.custom).toBe(true);
+//         expect(channel.processing).toBe(false);
+
+//         const response = await channel.get<MockResponse>('/posts', { userId: 1 });
+
+//         expect(Array.isArray(response.result)).toBe(true);
+//         expect(response.result?.length).toBeGreaterThan(0);
+//         expect(response.result?.[0].userId).toBe(1);
+//         expect((response.result?.[0] as any).customField).toBe('customValue');
+//     });
+//     it('Should allow to extend error handler behavior', async () => {
+//         class myChannel extends A_HTTPChannel {
+//             custom = true;
+//             constructor() {
+//                 super();
+//                 this.baseUrl = "https://jsonplaceholder.typicode.com";
+//             }
+//         }
+
+//         class myChannelWithCustomErrorHandler extends myChannel {
+//             @A_Feature.Extend({
+//                 name: A_SERVER_CONSTANTS__A_HttpChannel_Lifecycle.onError
+//             })
+//             protected async handleError(
+//                 @A_Inject(A_HTTPChannel_RequestContext) context: A_HTTPChannel_RequestContext<MockResponse>,
+//                 error: any
+//             ): Promise<void> {
+//                 context.result = [{
+//                     userId: -1,
+//                     id: -1,
+//                     title: 'error',
+//                     body: 'error',
+//                     customField: 'customValue'
+//                 }];
+//             }
+//         }
+
+//         const scope = new A_Scope({
+//             components: [myChannel, myChannelWithCustomErrorHandler]
+//         });
+
+//         const channel = scope.resolve(myChannelWithCustomErrorHandler);
+//         expect(channel).toBeInstanceOf(myChannelWithCustomErrorHandler);
+//         expect(channel.custom).toBe(true);
+//         expect(channel.processing).toBe(false);
+
+//         const response = await channel.get<MockResponse>('/posts_invalid', { userId: 1 }, { throwOnError: false });
+
+//         expect(Array.isArray(response.result)).toBe(true);
+//         expect(response.result?.length).toBe(1);
+//         expect(response.result?.[0].userId).toBe(-1);
+//         expect((response.result?.[0] as any).customField).toBe('customValue');
+//     });
+
+//     it('Should do a proper filtering with query params', async () => {
+//         class myChannel extends A_HTTPChannel {
+//             custom = true;
+//             constructor() {
+//                 super();
+//                 this.baseUrl = "https://jsonplaceholder.typicode.com";
+//             }
+//         }
+
+//         const scope = new A_Scope({
+//             components: [myChannel]
+//         });
+
+//         const channel = scope.resolve(myChannel);
+//         expect(channel).toBeInstanceOf(myChannel);
+//         expect(channel.custom).toBe(true);
+//         expect(channel.processing).toBe(false);
+
+//         const response = await channel.get<MockResponse>('/posts', { userId: 1 });
+
+//         expect(Array.isArray(response.result)).toBe(true);
+//         expect(response.result?.length).toBeGreaterThan(0);
+//         expect(response.result?.every(item => item.userId === 1)).toBe(true);
+//     });
+
+//     it('Should be possible to do a POST request', async () => {
+//         class myChannel extends A_HTTPChannel {
+//             custom = true;
+//             constructor() {
+//                 super();
+//                 this.baseUrl = "https://jsonplaceholder.typicode.com";
+//             }
+//         }
+
+//         const scope = new A_Scope({
+//             components: [myChannel]
+//         });
+
+//         const channel = scope.resolve(myChannel);
+//         expect(channel).toBeInstanceOf(myChannel);
+//         expect(channel.custom).toBe(true);
+//         expect(channel.processing).toBe(false);
+
+//         const response = await channel.post<MockResponse>(
+//             '/posts',
+//             {
+//                 title: 'foo',
+//                 body: 'bar',
+//                 userId: 1,
+//             }
+//         );
+
+//         expect(response.result).toBeDefined();
+//         expect((response.result as any).id).toBeDefined();
+//         expect((response.result as any).title).toBe('foo');
+//         expect((response.result as any).body).toBe('bar');
+//         expect((response.result as any).userId).toBe(1);
+//     });
+// });