@fylib/adapter-angular 0.1.0

package/dist/providers.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken, EnvironmentProviders } from '@angular/core';
+import { AppConfig } from '@fylib/config';
+/**
+ * Injection Token para a configuração global do fyLib no Angular.
+ */
+export declare const FYLIB_CONFIG: InjectionToken<Partial<AppConfig>>;
+/**
+ * Provedor de ambiente para inicializar o fyLib com uma configuração customizada.
+ *
+ * @param config Configuração parcial do fyLib (temas, animações, logs, sse, etc).
+ */
+export declare function provideFyLib(config: Partial<AppConfig>): EnvironmentProviders;

package/dist/providers.js

@@ -0,0 +1,18 @@
+import { InjectionToken, makeEnvironmentProviders } from '@angular/core';
+/**
+ * Injection Token para a configuração global do fyLib no Angular.
+ */
+export const FYLIB_CONFIG = new InjectionToken('FYLIB_CONFIG');
+/**
+ * Provedor de ambiente para inicializar o fyLib com uma configuração customizada.
+ *
+ * @param config Configuração parcial do fyLib (temas, animações, logs, sse, etc).
+ */
+export function provideFyLib(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: FYLIB_CONFIG,
+            useValue: config
+        }
+    ]);
+}

package/dist/services/fylib.service.d.ts

@@ -0,0 +1,31 @@
+import { Signal } from '@angular/core';
+import { AppConfig, ComponentSelector, UIEventKey } from '@fylib/config';
+import { DesignTokens } from '@fylib/core';
+export declare class FyLibService {
+    private platformId;
+    private configSignal;
+    private themeVersion;
+    readonly config: Signal<AppConfig>;
+    readonly tokens: Signal<DesignTokens>;
+    constructor(configFromProvider: Partial<AppConfig>);
+    private watchConfigFile;
+    setTheme(name: string): void;
+    setMode(mode: 'light' | 'dark'): void;
+    getMode(): import("@fylib/theme").ThemeMode;
+    getTokens(): DesignTokens;
+    getThemeBackgroundEffect(): {
+        name: string;
+        intensity?: number;
+        speed?: number;
+        loop?: boolean;
+    } | undefined;
+    getThemeWallpaper(): import("@fylib/core").WallpaperDefinition | undefined;
+    triggerEffect(name: string, params?: Record<string, any>): void;
+    triggerEffectForEvent(eventKey: UIEventKey, componentSelector?: ComponentSelector, instanceFlag?: boolean | null): void;
+    playAnimation(name: string): void;
+    isAnimationsEnabledFor(componentSelector: ComponentSelector): boolean;
+    isEffectsEnabledFor(componentSelector: ComponentSelector, instanceFlag: boolean | null | undefined): boolean;
+    getComponentAnimation(componentSelector: ComponentSelector, event: string): string | undefined;
+    private deepMerge;
+    private isObject;
+}

package/dist/services/fylib.service.js

@@ -0,0 +1,214 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Injectable, signal, computed, inject, PLATFORM_ID, Optional, Inject } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { themeEngine, defaultTheme } from '@fylib/theme';
+import { animationEngine } from '@fylib/animation';
+import { configManager } from '@fylib/config';
+import { logger } from '@fylib/logger';
+import { registerAllEffects } from '../effects/register-all';
+import { FYLIB_CONFIG } from '../providers';
+import { registerPhosphorProvider } from '../icons/providers/phosphor.provider';
+import { registerFontAwesomeProvider } from '../icons/providers/fontawesome.provider';
+import { registerMdiProvider } from '../icons/providers/mdi.provider';
+let FyLibService = class FyLibService {
+    constructor(configFromProvider) {
+        this.platformId = inject(PLATFORM_ID);
+        this.configSignal = signal(configManager.getConfig());
+        this.themeVersion = signal(0);
+        this.config = this.configSignal.asReadonly();
+        this.tokens = computed(() => {
+            this.themeVersion();
+            try {
+                return themeEngine.getTokens();
+            }
+            catch (e) {
+                return defaultTheme.tokens;
+            }
+        });
+        // Se existir configuração via provider (provideFyLib), aplica imediatamente
+        // ANTES de qualquer outro log para garantir que o estado do logger (enabled/disabled) seja respeitado
+        if (configFromProvider) {
+            configManager.updateConfig(configFromProvider);
+        }
+        logger.info('AngularAdapter', 'FyLibService initialized');
+        // Garante que o tema padrão esteja registrado
+        try {
+            themeEngine.registerTheme(defaultTheme);
+        }
+        catch (e) { }
+        themeEngine.registerPlugin({
+            name: 'config-token-overrides',
+            apply: (tokens) => {
+                const config = this.configSignal();
+                const overrides = config.theme?.tokenOverrides;
+                if (!overrides) {
+                    return tokens;
+                }
+                return this.deepMerge(tokens, overrides);
+            }
+        });
+        // Providers de ícones default
+        try {
+            registerPhosphorProvider();
+        }
+        catch (e) { }
+        try {
+            registerFontAwesomeProvider();
+        }
+        catch (e) { }
+        try {
+            registerMdiProvider();
+        }
+        catch (e) { }
+        // Sincroniza tema se mudou
+        configManager.subscribe(config => {
+            if (!config)
+                return;
+            const oldConfig = this.configSignal();
+            this.configSignal.set(config);
+            const themeName = config.theme?.theme;
+            if (themeName && themeName !== oldConfig.theme?.theme) {
+                try {
+                    this.setTheme(themeName);
+                }
+                catch (e) {
+                    logger.error('Theme', `Erro ao carregar tema: ${themeName}`);
+                }
+            }
+        });
+        if (isPlatformBrowser(this.platformId)) {
+            registerAllEffects();
+            // Regra de precedência: 
+            // 1. Se __FYLIB_DISABLE_CONFIG_POLL__ estiver ativo no window, desabilita.
+            // 2. Se houver configuração vinda do provider (e não for um objeto vazio), 
+            //    o provider "vence" e desabilita o polling automático por padrão.
+            const hasProviderConfig = configFromProvider && Object.keys(configFromProvider).length > 0;
+            const disablePoll = (typeof window !== 'undefined' && window.__FYLIB_DISABLE_CONFIG_POLL__ === true) ||
+                hasProviderConfig;
+            if (!disablePoll) {
+                this.watchConfigFile();
+            }
+            else if (hasProviderConfig) {
+                logger.info('AngularAdapter', 'Polling desabilitado: utilizando configuração estática do provider');
+            }
+        }
+    }
+    async watchConfigFile() {
+        const fetchConfig = async () => {
+            try {
+                const response = await fetch('/fylib/theme-control/theme-controller.json');
+                if (response.ok) {
+                    const newConfig = await response.json();
+                    configManager.updateConfig(newConfig);
+                }
+            }
+            catch (e) {
+                // Arquivo pode não existir ainda
+            }
+        };
+        fetchConfig();
+        setInterval(fetchConfig, 3000); // Polling a cada 3s para exemplo
+    }
+    setTheme(name) {
+        themeEngine.setTheme(name);
+        this.themeVersion.update(v => v + 1);
+    }
+    setMode(mode) {
+        themeEngine.setMode(mode);
+        this.themeVersion.update(v => v + 1);
+    }
+    getMode() {
+        return themeEngine.getMode();
+    }
+    getTokens() {
+        return themeEngine.getTokens();
+    }
+    getThemeBackgroundEffect() {
+        return themeEngine.getBackgroundEffect();
+    }
+    getThemeWallpaper() {
+        return themeEngine.getWallpaper();
+    }
+    triggerEffect(name, params) {
+        animationEngine.triggerEffect(name, params);
+    }
+    triggerEffectForEvent(eventKey, componentSelector, instanceFlag) {
+        const config = this.configSignal();
+        const effectNameFromConfig = config.theme?.effectTriggers?.[eventKey];
+        if (effectNameFromConfig) {
+            this.triggerEffect(effectNameFromConfig);
+        }
+    }
+    playAnimation(name) {
+        animationEngine.playAnimation(name);
+    }
+    isAnimationsEnabledFor(componentSelector) {
+        const config = this.configSignal();
+        if (!config.theme?.animationsEnabled)
+            return false;
+        if (config.theme?.disableAnimationsForComponents?.includes(componentSelector))
+            return false;
+        return true;
+    }
+    isEffectsEnabledFor(componentSelector, instanceFlag) {
+        const config = this.configSignal();
+        if (config.theme?.effectsEnabled === false)
+            return false;
+        if (config.theme?.disableEffectsForComponents?.includes(componentSelector))
+            return false;
+        if (instanceFlag === false)
+            return false;
+        return true;
+    }
+    getComponentAnimation(componentSelector, event) {
+        const config = this.configSignal();
+        const byComponent = config.theme?.componentAnimationsOverrides?.[componentSelector];
+        const override = byComponent ? byComponent[event] : undefined;
+        if (override) {
+            return override;
+        }
+        return themeEngine.getComponentAnimation(componentSelector, event);
+    }
+    deepMerge(target, source) {
+        const output = { ...target };
+        if (this.isObject(target) && this.isObject(source)) {
+            Object.keys(source).forEach(key => {
+                if (this.isObject(source[key])) {
+                    if (!(key in target)) {
+                        Object.assign(output, { [key]: source[key] });
+                    }
+                    else {
+                        output[key] = this.deepMerge(target[key], source[key]);
+                    }
+                }
+                else {
+                    Object.assign(output, { [key]: source[key] });
+                }
+            });
+        }
+        return output;
+    }
+    isObject(item) {
+        return item && typeof item === 'object' && !Array.isArray(item);
+    }
+};
+FyLibService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    }),
+    __param(0, Optional()),
+    __param(0, Inject(FYLIB_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], FyLibService);
+export { FyLibService };

package/dist/services/notification.service.d.ts

@@ -0,0 +1,27 @@
+import { ComponentRef } from '@angular/core';
+import { ToastProps } from '@fylib/catalog';
+import { FyToastComponent } from '../components/toast.component';
+import { NotificationItem } from '@fylib/catalog';
+export interface ToastOptions extends Partial<Omit<ToastProps, 'message'>> {
+    message: string;
+}
+export declare class FyNotificationService {
+    private appRef;
+    private injector;
+    private document;
+    private containerMap;
+    private toasts;
+    private _notifications;
+    readonly notifications: import("@angular/core").Signal<NotificationItem[]>;
+    addNotification(notification: NotificationItem): void;
+    clearNotifications(): void;
+    markAsRead(id: string): void;
+    markAllAsRead(): void;
+    show(options: ToastOptions | string): ComponentRef<FyToastComponent>;
+    success(message: string, title?: string, options?: Partial<ToastOptions>): ComponentRef<FyToastComponent>;
+    error(message: string, title?: string, options?: Partial<ToastOptions>): ComponentRef<FyToastComponent>;
+    warning(message: string, title?: string, options?: Partial<ToastOptions>): ComponentRef<FyToastComponent>;
+    info(message: string, title?: string, options?: Partial<ToastOptions>): ComponentRef<FyToastComponent>;
+    private destroyToast;
+    private getOrCreateContainer;
+}

package/dist/services/notification.service.js

@@ -0,0 +1,118 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable, signal, inject, ApplicationRef, EnvironmentInjector, createComponent } from '@angular/core';
+import { FyToastComponent } from '../components/toast.component';
+import { DOCUMENT } from '@angular/common';
+let FyNotificationService = class FyNotificationService {
+    constructor() {
+        this.appRef = inject(ApplicationRef);
+        this.injector = inject(EnvironmentInjector);
+        this.document = inject(DOCUMENT);
+        this.containerMap = new Map();
+        this.toasts = signal([]);
+        this._notifications = signal([]);
+        this.notifications = this._notifications.asReadonly();
+    }
+    addNotification(notification) {
+        this._notifications.update(current => [notification, ...current]);
+    }
+    clearNotifications() {
+        this._notifications.set([]);
+    }
+    markAsRead(id) {
+        this._notifications.update(current => current.map(n => n.id === id ? { ...n, read: true } : n));
+    }
+    markAllAsRead() {
+        this._notifications.update(current => current.map(n => ({ ...n, read: true })));
+    }
+    show(options) {
+        const props = typeof options === 'string' ? { message: options } : options;
+        const position = props.position || 'top-right';
+        const container = this.getOrCreateContainer(position);
+        // Create component without host element
+        const componentRef = createComponent(FyToastComponent, {
+            environmentInjector: this.injector
+        });
+        // Set inputs
+        Object.assign(componentRef.instance, props);
+        // Handle close
+        const sub = componentRef.instance.fyClose.subscribe(() => {
+            this.destroyToast(componentRef);
+            sub.unsubscribe();
+        });
+        // Manually trigger change detection
+        componentRef.changeDetectorRef.detectChanges();
+        // Attach to appRef so it's part of the Angular component tree
+        this.appRef.attachView(componentRef.hostView);
+        // Append the native element to the container
+        const domElem = componentRef.hostView.rootNodes[0];
+        container.appendChild(domElem);
+        this.toasts.update(current => [...current, componentRef]);
+        return componentRef;
+    }
+    success(message, title, options) {
+        return this.show({ ...options, message, title, type: 'success' });
+    }
+    error(message, title, options) {
+        return this.show({ ...options, message, title, type: 'error' });
+    }
+    warning(message, title, options) {
+        return this.show({ ...options, message, title, type: 'warning' });
+    }
+    info(message, title, options) {
+        return this.show({ ...options, message, title, type: 'info' });
+    }
+    destroyToast(ref) {
+        this.toasts.update(current => current.filter(r => r !== ref));
+        // Remove from DOM manually since we appended it manually
+        const domElem = ref.hostView.rootNodes[0];
+        if (domElem && domElem.parentNode) {
+            domElem.parentNode.removeChild(domElem);
+        }
+        this.appRef.detachView(ref.hostView);
+        ref.destroy();
+    }
+    getOrCreateContainer(position) {
+        if (this.containerMap.has(position)) {
+            return this.containerMap.get(position);
+        }
+        const container = this.document.createElement('div');
+        container.className = `fy-toast-container fy-toast-container--${position}`;
+        // Style the container
+        Object.assign(container.style, {
+            position: 'fixed',
+            zIndex: '9999',
+            display: 'flex',
+            flexDirection: 'column',
+            pointerEvents: 'none',
+            padding: '16px'
+        });
+        // Position styles
+        const [y, x] = position.split('-');
+        if (y === 'top')
+            container.style.top = '0';
+        else
+            container.style.bottom = '0';
+        if (x === 'left')
+            container.style.left = '0';
+        else if (x === 'right')
+            container.style.right = '0';
+        else {
+            container.style.left = '50%';
+            container.style.transform = 'translateX(-50%)';
+        }
+        this.document.body.appendChild(container);
+        this.containerMap.set(position, container);
+        return container;
+    }
+};
+FyNotificationService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    })
+], FyNotificationService);
+export { FyNotificationService };

package/dist/services/sse.service.d.ts

@@ -0,0 +1,16 @@
+import { OnDestroy } from '@angular/core';
+export declare class FySSEService implements OnDestroy {
+    private platformId;
+    private fylib;
+    private notification;
+    private eventSource;
+    private reconnectTimeout;
+    private config;
+    constructor();
+    private initFromConfig;
+    connect(): void;
+    private handleEvent;
+    private reconnect;
+    disconnect(): void;
+    ngOnDestroy(): void;
+}

package/dist/services/sse.service.js

@@ -0,0 +1,109 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable, inject, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { FyLibService } from './fylib.service';
+import { FyNotificationService } from './notification.service';
+import { logger } from '@fylib/logger';
+let FySSEService = class FySSEService {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.fylib = inject(FyLibService);
+        this.notification = inject(FyNotificationService);
+        this.eventSource = null;
+        this.reconnectTimeout = null;
+        this.config = null;
+        if (isPlatformBrowser(this.platformId)) {
+            this.initFromConfig();
+        }
+    }
+    initFromConfig() {
+        const config = this.fylib.config();
+        if (config.sse && config.sse.enabled) {
+            this.config = config.sse;
+            this.connect();
+        }
+    }
+    connect() {
+        if (!this.config || !isPlatformBrowser(this.platformId))
+            return;
+        this.disconnect();
+        try {
+            this.eventSource = new EventSource(this.config.endpoint, {
+                withCredentials: this.config.withCredentials ?? false
+            });
+            this.eventSource.onopen = () => {
+                logger.info('SSE', 'SSE Connected to:', this.config?.endpoint);
+            };
+            this.eventSource.onerror = (error) => {
+                logger.error('SSE', 'SSE Error:', error);
+                this.reconnect();
+            };
+            // Registrar eventos mapeados
+            if (this.config.events) {
+                Object.keys(this.config.events).forEach(eventName => {
+                    this.eventSource?.addEventListener(eventName, (event) => {
+                        try {
+                            const data = JSON.parse(event.data);
+                            this.handleEvent(eventName, data);
+                        }
+                        catch (e) {
+                            this.handleEvent(eventName, event.data);
+                        }
+                    });
+                });
+            }
+        }
+        catch (e) {
+            logger.error('SSE', 'Failed to create EventSource:', e);
+            this.reconnect();
+        }
+    }
+    handleEvent(eventName, data) {
+        if (!this.config?.events || !this.config.events[eventName])
+            return;
+        logger.debug('SSE', `Received event: ${eventName}`, data);
+        // Executa a função mapeada passando os serviços necessários
+        this.config.events[eventName](data, {
+            notification: this.notification,
+            // O menu de notificações será integrado via um serviço de estado global ou via FyNotificationService
+            menu: this.notification
+        });
+    }
+    reconnect() {
+        if (this.reconnectTimeout)
+            clearTimeout(this.reconnectTimeout);
+        const delay = this.config?.reconnectDelay ?? 5000;
+        this.reconnectTimeout = setTimeout(() => {
+            logger.info('SSE', 'SSE Reconnecting...');
+            this.connect();
+        }, delay);
+    }
+    disconnect() {
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+        }
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+    }
+    ngOnDestroy() {
+        this.disconnect();
+    }
+};
+FySSEService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], FySSEService);
+export { FySSEService };

package/dist/services/webclient.service.d.ts

@@ -0,0 +1,38 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+export interface FyHttpRequestOptions {
+    headers?: HttpHeaders | Record<string, string | string[]>;
+    params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    cryptoEnabled?: boolean;
+    autoNotify?: boolean;
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+}
+export declare class FyWebClientService {
+    private http;
+    private fylib;
+    private notify;
+    /**
+     * Realiza uma requisição GET reativa
+     */
+    get<T = any>(url: string, options?: FyHttpRequestOptions): Observable<T>;
+    /**
+     * Realiza uma requisição POST reativa
+     */
+    post<T = any>(url: string, body: any, options?: FyHttpRequestOptions): Observable<T>;
+    /**
+     * Realiza uma requisição PUT reativa
+     */
+    put<T = any>(url: string, body: any, options?: FyHttpRequestOptions): Observable<T>;
+    /**
+     * Realiza uma requisição DELETE reativa
+     */
+    delete<T = any>(url: string, options?: FyHttpRequestOptions): Observable<T>;
+    private buildUrl;
+    private mergeOptions;
+    private processOutgoingData;
+    private processIncomingData;
+    private handleError;
+}