@smess/networking 1.0.24 → 1.0.26

package/dist/src/services/order.service.js

@@ -1,97 +0,0 @@
-import { Accept, SMESSHeader, SmessService } from "./smess.service";
-export class OrderProvider {
-    constructor(config, target, $authToken) {
-        this.config = config;
-        this.target = target;
-        this.$authToken = $authToken;
-    }
-    get baseURL() {
-        return this.config.version
-            ? `${this.config.baseUrl}/${this.config.version}`
-            : this.config.baseUrl;
-    }
-    get path() {
-        switch (this.target) {
-            case "order-list":
-                return "/order/list";
-            case "order-create":
-                return "/order/create";
-            case "order-delete":
-                return "/order/${id}";
-            case "order-get-draft":
-                return "/order/get-draft";
-            case "order-collection":
-                return "/order/collection";
-            case "order-update":
-            case "order-get":
-            default:
-                return "/order/${id}";
-        }
-    }
-    get method() {
-        switch (this.target) {
-            case "order-list":
-            case "order-get":
-            case "order-get-draft":
-            case "order-collection":
-                return "GET";
-            case "order-create":
-                return "POST";
-            case "order-update":
-                return "PUT";
-            case "order-delete":
-                return "DELETE";
-            default:
-                return "GET";
-        }
-    }
-    get headers() {
-        let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
-        if (this.config.clientId) {
-            headers[SMESSHeader.ClientId] = this.config.clientId;
-        }
-        if (this.config.apiKey) {
-            headers[SMESSHeader.ApiKey] = this.config.apiKey;
-        }
-        return SmessService.filterHeaders(headers);
-    }
-    getPath(...queryParams) {
-        let definedPath = this.path;
-        const params = definedPath.match(/\$\{(.+?)\}/g);
-        params?.forEach((value, index) => {
-            definedPath = definedPath.replace(value, String(queryParams[index]));
-        });
-        return definedPath;
-    }
-}
-export class OrderService {
-    constructor(config, $authToken) {
-        this.config = config;
-        this.$authToken = $authToken;
-    }
-    provider(target) {
-        const targetWrapper = new OrderProvider(this.config, target, this.$authToken);
-        return new SmessService(targetWrapper);
-    }
-    list() {
-        return this.provider("order-list").request();
-    }
-    create(payload) {
-        return this.provider("order-create").request(payload);
-    }
-    delete(id) {
-        return this.provider("order-delete").request(null, undefined, id);
-    }
-    getDraft() {
-        return this.provider("order-get-draft").request();
-    }
-    update(id, payload) {
-        return this.provider("order-update").request(payload, undefined, id);
-    }
-    get(id) {
-        return this.provider("order-get").request(null, undefined, id);
-    }
-    collection(payload) {
-        return this.provider("order-collection").request(payload, undefined, undefined);
-    }
-}

package/dist/src/services/order.service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/services/order.service.test.js

@@ -1,163 +0,0 @@
-import { OrderService, } from "./order.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { of, BehaviorSubject } from "rxjs";
-describe("OrderService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        isProd: false,
-        clientId: "test-client-id",
-        apiKey: "test-api-key",
-    };
-    let service;
-    let $authToken;
-    beforeEach(() => {
-        $authToken = new BehaviorSubject(null);
-        service = new OrderService(config, $authToken);
-    });
-    it("list success", async () => {
-        const response = { data: [{ id: "1", status: "draft" }] };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.list().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("list error", async () => {
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.list().toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("create success", async () => {
-        const payload = {
-            order_date: "2024-01-01",
-            order_items: [],
-        };
-        const response = { data: { id: "1", status: "created" } };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.create(payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("create error", async () => {
-        const payload = {
-            order_date: "2024-01-01",
-            order_items: [],
-        };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.create(payload).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("delete success", async () => {
-        const response = { data: { id: "1", status: "deleted" } };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.delete("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("delete error", async () => {
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.delete("1").toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("getDraft success", async () => {
-        const response = { data: { id: "draft", status: "draft" } };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.getDraft().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("getDraft error", async () => {
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.getDraft().toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("update success", async () => {
-        const payload = {
-            order_date: "2024-01-01",
-            order_items: [],
-        };
-        const response = { data: { id: "1", status: "updated" } };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.update("1", payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("update error", async () => {
-        const payload = {
-            order_date: "2024-01-01",
-            order_items: [],
-        };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.update("1", payload).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("get success", async () => {
-        const response = { data: { id: "1", status: "fetched" } };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.get("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("get error", async () => {
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.get("1").toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("collection success", async () => {
-        const payload = {
-            page: 1,
-            per_page: 10,
-            search: "test order",
-            status: "pending",
-            payment_status: "paid",
-        };
-        const response = { data: { orders: [], total: 0 } };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.collection(payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("collection error", async () => {
-        const payload = {
-            page: 1,
-            per_page: 10,
-        };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.collection(payload).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-});

package/dist/src/services/product.service.d.ts

@@ -1,21 +0,0 @@
-import { BaseProvider } from "../core/base.provider";
-import { BaseServiceWrapper } from "../core/base.service.wrapper";
-import { NetworkingConfig } from "../types/types";
-export interface Product {
-    id: number;
-    name: string;
-    price: number;
-}
-export declare class ProductProvider extends BaseProvider {
-    constructor(config: NetworkingConfig, { productId, method }?: {
-        productId?: number;
-        method?: string;
-    });
-}
-export declare class ProductService extends BaseServiceWrapper<ProductProvider> {
-    private config;
-    constructor(config: NetworkingConfig, productId?: number, method?: string);
-    fetchProductById(id: number): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
-    fetchAllProducts(): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product[]>>;
-    createProduct(product: Omit<Product, "id">): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
-}

package/dist/src/services/product.service.js

@@ -1,42 +0,0 @@
-import { BaseProvider } from "../core/base.provider";
-import { BaseServiceWrapper } from "../core/base.service.wrapper";
-// ProductProvider implements ProviderType for product endpoints
-export class ProductProvider extends BaseProvider {
-    constructor(config, { productId, method } = {}) {
-        super({
-            config,
-            path: productId ? `/products/${productId}` : "/products",
-            method: method || "GET",
-            headers: { "Content-Type": "application/json" },
-            getPath: () => (productId ? `/products/${productId}` : "/products"),
-        });
-    }
-}
-// ProductService provides high-level methods for product API
-export class ProductService extends BaseServiceWrapper {
-    constructor(config, productId, method) {
-        super(new ProductProvider(config, { productId, method }));
-        this.config = config;
-    }
-    // Fetch a product by ID
-    fetchProductById(id) {
-        this.provider = new ProductProvider(this.config, { productId: id });
-        return this.request();
-    }
-    // Fetch all products
-    fetchAllProducts() {
-        this.provider = new ProductProvider(this.config);
-        return this.request();
-    }
-    // Create a new product (POST)
-    createProduct(product) {
-        this.provider = new ProductProvider(this.config, { method: "POST" });
-        return this.request(product);
-    }
-}
-// Example usage:
-// setNetworkingConfig({ baseUrl: 'https://fakestoreapi.com', isProd: false });
-// const productService = new ProductService();
-// productService.fetchProductById(1).subscribe(result => console.log(result));
-// productService.fetchAllProducts().subscribe(result => console.log(result));
-// productService.createProduct({ name: 'New Product', price: 99.99 }).subscribe(result => console.log(result));

package/dist/src/services/product.service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/services/product.service.test.js

@@ -1,61 +0,0 @@
-import { ProductService } from "./product.service";
-import { NetworkingUIEventWrapped } from "../types/types";
-import { of, throwError } from "rxjs";
-import { BaseServiceWrapper } from "../core/base.service.wrapper";
-describe("ProductService", () => {
-    const config = {
-        baseUrl: "https://jsonplaceholder.typicode.com",
-        isProd: false,
-        clientId: "test-client",
-        apiKey: "test-key",
-    };
-    const product = { id: 1, name: "Product", price: 10 };
-    let requestSpy;
-    beforeEach(() => {
-        requestSpy = jest
-            .spyOn(BaseServiceWrapper.prototype, "request")
-            .mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(product)));
-    });
-    afterEach(() => {
-        requestSpy.mockRestore();
-    });
-    it("should fetch product by id", (done) => {
-        const service = new ProductService(config, 1);
-        service
-            .fetchProductById(1)
-            .subscribe((result) => {
-            expect(result.response).toEqual(product);
-            done();
-        });
-    });
-    it("should fetch all products", (done) => {
-        const service = new ProductService(config);
-        service
-            .fetchAllProducts()
-            .subscribe((result) => {
-            expect(result.response).toEqual(product);
-            done();
-        });
-    });
-    it("should create a product", (done) => {
-        const service = new ProductService(config);
-        service
-            .createProduct({ name: "New Product", price: 99.99 })
-            .subscribe((result) => {
-            expect(result.response).toEqual(product);
-            done();
-        });
-    });
-    it("request should handle error", (done) => {
-        requestSpy.mockImplementationOnce(() => throwError(() => new Error("Test error")));
-        const service = new ProductService(config);
-        // Simulate error by calling a method that uses request
-        service.fetchProductById(1).subscribe({
-            error: (err) => {
-                expect(err).toBeInstanceOf(Error);
-                expect(err.message).toBe("Test error");
-                done();
-            },
-        });
-    });
-});

package/dist/src/services/smess.service.d.ts

@@ -1,36 +0,0 @@
-import { HeaderType, NetworkingUIEventWrapped, ProviderType } from "../types/types";
-import { Observable } from "../utils/rxjs-import";
-export declare enum SMESSHeader {
-    ContentType = "Content-Type",
-    Authorization = "Authorization",
-    Accept = "Accept",
-    ApiKey = "X-Api-Key",
-    ClientId = "X-Client-Id"
-}
-export declare enum ContentType {
-    Json = "application/json",
-    FormURLEncoded = "application/x-www-form-urlencoded"
-}
-export declare enum Accept {
-    V1 = "application/json",
-    V2 = "application/vnd.smess.v2+json",
-    V3 = "application/vnd.smess.v3+json",
-    V4 = "application/vnd.smess.v4+json",
-    V5 = "application/vnd.smess.v5+json",
-    V6 = "application/vnd.smess.v6+json",
-    V7 = "application/vnd.smess.v7+json",
-    V8 = "application/vnd.smess.v8+json",
-    V9 = "application/vnd.smess.v9+json",
-    V10 = "application/vnd.smess.v10+json"
-}
-export declare class SmessService<T extends ProviderType> {
-    private httpService;
-    private target;
-    constructor(target: T);
-    static getHeaders(version: Accept, authorization?: string | null, options?: HeaderType): Partial<Record<SMESSHeader, string | undefined>>;
-    static filterHeaders(headers: Partial<Record<SMESSHeader, string | undefined>>): Record<string, string>;
-    private static commonHeaders;
-    request<R = unknown>(request?: unknown, mockResponse?: R, ...queryParams: unknown[]): Observable<NetworkingUIEventWrapped<R>>;
-    private transformAxiosError;
-    private transformAxiosResponse;
-}

package/dist/src/services/smess.service.js

@@ -1,128 +0,0 @@
-import { AlertButtonModel, AlertModel, NetworkingUIEventWrapped, } from "../types/types";
-import { catchError, mergeMap, of, startWith, } from "../utils/rxjs-import";
-import HttpService from "../core/rx.http.service";
-import { $logger } from "../services/logger.service";
-export var SMESSHeader;
-(function (SMESSHeader) {
-    SMESSHeader["ContentType"] = "Content-Type";
-    SMESSHeader["Authorization"] = "Authorization";
-    SMESSHeader["Accept"] = "Accept";
-    SMESSHeader["ApiKey"] = "X-Api-Key";
-    SMESSHeader["ClientId"] = "X-Client-Id";
-})(SMESSHeader || (SMESSHeader = {}));
-export var ContentType;
-(function (ContentType) {
-    ContentType["Json"] = "application/json";
-    ContentType["FormURLEncoded"] = "application/x-www-form-urlencoded";
-})(ContentType || (ContentType = {}));
-export var Accept;
-(function (Accept) {
-    Accept["V1"] = "application/json";
-    Accept["V2"] = "application/vnd.smess.v2+json";
-    Accept["V3"] = "application/vnd.smess.v3+json";
-    Accept["V4"] = "application/vnd.smess.v4+json";
-    Accept["V5"] = "application/vnd.smess.v5+json";
-    Accept["V6"] = "application/vnd.smess.v6+json";
-    Accept["V7"] = "application/vnd.smess.v7+json";
-    Accept["V8"] = "application/vnd.smess.v8+json";
-    Accept["V9"] = "application/vnd.smess.v9+json";
-    Accept["V10"] = "application/vnd.smess.v10+json";
-})(Accept || (Accept = {}));
-export class SmessService {
-    constructor(target) {
-        this.target = target;
-        // Set default headers
-        $logger.info("SmessService initialized", {
-            target: this.target,
-            baseURL: this.target.baseURL,
-            method: this.target.method,
-            headers: this.target.headers,
-        }, "SmessService");
-        this.httpService = HttpService.create({
-            baseURL: this.target.baseURL,
-            headers: this.target.headers,
-            method: this.target.method,
-        });
-        this.httpService.interceptors.response.use((response) => response, async (error) => {
-            const originalRequest = error.config;
-            if (error.response?.status === 401 && !originalRequest._retry) {
-                originalRequest._retry = true;
-                $logger.info("SmessService constructor - 401 retry", originalRequest, "SmessService");
-                // Implement token refresh logic here
-                // Then retry the original request
-                // return httpService.request(originalRequest);
-            }
-            return Promise.reject(error);
-        });
-    }
-    static getHeaders(version, authorization = null, options) {
-        const headers = this.commonHeaders(version, options);
-        if (authorization) {
-            headers["Authorization"] = 'Bearer ' + authorization;
-        }
-        return headers;
-    }
-    static filterHeaders(headers) {
-        const filteredHeaders = Object.fromEntries(Object.entries(headers).filter(([_, value]) => value !== undefined && value !== null && value !== ""));
-        return filteredHeaders;
-    }
-    static commonHeaders(version, options) {
-        const { shouldAddClientIdHeader = true } = options ?? {};
-        const headers = {
-            Accept: version,
-            Authorization: "",
-            "Content-Type": ContentType.Json,
-            "X-Api-Key": "",
-        };
-        return headers;
-    }
-    // MARK: - Public
-    request(request, mockResponse, ...queryParams) {
-        const url = queryParams.length
-            ? this.target.getPath(...queryParams)
-            : this.target.path;
-        const config = { url };
-        let observable;
-        if (this.target.method === "GET") {
-            if (request) {
-                config.data = request;
-                config.params = request;
-            }
-            observable = this.httpService.get(url, config);
-        }
-        else if (this.target.method === "POST") {
-            observable = this.httpService.post(url, request, config);
-        }
-        else if (this.target.method === "PATCH") {
-            observable = this.httpService.patch(url, request, config);
-        }
-        else if (this.target.method === "PUT") {
-            observable = this.httpService.put(url, request, config);
-        }
-        else {
-            observable = this.httpService.request(config);
-        }
-        return observable.pipe(catchError((error) => this.transformAxiosError(error, mockResponse)), mergeMap((data) => this.transformAxiosResponse(data)), startWith(NetworkingUIEventWrapped.waiting()));
-    }
-    // MARK: - Private
-    transformAxiosError(error, mockResponse) {
-        $logger.error("transformAxiosError", error, "SmessService");
-        const message = error instanceof Error ? error.message : String(error);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for axios compatibility
-        const response = error.response;
-        const httpErrorCode = response ? response.status : 0;
-        const title = response?.statusText;
-        const alertModel = new AlertModel(message, httpErrorCode, true, title, response?.data, [AlertButtonModel.buttonYes()]);
-        if (mockResponse) {
-            return of(NetworkingUIEventWrapped.succeeded(mockResponse));
-        }
-        return of(NetworkingUIEventWrapped.failed(alertModel));
-    }
-    transformAxiosResponse(response) {
-        $logger.info("transformAxiosResponse", response, "SmessService");
-        if (response instanceof NetworkingUIEventWrapped) {
-            return of(response);
-        }
-        return of(NetworkingUIEventWrapped.succeeded(response.data));
-    }
-}

package/dist/src/services/smess.service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/services/smess.service.test.js

@@ -1,103 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any -- Required for test mocks */
-import { SmessService } from "./smess.service";
-import { NetworkingUIEventWrapped, } from "../types/types";
-import { of, throwError } from "rxjs";
-describe("SmessService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        isProd: false,
-        clientId: "test-client",
-        apiKey: "test-key",
-    };
-    const provider = {
-        baseURL: config.baseUrl,
-        path: "/resource",
-        method: "GET",
-        headers: {},
-        getPath: () => "/resource",
-    };
-    it("should return succeeded for GET", (done) => {
-        const service = new SmessService(provider);
-        service["httpService"] = {
-            get: jest.fn(() => of({ data: { foo: "bar" } })),
-            post: jest.fn(),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn(),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service.request().subscribe((result) => {
-            if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: "bar" });
-                done();
-            }
-        });
-    });
-    it("should return succeeded for POST", (done) => {
-        const postProvider = { ...provider, method: "POST" };
-        const service = new SmessService(postProvider);
-        service["httpService"] = {
-            get: jest.fn(),
-            post: jest.fn(() => of({ data: { foo: "baz" } })),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn(),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service
-            .request({ some: "data" })
-            .subscribe((result) => {
-            if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: "baz" });
-                done();
-            }
-        });
-    });
-    it("should handle error", (done) => {
-        const service = new SmessService(provider);
-        service["httpService"] = {
-            get: jest.fn(() => throwError(() => new Error("Test error"))),
-            post: jest.fn(),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn(),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service.request().subscribe((result) => {
-            if (result.hasFailed) {
-                expect(result).toBeInstanceOf(NetworkingUIEventWrapped);
-                expect(result.hasFailed).toBe(true);
-                expect(result.alertModel).toBeTruthy();
-                expect(result.alertModel?.message).toBe("Test error");
-                done();
-            }
-        });
-    });
-    it("should return mock response if provided", (done) => {
-        const service = new SmessService(provider);
-        service["httpService"] = {
-            get: jest.fn(() => throwError(() => new Error("Test error"))),
-            post: jest.fn(),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn((payload, mockResponse) => {
-                if (payload === "error") {
-                    return throwError(() => new Error("Test error"));
-                }
-                if (mockResponse !== undefined) {
-                    return of(NetworkingUIEventWrapped.succeeded(mockResponse));
-                }
-                return of({ data: { foo: "mock" } });
-            }),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service
-            .request(undefined, { foo: "mock" })
-            .subscribe((result) => {
-            if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: "mock" });
-                done();
-            }
-        });
-    });
-});