@saolabs/client 1.0.0

package/src/core/hellpers/ApiClient.ts

@@ -0,0 +1,145 @@
+/**
+ * API Module - V2 TypeScript
+ * Centralized API service for backend communication
+ */
+
+import { APIClientInterface } from '../contracts/ApiInterface.js';
+import { HttpService } from '../services/HttpService.js';
+
+export interface APIEndpoints {
+    system?: {
+        config?: string;
+        data?: string;
+    };
+    [key: string]: any;
+}
+
+export class ApiClient implements APIClientInterface {
+    private http: HttpService;
+    private endpoints: APIEndpoints;
+
+    constructor() {
+        this.http = new HttpService();
+        this.setupDefaultHeaders();
+        this.endpoints = this.loadEndpoints();
+    }
+
+    /**
+     * Setup default headers including CSRF token
+     * @private
+     */
+    private setupDefaultHeaders(): void {
+        this.http.setHeader('Content-Type', 'application/json');
+        this.http.setHeader('Accept', 'application/json');
+        this.http.setHeader('X-Requested-With', 'XMLHttpRequest');
+        this.http.setHeader('X-DATA-TYPE', 'json');
+
+        // Get CSRF token from meta tag (SSR support)
+        if (typeof document !== 'undefined') {
+            const csrfToken = document.querySelector('meta[name="csrf-token"]');
+            if (csrfToken) {
+                const token = csrfToken.getAttribute('content');
+                if (token) {
+                    this.http.setHeader('X-CSRF-TOKEN', token);
+                }
+            }
+        }
+    }
+
+    init(config: Record<string, any>): void {
+        // Placeholder for any future initialization logic
+    }
+
+    /**
+     * Load API endpoints from config
+     * @private
+     */
+    private loadEndpoints(): APIEndpoints {
+        if (typeof window === 'undefined') {
+            return {};
+        }
+        return (window as any).ONE_CONFIGS?.api?.endpoints || {};
+    }
+
+    /**
+     * Get view data for specific URI
+     * V1 compatible: returns response.data if status=true, else {}
+     */
+    async getViewData(uri: string): Promise<any> {
+        try {
+            const response = await this.http.get(uri);
+            return response.status ? response.data : {};
+        } catch (error) {
+            console.error('[API] Error getting view data:', error);
+            return {};
+        }
+    }
+
+    /**
+     * Get system configuration
+     * V1 compatible
+     */
+    async getSystemConfig(): Promise<any> {
+        const endpoint = this.endpoints?.system?.config;
+        if (!endpoint) {
+            return {};
+        }
+
+        try {
+            const response = await this.http.get(endpoint);
+            return response.status ? response.data : {};
+        } catch (error) {
+            console.error('[API] Error getting system config:', error);
+            return {};
+        }
+    }
+
+    /**
+     * Get system data
+     * V1 compatible
+     */
+    async getSystemData(): Promise<any> {
+        const endpoint = this.endpoints?.system?.data;
+        if (!endpoint) {
+            return {};
+        }
+
+        try {
+            const response = await this.http.get(endpoint);
+            return response.status ? response.data : {};
+        } catch (error) {
+            console.error('[API] Error getting system data:', error);
+            return {};
+        }
+    }
+
+    /**
+     * Get data for current URI
+     * Optimization: SSR-safe window access
+     */
+    async getURIData(): Promise<any> {
+        if (typeof window === 'undefined') {
+            return {};
+        }
+
+        const uri = window.location.pathname + window.location.search;
+        return this.getViewData(uri);
+    }
+
+    /**
+     * Set custom endpoint
+     */
+    setEndpoint(key: string, value: string): void {
+        if (!this.endpoints[key]) {
+            this.endpoints[key] = {};
+        }
+        Object.assign(this.endpoints[key], typeof value === 'string' ? { url: value } : value);
+    }
+
+    /**
+     * Get HTTP service instance for custom requests
+     */
+    getHttpService(): HttpService {
+        return this.http;
+    }
+}

package/src/core/hellpers/app.ts

@@ -0,0 +1,57 @@
+import { Application } from "../app/Application";
+import { AppFactory, ServiceKey } from "../contracts/ApplicationInterface";
+
+
+/**
+ * Container instance để quản lý services
+ * Tương tự Laravel's app container
+ */
+const AppInstance = new Application();
+
+/**
+ * Helper function để lấy/đăng ký services
+ * Cách dùng:
+ * - app() - trả về container instance
+ * - app('service_name') - lấy service
+ * - app('key', value) - đăng ký instance
+ * 
+ * @param key - Tên service (optional)
+ * @param value - Giá trị service (optional)
+ * @returns Container instance, service, hoặc void
+ * 
+ * @example
+ * // Lấy container
+ * const container = app();
+ * container.singleton('store', Store);
+ * 
+ * // Lấy service trực tiếp
+ * const store = app('store');
+ * 
+ * // Đăng ký instance
+ * app('config', { api: 'https://api.example.com' });
+ */
+const appFactory = <T>(key?: ServiceKey, value?: any): Application | T | any | void => {
+    if (key === undefined || key === null) {
+        // Không truyền gì → trả về container
+        return AppInstance;
+    }
+    if (value !== undefined) {
+        // Truyền 2 tham số → đăng ký instance
+        AppInstance.instance(key, value);
+        return;
+    }
+    // Truyền 1 tham số → lấy service
+    return AppInstance.make(key);
+};
+
+// Add make method to app function for TypeScript compatibility
+appFactory.make = <T>(name: ServiceKey): T => AppInstance.make(name);
+appFactory.instance = <T>(name: ServiceKey, value: T): Application => AppInstance.instance(name, value);
+appFactory.resolve = <T>(name: ServiceKey, defaultValue?: T): T => AppInstance.resolve(name, defaultValue);
+appFactory.register = <T>(name: ServiceKey, factory: () => T): Application => AppInstance.bind(name, factory);
+appFactory.bind = <T>(name: ServiceKey, factory: () => T): Application => AppInstance.bind(name, factory);
+appFactory.singleton = <T>(name: ServiceKey, factory: () => T): Application => AppInstance.singleton(name, factory);
+appFactory.has = (name: ServiceKey): boolean => AppInstance.has(name);
+appFactory.flush = (): void => { AppInstance.flush(); };
+appFactory.destroy = (): void => { AppInstance.destroy(); };
+export const app = appFactory as AppFactory;

package/src/core/hellpers/utils.ts

@@ -0,0 +1,109 @@
+export function generateUUID(length: number = 36): string {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    }).substring(0, length);
+}
+const htmlEscapeMap: Record<string, string> = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+const htmlEscapeRe = /[&<>"']/g;
+
+export function escapeHTML(str: string): string {
+    return str.replace(htmlEscapeRe, (ch) => htmlEscapeMap[ch]);
+}
+export function isEmpty(value: any): boolean {
+    if (value == null) return true;
+    if (typeof value === 'string' && value.trim() === '') return true;
+    if (Array.isArray(value) && value.length === 0) return true;
+    if (typeof value === 'object' && Object.keys(value).length === 0) return true;
+    return false;
+}
+
+export function isObject(value: any): boolean {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function hasProperty(obj: any, prop: string): boolean {
+    return obj != null && Object.prototype.hasOwnProperty.call(obj, prop);
+}
+export function hasMethod(obj: any, method: string): boolean {
+    return obj != null && typeof obj[method] === 'function';
+}
+export function hasAnyProperty(obj: any, props: string[]): boolean {
+    return obj != null && props.some(prop => Object.prototype.hasOwnProperty.call(obj, prop));
+}
+export function hasData(value: any): boolean {
+    return isObject(value) && Object.keys(value).length > 0;
+}
+export function isArray(value: any): boolean {
+    return Array.isArray(value);
+}
+
+export function isString(value: any): boolean {
+    return typeof value === 'string';
+}
+
+export function isNumber(value: any): boolean {
+    return typeof value === 'number' && !isNaN(value);
+}
+
+export function isBoolean(value: any): boolean {
+    return typeof value === 'boolean';
+}
+
+export function isFunction(value: any): boolean {
+    return typeof value === 'function';
+}
+
+export function isPromise(value: any): boolean {
+    return value instanceof Promise || (value !== null && typeof value === 'object' && typeof value.then === 'function');
+}
+
+export function isHTMLElement(value: any): boolean {
+    return value instanceof HTMLElement;
+}
+
+export function isNode(value: any): boolean {
+    return value instanceof Node;
+}
+
+export function isCommentNode(value: any): boolean {
+    return value instanceof Comment;
+}
+
+export function isTextNode(value: any): boolean {
+    return value instanceof Text;
+}
+
+export function isOneElement(value: any): boolean {
+    return value && typeof value === 'object' && 'isOneElement' in value && value.isOneElement === true;
+}
+
+export function isOneHtml(value: any): boolean {
+    return value && typeof value === 'object' && 'isOneHtml' in value && value.isOneHtml === true;
+}
+
+export function isOneText(value: any): boolean {
+    return value && typeof value === 'object' && 'isOneText' in value && value.isOneText === true;
+}
+
+export function isOneNativeElement(value: any): boolean {
+    return value && typeof value === 'object' && 'isOneNativeElement' in value && value.isOneNativeElement === true;
+}
+
+export function isOneReactive(value: any): boolean {
+    return value && typeof value === 'object' && 'isOneReactive' in value && value.isOneReactive === true;
+}
+
+export function isOneFragment(value: any): boolean {
+    return value && typeof value === 'object' && 'isOneFragment' in value && value.isOneFragment === true;
+}
+
+export function isOneBlock(value: any): boolean {
+    return value && typeof value === 'object' && 'isOneBlock' in value && value.isOneBlock === true;
+}