@fylib/adapter-angular 0.1.0

package/dist/services/webclient.service.js

@@ -0,0 +1,144 @@
+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, inject } from '@angular/core';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { throwError, from } from 'rxjs';
+import { catchError, retry, timeout, switchMap } from 'rxjs/operators';
+import { FyLibService } from './fylib.service';
+import { FyNotificationService } from './notification.service';
+import { cryptoEngine } from '@fylib/crypto';
+let FyWebClientService = class FyWebClientService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.fylib = inject(FyLibService);
+        this.notify = inject(FyNotificationService);
+    }
+    /**
+     * Realiza uma requisição GET reativa
+     */
+    get(url, options = {}) {
+        const finalUrl = this.buildUrl(url);
+        const finalOptions = this.mergeOptions(options);
+        return this.http.get(finalUrl, {
+            headers: finalOptions.headers,
+            params: finalOptions.params,
+            responseType: finalOptions.responseType
+        }).pipe(timeout(finalOptions.timeout || 10000), retry({
+            count: finalOptions.retries || 0,
+            delay: finalOptions.retryDelay || 1000
+        }), switchMap(data => from(this.processIncomingData(data, finalOptions))), catchError(err => this.handleError(err, finalOptions)));
+    }
+    /**
+     * Realiza uma requisição POST reativa
+     */
+    post(url, body, options = {}) {
+        const finalUrl = this.buildUrl(url);
+        const finalOptions = this.mergeOptions(options);
+        return from(this.processOutgoingData(body, finalOptions)).pipe(switchMap(processedBody => this.http.post(finalUrl, processedBody, {
+            headers: finalOptions.headers,
+            params: finalOptions.params,
+            responseType: finalOptions.responseType
+        })), timeout(finalOptions.timeout || 10000), retry({
+            count: finalOptions.retries || 0,
+            delay: finalOptions.retryDelay || 1000
+        }), switchMap(data => from(this.processIncomingData(data, finalOptions))), catchError(err => this.handleError(err, finalOptions)));
+    }
+    /**
+     * Realiza uma requisição PUT reativa
+     */
+    put(url, body, options = {}) {
+        const finalUrl = this.buildUrl(url);
+        const finalOptions = this.mergeOptions(options);
+        return from(this.processOutgoingData(body, finalOptions)).pipe(switchMap(processedBody => this.http.put(finalUrl, processedBody, {
+            headers: finalOptions.headers,
+            params: finalOptions.params,
+            responseType: finalOptions.responseType
+        })), timeout(finalOptions.timeout || 10000), switchMap(data => from(this.processIncomingData(data, finalOptions))), catchError(err => this.handleError(err, finalOptions)));
+    }
+    /**
+     * Realiza uma requisição DELETE reativa
+     */
+    delete(url, options = {}) {
+        const finalUrl = this.buildUrl(url);
+        const finalOptions = this.mergeOptions(options);
+        return this.http.delete(finalUrl, {
+            headers: finalOptions.headers,
+            params: finalOptions.params,
+            responseType: finalOptions.responseType
+        }).pipe(timeout(finalOptions.timeout || 10000), switchMap(data => from(this.processIncomingData(data, finalOptions))), catchError(err => this.handleError(err, finalOptions)));
+    }
+    // --- Métodos Privados Auxiliares ---
+    buildUrl(url) {
+        const baseUrl = this.fylib.config().http?.baseUrl;
+        if (baseUrl && !url.startsWith('http')) {
+            return `${baseUrl.replace(/\/$/, '')}/${url.replace(/^\//, '')}`;
+        }
+        return url;
+    }
+    mergeOptions(options) {
+        const globalHttp = this.fylib.config().http || {};
+        return {
+            timeout: options.timeout ?? globalHttp.timeout ?? 15000,
+            retries: options.retries ?? globalHttp.retries ?? 0,
+            retryDelay: options.retryDelay ?? globalHttp.retryDelay ?? 1000,
+            cryptoEnabled: options.cryptoEnabled ?? globalHttp.cryptoEnabled ?? true,
+            autoNotify: options.autoNotify ?? globalHttp.autoNotify ?? true,
+            headers: {
+                ...globalHttp.headers,
+                ...options.headers
+            },
+            ...options
+        };
+    }
+    async processOutgoingData(body, options) {
+        const cryptoCfg = this.fylib.config().crypto;
+        if (options.cryptoEnabled && cryptoCfg?.enabled && body) {
+            const jsonStr = typeof body === 'string' ? body : JSON.stringify(body);
+            const encrypted = await cryptoEngine.encrypt(jsonStr, cryptoCfg);
+            return { payload: encrypted, encrypted: true };
+        }
+        return body;
+    }
+    async processIncomingData(data, options) {
+        const cryptoCfg = this.fylib.config().crypto;
+        let result = data;
+        // Se vier embrulhado em { payload: '...' } ou for uma string criptografada
+        if (options.cryptoEnabled && cryptoCfg?.enabled) {
+            const encryptedPayload = data?.payload || (typeof data === 'string' ? data : null);
+            if (encryptedPayload) {
+                try {
+                    const decrypted = await cryptoEngine.decrypt(encryptedPayload, cryptoCfg);
+                    result = JSON.parse(decrypted);
+                }
+                catch (e) {
+                    console.error('[fyLib WebClient] Erro ao descriptografar resposta:', e);
+                }
+            }
+        }
+        if (options.autoNotify) {
+            this.notify.success('Dados carregados com sucesso', 'WebClient');
+        }
+        return result;
+    }
+    handleError(error, options) {
+        let errorMessage = 'Ocorreu um erro na requisição';
+        if (error instanceof HttpErrorResponse) {
+            errorMessage = `Erro ${error.status}: ${error.statusText || error.message}`;
+        }
+        else {
+            errorMessage = error.message;
+        }
+        if (options.autoNotify) {
+            this.notify.error(errorMessage, 'Erro de Conexão');
+        }
+        return throwError(() => error);
+    }
+};
+FyWebClientService = __decorate([
+    Injectable({ providedIn: 'root' })
+], FyWebClientService);
+export { FyWebClientService };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@fylib/adapter-angular",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run --passWithNoTests"
+  },
+  "peerDependencies": {
+    "@angular/common": "catalog:",
+    "@angular/core": "catalog:",
+    "chart.js": "catalog:",
+    "ng2-charts": "catalog:",
+    "rxjs": "catalog:"
+  },
+  "dependencies": {
+    "@fylib/core": "workspace:*",
+    "@fylib/theme": "workspace:*",
+    "@fylib/animation": "workspace:*",
+    "@fylib/catalog": "workspace:*",
+    "@fylib/config": "workspace:*",
+    "@fylib/crypto": "workspace:*",
+    "@fylib/logger": "workspace:*",
+    "chart.js": "catalog:",
+    "ng2-charts": "catalog:",
+    "rxjs": "catalog:",
+    "tslib": "catalog:"
+  },
+  "devDependencies": {
+    "typescript": "catalog:",
+    "@angular/common": "catalog:",
+    "@angular/core": "catalog:",
+    "@angular/compiler": "catalog:",
+    "@types/node": "catalog:"
+  }
+}