@smess/networking 1.0.15 → 1.0.18

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export * from "./services/user.service";
 export * from "./services/product.service";
 export * from "./services/auth.service";
 export * from "./services/store.service";
+export * from "./services/store.cart.service";
+export * from "./services/store.product.service";
 export * from "./services/customer.service";
 export * from "./services/order.service";
 export * from "./services/cache.service";

package/dist/index.js

@@ -2,6 +2,8 @@ export * from "./services/user.service";
 export * from "./services/product.service";
 export * from "./services/auth.service";
 export * from "./services/store.service";
+export * from "./services/store.cart.service";
+export * from "./services/store.product.service";
 export * from "./services/customer.service";
 export * from "./services/order.service";
 export * from "./services/cache.service";

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

@@ -4,6 +4,7 @@ import { BehaviorSubject, Observable } from "rxjs";
 export interface AuthLoginRequest {
     identifier: string;
     password: string;
+    rememberMe?: boolean;
 }
 export interface ForgotPasswordRequest {
     identifier: string;
@@ -45,9 +46,15 @@ export interface AuthServiceType {
 }
 export declare class AuthService implements AuthServiceType {
     private readonly config;
-    readonly $authToken: BehaviorSubject<string | null>;
+    private readonly $_authToken;
     constructor(config: NetworkingConfig);
+    get $authToken(): BehaviorSubject<string | null>;
     get currentAuthToken(): string | null;
+    private getValidToken;
+    private loadFromStorage;
+    private loadAuthFromStorage;
+    private saveAuthToStorage;
+    private clearAuthFromStorage;
     provider(target: AuthTarget): SmessService<AuthProvider>;
     login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
     logout(): Observable<NetworkingUIEventWrapped<void>>;

package/dist/services/auth.service.js

@@ -1,6 +1,9 @@
 import { Accept, SMESSHeader, SmessService } from "./smess.service";
 import { BehaviorSubject } from "rxjs";
 import { tap } from "rxjs/operators";
+// LocalStorage keys for auth persistence
+const AUTH_TOKEN_KEY = 'smess_auth_token';
+const AUTH_RESPONSE_KEY = 'smess_auth_response';
 export class AuthProvider {
     constructor(config, target, $authToken) {
         this.config = config;
@@ -68,11 +71,88 @@ export class AuthProvider {
 export class AuthService {
     constructor(config) {
         this.config = config;
-        this.$authToken = new BehaviorSubject(null);
+        this.$_authToken = new BehaviorSubject(null);
+        this.loadAuthFromStorage();
+    }
+    // Getter that returns BehaviorSubject with token validation
+    get $authToken() {
+        const currentToken = this.getValidToken();
+        if (currentToken !== this.$_authToken.value) {
+            this.$_authToken.next(currentToken);
+        }
+        return this.$_authToken;
     }
     // Get current auth token value
     get currentAuthToken() {
-        return this.$authToken.value;
+        return this.getValidToken();
+    }
+    // Get valid token from memory or localStorage
+    getValidToken() {
+        // If we have a token in memory, return it (assume it's valid)
+        if (this.$_authToken.value) {
+            return this.$_authToken.value;
+        }
+        // Otherwise, try to load from localStorage
+        return this.loadFromStorage();
+    }
+    // Load token from localStorage and check expiration
+    loadFromStorage() {
+        try {
+            const storedResponse = localStorage.getItem(AUTH_RESPONSE_KEY);
+            const storedAt = localStorage.getItem(`${AUTH_RESPONSE_KEY}_stored_at`);
+            if (storedResponse && storedAt) {
+                const authResponse = JSON.parse(storedResponse);
+                const storedTime = parseInt(storedAt, 10);
+                // Check if token is expired
+                if (authResponse.expires_in && typeof authResponse.expires_in === 'number') {
+                    const expirationTime = storedTime + (authResponse.expires_in * 1000);
+                    if (Date.now() >= expirationTime) {
+                        // Token expired, clear storage
+                        this.clearAuthFromStorage();
+                        return null;
+                    }
+                }
+                // Token is valid, store in memory and return
+                const token = String(authResponse.token);
+                this.$_authToken.next(token);
+                return token;
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load token from localStorage:', error);
+            this.clearAuthFromStorage();
+        }
+        return null;
+    }
+    // Load auth token from localStorage on initialization
+    loadAuthFromStorage() {
+        this.loadFromStorage();
+    }
+    // Save auth response to localStorage
+    saveAuthToStorage(authResponse) {
+        try {
+            localStorage.setItem(AUTH_TOKEN_KEY, String(authResponse.token));
+            localStorage.setItem(AUTH_RESPONSE_KEY, JSON.stringify(authResponse));
+            localStorage.setItem(`${AUTH_RESPONSE_KEY}_stored_at`, Date.now().toString());
+            // Update memory
+            this.$_authToken.next(String(authResponse.token));
+        }
+        catch (error) {
+            console.warn('Failed to save auth to localStorage:', error);
+        }
+    }
+    // Clear auth from localStorage
+    clearAuthFromStorage() {
+        try {
+            localStorage.removeItem(AUTH_TOKEN_KEY);
+            localStorage.removeItem(AUTH_RESPONSE_KEY);
+            localStorage.removeItem(`${AUTH_RESPONSE_KEY}_stored_at`);
+            // Clear memory
+            this.$_authToken.next(null);
+        }
+        catch (error) {
+            console.warn('Failed to clear auth from localStorage:', error);
+        }
     }
     provider(target) {
         const targetWrapper = new AuthProvider(this.config, target, this.$authToken);
@@ -84,7 +164,11 @@ export class AuthService {
             .pipe(tap((result) => {
             if (result.hasSuccess && result.response?.token) {
                 // Set the auth token when login is successful
-                this.$authToken.next(String(result.response.token));
+                this.$_authToken.next(String(result.response.token));
+                // Save to localStorage if rememberMe is true
+                if (payload.rememberMe && result.response) {
+                    this.saveAuthToStorage(result.response);
+                }
             }
         }));
     }
@@ -93,8 +177,8 @@ export class AuthService {
             .request()
             .pipe(tap((result) => {
             if (result.hasSuccess) {
-                // Clear the auth token when logout is successful
-                this.$authToken.next(null);
+                // Clear from localStorage (this will also clear memory)
+                this.clearAuthFromStorage();
             }
         }));
     }

package/dist/services/auth.service.test.js

@@ -1,3 +1,6 @@
+/**
+ * @jest-environment jsdom
+ */
 import { AuthService, } from "./auth.service";
 import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
 import { of } from "rxjs";
@@ -9,7 +12,18 @@ describe("AuthService", () => {
         apiKey: "test-api-key",
     };
     let service;
+    let mockLocalStorage;
     beforeEach(() => {
+        // Mock localStorage for all tests
+        mockLocalStorage = {
+            setItem: jest.fn(),
+            getItem: jest.fn(),
+            removeItem: jest.fn(),
+        };
+        Object.defineProperty(window, 'localStorage', {
+            value: mockLocalStorage,
+            writable: true,
+        });
         service = new AuthService(config);
     });
     it("login success", async () => {
@@ -39,6 +53,55 @@ describe("AuthService", () => {
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
+    it("login success with rememberMe", async () => {
+        const payload = {
+            identifier: "user",
+            password: "pass",
+            rememberMe: true
+        };
+        const response = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "token",
+            refresh_token: "refresh",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.login(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+        // Verify that auth token is set after successful login
+        expect(service.currentAuthToken).toBe("token");
+        expect(service.$authToken.value).toBe("token");
+        // Verify that localStorage was called to save the auth data
+        expect(mockLocalStorage.setItem).toHaveBeenCalledWith('smess_auth_token', 'token');
+        expect(mockLocalStorage.setItem).toHaveBeenCalledWith('smess_auth_response', JSON.stringify(response));
+    });
+    it("login success without rememberMe", async () => {
+        const payload = {
+            identifier: "user",
+            password: "pass",
+            rememberMe: false
+        };
+        const response = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "token",
+            refresh_token: "refresh",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.login(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+        // Verify that auth token is set after successful login
+        expect(service.currentAuthToken).toBe("token");
+        expect(service.$authToken.value).toBe("token");
+        // Verify that localStorage was NOT called to save the auth data
+        expect(mockLocalStorage.setItem).not.toHaveBeenCalled();
+    });
     it("logout success", async () => {
         // First set a token to test clearing it
         service.$authToken.next("test-token");
@@ -51,6 +114,132 @@ describe("AuthService", () => {
         // Verify that auth token is cleared after successful logout
         expect(service.currentAuthToken).toBe(null);
         expect(service.$authToken.value).toBe(null);
+        // Verify that localStorage was cleared
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_token');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_response');
+    });
+    it("loads auth token from localStorage on initialization", () => {
+        // Mock localStorage to return a stored auth response
+        const storedResponse = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "stored-token",
+            refresh_token: "refresh",
+        };
+        const mockLocalStorage = {
+            setItem: jest.fn(),
+            getItem: jest.fn().mockImplementation((key) => {
+                if (key === 'smess_auth_response') {
+                    return JSON.stringify(storedResponse);
+                }
+                if (key === 'smess_auth_response_stored_at') {
+                    return Date.now().toString();
+                }
+                return null;
+            }),
+            removeItem: jest.fn(),
+        };
+        Object.defineProperty(window, 'localStorage', {
+            value: mockLocalStorage,
+            writable: true,
+        });
+        // Create a new service instance
+        const newService = new AuthService(config);
+        // Verify that the stored token was loaded
+        expect(newService.currentAuthToken).toBe('stored-token');
+        expect(newService.$authToken.value).toBe('stored-token');
+        expect(mockLocalStorage.getItem).toHaveBeenCalledWith('smess_auth_response');
+    });
+    it("handles localStorage errors gracefully", () => {
+        // Mock localStorage to throw an error
+        const mockLocalStorage = {
+            setItem: jest.fn().mockImplementation(() => {
+                throw new Error('localStorage error');
+            }),
+            getItem: jest.fn().mockImplementation(() => {
+                throw new Error('localStorage error');
+            }),
+            removeItem: jest.fn().mockImplementation(() => {
+                throw new Error('localStorage error');
+            }),
+        };
+        Object.defineProperty(window, 'localStorage', {
+            value: mockLocalStorage,
+            writable: true,
+        });
+        // Should not throw an error during initialization
+        expect(() => new AuthService(config)).not.toThrow();
+        // Should not throw an error during login with rememberMe
+        const service = new AuthService(config);
+        const payload = {
+            identifier: "user",
+            password: "pass",
+            rememberMe: true
+        };
+        const response = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "token",
+            refresh_token: "refresh",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        expect(async () => {
+            await service.login(payload).toPromise();
+        }).not.toThrow();
+    });
+    it("handles expired token from localStorage", () => {
+        // Mock localStorage with expired token
+        const expiredResponse = {
+            token_type: "Bearer",
+            expires_in: 1, // 1 second
+            token: "expired-token",
+            refresh_token: "refresh",
+        };
+        mockLocalStorage.getItem.mockImplementation((key) => {
+            if (key === 'smess_auth_response') {
+                return JSON.stringify(expiredResponse);
+            }
+            if (key === 'smess_auth_response_stored_at') {
+                // Set stored time to 2 seconds ago (expired)
+                return (Date.now() - 2000).toString();
+            }
+            return null;
+        });
+        // Create a new service instance
+        const newService = new AuthService(config);
+        // Verify that expired token is not returned
+        expect(newService.currentAuthToken).toBe(null);
+        expect(newService.$authToken.value).toBe(null);
+        // Verify that localStorage was cleared
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_token');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_response');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_response_stored_at');
+    });
+    it("handles valid token from localStorage", () => {
+        // Mock localStorage with valid token
+        const validResponse = {
+            token_type: "Bearer",
+            expires_in: 3600, // 1 hour
+            token: "valid-token",
+            refresh_token: "refresh",
+        };
+        mockLocalStorage.getItem.mockImplementation((key) => {
+            if (key === 'smess_auth_response') {
+                return JSON.stringify(validResponse);
+            }
+            if (key === 'smess_auth_response_stored_at') {
+                // Set stored time to 30 minutes ago (still valid)
+                return (Date.now() - 1800000).toString();
+            }
+            return null;
+        });
+        // Create a new service instance
+        const newService = new AuthService(config);
+        // Verify that valid token is returned
+        expect(newService.currentAuthToken).toBe("valid-token");
+        expect(newService.$authToken.value).toBe("valid-token");
     });
     it("forgotPassword success", async () => {
         const payload = { identifier: "user" };

package/dist/services/store.cart.service.d.ts

@@ -0,0 +1,139 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StoreCartTarget = "cart-get" | "cart-update" | "cart-add-item" | "cart-update-item" | "cart-delete-item" | "cart-delete-all-items";
+export interface BillingInformation {
+    email?: string;
+    phone_number?: string;
+    street?: string;
+    city?: string;
+    postal_code?: string;
+    state?: string;
+    country?: string;
+    [key: string]: unknown;
+}
+export interface ShippingInformation {
+    email?: string;
+    phone_number?: string;
+    street?: string;
+    city?: string;
+    postal_code?: string;
+    state?: string;
+    country?: string;
+    [key: string]: unknown;
+}
+export interface CartItem {
+    [key: string]: unknown;
+}
+export interface StoreInfo {
+    [key: string]: unknown;
+}
+export interface Cart {
+    dateCreated: string;
+    dateModified: string;
+    discountTotal: number;
+    discountTax: number;
+    shippingTotal: number;
+    shippingTax: number;
+    cartTax: number;
+    total: number;
+    totalTax: number;
+    customerId: string | null;
+    billingInformation: BillingInformation | null;
+    shippingInformation: ShippingInformation | null;
+    paymentMethod: string;
+    deliveryType: string;
+    transactionId: string | null;
+    customerIpAddress: string;
+    customerUserAgent: string;
+    customerNote: string | null;
+    cartHash: string;
+    cartItems: CartItem[];
+    paymentUrl: string | null;
+    store: StoreInfo | null;
+    [key: string]: unknown;
+}
+export interface CartUpdateRequest {
+    status?: string;
+    customer_note?: string;
+    customer_id?: string;
+    payment_method?: string;
+    delivery_type?: string;
+    billing_information?: BillingInformation;
+    shipping_information?: ShippingInformation;
+    [key: string]: unknown;
+}
+export interface CartAddItemRequest {
+    product_id: string;
+    quantity: number;
+    [key: string]: unknown;
+}
+export interface CartUpdateItemQuantityRequest {
+    quantity: number;
+}
+export declare class StoreCartProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $cartHash;
+    private readonly $storeId;
+    constructor(config: NetworkingConfig, target: StoreCartTarget, $cartHash: BehaviorSubject<string | null>, $storeId: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface StoreCartServiceType {
+    getCart(): Observable<NetworkingUIEventWrapped<Cart>>;
+    updateCart(payload: CartUpdateRequest): Observable<NetworkingUIEventWrapped<Cart>>;
+    addItem(payload: CartAddItemRequest): Observable<NetworkingUIEventWrapped<Cart>>;
+    updateItemQuantity(itemId: string, payload: CartUpdateItemQuantityRequest): Observable<NetworkingUIEventWrapped<Cart>>;
+    deleteItem(itemId: string): Observable<NetworkingUIEventWrapped<void>>;
+    deleteAllItems(): Observable<NetworkingUIEventWrapped<void>>;
+}
+export declare class StoreCartService implements StoreCartServiceType {
+    private readonly config;
+    private readonly $cartHash;
+    private readonly $storeId;
+    constructor(config: NetworkingConfig, $storeId?: BehaviorSubject<string | null>);
+    get currentCartHash(): string | null;
+    get cartHash$(): BehaviorSubject<string | null>;
+    get currentStoreId(): string | null;
+    get storeId$(): BehaviorSubject<string | null>;
+    setStoreId(storeId: string | null): void;
+    provider(target: StoreCartTarget): SmessService<StoreCartProvider>;
+    /**
+     * Update the cart hash from cart response
+     */
+    private updateCartHash;
+    /**
+     * Get the current cart
+     * GET api/v1/store/cart
+     */
+    getCart(): Observable<NetworkingUIEventWrapped<Cart>>;
+    /**
+     * Update cart (e.g., add notes, apply coupon)
+     * PUT api/v1/store/cart
+     */
+    updateCart(payload: CartUpdateRequest): Observable<NetworkingUIEventWrapped<Cart>>;
+    /**
+     * Add item to cart
+     * POST api/v1/store/cart/items
+     */
+    addItem(payload: CartAddItemRequest): Observable<NetworkingUIEventWrapped<Cart>>;
+    /**
+     * Update item quantity in cart
+     * PUT api/v1/store/cart/items/{id}
+     */
+    updateItemQuantity(itemId: string, payload: CartUpdateItemQuantityRequest): Observable<NetworkingUIEventWrapped<Cart>>;
+    /**
+     * Delete item from cart
+     * DELETE api/v1/store/cart/items/{id}
+     */
+    deleteItem(itemId: string): Observable<NetworkingUIEventWrapped<void>>;
+    /**
+     * Delete all items from cart
+     * DELETE api/v1/store/cart/items
+     */
+    deleteAllItems(): Observable<NetworkingUIEventWrapped<void>>;
+}

package/dist/services/store.cart.service.js

@@ -0,0 +1,166 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { BehaviorSubject } from "rxjs";
+import { tap } from "rxjs/operators";
+export class StoreCartProvider {
+    constructor(config, target, $cartHash, $storeId) {
+        this.config = config;
+        this.target = target;
+        this.$cartHash = $cartHash;
+        this.$storeId = $storeId;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "cart-get":
+                return "/store/cart";
+            case "cart-update":
+                return "/store/cart";
+            case "cart-add-item":
+                return "/store/cart/items";
+            case "cart-update-item":
+                return "/store/cart/items/\${id}";
+            case "cart-delete-item":
+                return "/store/cart/items/\${id}";
+            case "cart-delete-all-items":
+                return "/store/cart/items";
+            default:
+                return "/store/cart";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "cart-get":
+                return "GET";
+            case "cart-update":
+                return "PUT";
+            case "cart-add-item":
+                return "POST";
+            case "cart-update-item":
+                return "PUT";
+            case "cart-delete-item":
+                return "DELETE";
+            case "cart-delete-all-items":
+                return "DELETE";
+            default:
+                return "GET";
+        }
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, null);
+        if (this.config.clientId) {
+            headers[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        const filteredHeaders = SmessService.filterHeaders(headers);
+        // Add X-Nonce-Token header if cartHash is available
+        if (this.$cartHash.value) {
+            filteredHeaders["X-Nonce-Token"] = this.$cartHash.value;
+        }
+        // Add X-Store-Id header if storeId is available
+        if (this.$storeId.value) {
+            filteredHeaders["X-Store-Id"] = this.$storeId.value;
+        }
+        return filteredHeaders;
+    }
+    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 StoreCartService {
+    constructor(config, $storeId) {
+        this.config = config;
+        this.$cartHash = new BehaviorSubject(null);
+        // Use the provided BehaviorSubject or create a new one
+        this.$storeId = $storeId || new BehaviorSubject(null);
+    }
+    // Getter to access the current cart hash
+    get currentCartHash() {
+        return this.$cartHash.value;
+    }
+    // Getter to access the cart hash as observable
+    get cartHash$() {
+        return this.$cartHash;
+    }
+    // Getter to access the current store ID
+    get currentStoreId() {
+        return this.$storeId.value;
+    }
+    // Getter to access the store ID as observable
+    get storeId$() {
+        return this.$storeId;
+    }
+    // Method to update the store ID
+    setStoreId(storeId) {
+        this.$storeId.next(storeId);
+    }
+    provider(target) {
+        const targetWrapper = new StoreCartProvider(this.config, target, this.$cartHash, this.$storeId);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * Update the cart hash from cart response
+     */
+    updateCartHash(result) {
+        if (result.hasSuccess && result.response) {
+            const response = result.response;
+            // Try to extract cartHash from different possible structures
+            const cartHash = response.data?.cartHash || response.cartHash;
+            if (cartHash) {
+                this.$cartHash.next(cartHash);
+            }
+        }
+    }
+    /**
+     * Get the current cart
+     * GET api/v1/store/cart
+     */
+    getCart() {
+        return this.provider("cart-get").request().pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Update cart (e.g., add notes, apply coupon)
+     * PUT api/v1/store/cart
+     */
+    updateCart(payload) {
+        return this.provider("cart-update").request(payload).pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Add item to cart
+     * POST api/v1/store/cart/items
+     */
+    addItem(payload) {
+        return this.provider("cart-add-item").request(payload).pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Update item quantity in cart
+     * PUT api/v1/store/cart/items/{id}
+     */
+    updateItemQuantity(itemId, payload) {
+        return this.provider("cart-update-item").request(payload, undefined, itemId).pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Delete item from cart
+     * DELETE api/v1/store/cart/items/{id}
+     */
+    deleteItem(itemId) {
+        return this.provider("cart-delete-item").request(undefined, undefined, itemId);
+    }
+    /**
+     * Delete all items from cart
+     * DELETE api/v1/store/cart/items
+     */
+    deleteAllItems() {
+        return this.provider("cart-delete-all-items").request();
+    }
+}

package/dist/services/store.cart.service.test.d.ts

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