@rainlanguage/ui-components 0.0.1-alpha.21 → 0.0.1-alpha.210

package/dist/models/Transaction.js

@@ -0,0 +1,100 @@
+import { waitForTransactionReceipt } from '@wagmi/core';
+import { TransactionStatusMessage, TransactionStoreErrorMessage } from '../types/transaction';
+import { writable } from 'svelte/store';
+/**
+ * Manages the lifecycle of an individual transaction, including waiting for
+ * blockchain confirmation (receipt) and subgraph indexing.
+ * It exposes its state as a Svelte writable store.
+ * @class TransactionStore
+ * @implements {Transaction}
+ */
+export class TransactionStore {
+    name;
+    config;
+    txHash;
+    links;
+    onSuccess;
+    onError;
+    // Optional indexing function called after receipt confirmation.
+    // TransactionStore doesn't know what this function does - it just calls it.
+    awaitIndexingFn;
+    state;
+    /**
+     * Creates a new TransactionStore instance.
+     * @param {TransactionArgs & { config: Config }} args - Configuration arguments for the transaction, including the wagmi `Config`.
+     * @param {() => void} onSuccess - Callback invoked when the transaction successfully completes (including indexing).
+     * @param {() => void} onError - Callback invoked if the transaction fails at any stage.
+     */
+    constructor(args, onSuccess, onError) {
+        this.config = args.config;
+        this.txHash = args.txHash;
+        this.name = args.name;
+        this.links = args.toastLinks;
+        this.state = writable({
+            name: this.name,
+            status: TransactionStatusMessage.IDLE,
+            links: this.links
+        });
+        this.awaitIndexingFn = args.awaitIndexingFn;
+        this.onSuccess = onSuccess;
+        this.onError = onError;
+    }
+    /**
+     * Updates the internal Svelte store with new state values.
+     * @param {Partial<TransactionStoreState>} partialState - An object containing the state properties to update.
+     * @private
+     */
+    updateState(partialState) {
+        this.state.update((currentState) => ({
+            ...currentState,
+            ...partialState
+        }));
+    }
+    /**
+     * Executes the transaction and begins monitoring its status
+     * @returns {Promise<void>}
+     */
+    async execute() {
+        this.updateState({
+            status: TransactionStatusMessage.PENDING_RECEIPT
+        });
+        await this.waitForTxReceipt(this.txHash);
+    }
+    /**
+     * Waits for the transaction receipt to be confirmed on the blockchain.
+     * If an indexing function is provided, it will be called after receipt confirmation.
+     * TransactionStore doesn't know what the indexing function does - it just calls it.
+     * @param {Hex} hash - The transaction hash to monitor
+     * @returns {Promise<void>}
+     * @private
+     */
+    async waitForTxReceipt(hash) {
+        try {
+            await waitForTransactionReceipt(this.config, { hash });
+            if (this.awaitIndexingFn) {
+                // Call the indexing function with the context it needs.
+                // The function handles everything: updating state, calling callbacks, etc.
+                await this.awaitIndexingFn({
+                    updateState: this.updateState.bind(this),
+                    onSuccess: this.onSuccess,
+                    onError: this.onError,
+                    links: this.links
+                });
+            }
+            else {
+                // No indexing needed, mark as success immediately
+                this.updateState({
+                    status: TransactionStatusMessage.SUCCESS
+                });
+                return this.onSuccess();
+            }
+        }
+        catch {
+            this.updateState({
+                status: TransactionStatusMessage.ERROR,
+                errorDetails: TransactionStoreErrorMessage.RECEIPT_FAILED
+            });
+            return this.onError();
+        }
+    }
+}

package/dist/providers/GuiProvider.svelte

@@ -1,5 +1,5 @@
 <script>import { setContext } from "svelte";
-import { DotrainOrderGui } from "@rainlanguage/orderbook/js_api";
+import { DotrainOrderGui } from "@rainlanguage/orderbook";
 import { GUI_CONTEXT_KEY } from "../hooks/useGui";
 export let gui;
 setContext(GUI_CONTEXT_KEY, gui);

package/dist/providers/GuiProvider.svelte.d.ts

@@ -1,5 +1,5 @@
 import { SvelteComponent } from "svelte";
-import { DotrainOrderGui } from '@rainlanguage/orderbook/js_api';
+import { DotrainOrderGui } from '@rainlanguage/orderbook';
 declare const __propDef: {
     props: {
         gui: DotrainOrderGui;

package/dist/providers/LocalDbProvider.svelte

@@ -0,0 +1,8 @@
+<script>import { setContext } from "svelte";
+import { SQLiteWasmDatabase } from "@rainlanguage/sqlite-web";
+import { LOCAL_DB_CONTEXT_KEY } from "../hooks/useLocalDb";
+export let localDb;
+setContext(LOCAL_DB_CONTEXT_KEY, localDb);
+</script>
+
+<slot />

package/dist/providers/LocalDbProvider.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+import { SQLiteWasmDatabase } from '@rainlanguage/sqlite-web';
+declare const __propDef: {
+    props: {
+        localDb: SQLiteWasmDatabase;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type LocalDbProviderProps = typeof __propDef.props;
+export type LocalDbProviderEvents = typeof __propDef.events;
+export type LocalDbProviderSlots = typeof __propDef.slots;
+export default class LocalDbProvider extends SvelteComponent<LocalDbProviderProps, LocalDbProviderEvents, LocalDbProviderSlots> {
+}
+export {};

package/dist/providers/RaindexClientProvider.svelte

@@ -0,0 +1,8 @@
+<script>import { setContext } from "svelte";
+import { RaindexClient } from "@rainlanguage/orderbook";
+import { RAINDEX_CLIENT_CONTEXT_KEY } from "../hooks/useRaindexClient";
+export let raindexClient;
+setContext(RAINDEX_CLIENT_CONTEXT_KEY, raindexClient);
+</script>
+
+<slot />

package/dist/providers/RaindexClientProvider.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+import { RaindexClient } from '@rainlanguage/orderbook';
+declare const __propDef: {
+    props: {
+        raindexClient: RaindexClient;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type RaindexClientProviderProps = typeof __propDef.props;
+export type RaindexClientProviderEvents = typeof __propDef.events;
+export type RaindexClientProviderSlots = typeof __propDef.slots;
+export default class RaindexClientProvider extends SvelteComponent<RaindexClientProviderProps, RaindexClientProviderEvents, RaindexClientProviderSlots> {
+}
+export {};

package/dist/providers/dotrainRegistry/DotrainRegistryProvider.svelte

@@ -0,0 +1,8 @@
+<script>import { setDotrainRegistryContext } from "./context";
+export let registry = null;
+export let error;
+export let manager;
+$: setDotrainRegistryContext({ registry, error, manager });
+</script>
+
+<slot />

package/dist/providers/dotrainRegistry/DotrainRegistryProvider.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponent } from "svelte";
+import type { DotrainRegistry } from '@rainlanguage/orderbook';
+import type { RegistryManager } from '../registry/RegistryManager';
+declare const __propDef: {
+    props: {
+        registry?: DotrainRegistry | null;
+        error: string | undefined;
+        manager: RegistryManager;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type DotrainRegistryProviderProps = typeof __propDef.props;
+export type DotrainRegistryProviderEvents = typeof __propDef.events;
+export type DotrainRegistryProviderSlots = typeof __propDef.slots;
+export default class DotrainRegistryProvider extends SvelteComponent<DotrainRegistryProviderProps, DotrainRegistryProviderEvents, DotrainRegistryProviderSlots> {
+}
+export {};

package/dist/providers/dotrainRegistry/context.d.ts

@@ -0,0 +1,9 @@
+import type { DotrainRegistry } from '@rainlanguage/orderbook';
+import type { RegistryManager } from '../registry/RegistryManager';
+export type DotrainRegistryContext = {
+    registry: DotrainRegistry | null;
+    error?: string;
+    manager: RegistryManager;
+};
+export declare const setDotrainRegistryContext: (context: DotrainRegistryContext) => void;
+export declare const getDotrainRegistryContext: () => DotrainRegistryContext;

package/dist/providers/dotrainRegistry/context.js

@@ -0,0 +1,40 @@
+import { getContext, setContext } from 'svelte';
+const DOTRAIN_REGISTRY_CONTEXT_KEY = 'dotrain-registry-context';
+export const setDotrainRegistryContext = (context) => {
+    setContext(DOTRAIN_REGISTRY_CONTEXT_KEY, context);
+};
+export const getDotrainRegistryContext = () => {
+    const ctx = getContext(DOTRAIN_REGISTRY_CONTEXT_KEY);
+    if (!ctx) {
+        throw new Error('Dotrain registry context not found. Did you forget to wrap your app in DotrainRegistryProvider?');
+    }
+    return ctx;
+};
+if (import.meta.vitest) {
+    const { describe, it, expect, vi, beforeEach } = import.meta.vitest;
+    vi.mock('svelte', async (importOriginal) => ({
+        ...(await importOriginal()),
+        getContext: vi.fn()
+    }));
+    describe('getDotrainRegistryContext', () => {
+        const mockGetContext = vi.mocked(getContext);
+        beforeEach(() => {
+            mockGetContext.mockReset();
+        });
+        it('should return the context when it exists', () => {
+            const mockCtx = { registry: null, manager: {} };
+            mockGetContext.mockImplementation((key) => {
+                if (key === DOTRAIN_REGISTRY_CONTEXT_KEY)
+                    return mockCtx;
+                return undefined;
+            });
+            const result = getDotrainRegistryContext();
+            expect(mockGetContext).toHaveBeenCalledWith(DOTRAIN_REGISTRY_CONTEXT_KEY);
+            expect(result).toEqual(mockCtx);
+        });
+        it('should throw an error when context is not set', () => {
+            mockGetContext.mockReturnValue(undefined);
+            expect(() => getDotrainRegistryContext()).toThrow('Dotrain registry context not found. Did you forget to wrap your app in DotrainRegistryProvider?');
+        });
+    });
+}

package/dist/providers/dotrainRegistry/useDotrainRegistry.d.ts

@@ -0,0 +1,5 @@
+import { type DotrainRegistryContext } from './context';
+/**
+ * Hook to access the current Dotrain registry context.
+ */
+export declare function useDotrainRegistry(): DotrainRegistryContext;

package/dist/providers/dotrainRegistry/useDotrainRegistry.js

@@ -0,0 +1,35 @@
+import { getDotrainRegistryContext } from './context';
+/**
+ * Hook to access the current Dotrain registry context.
+ */
+export function useDotrainRegistry() {
+    return getDotrainRegistryContext();
+}
+if (import.meta.vitest) {
+    const { describe, it, expect, vi, beforeEach } = import.meta.vitest;
+    vi.mock('./context', () => ({
+        getDotrainRegistryContext: vi.fn()
+    }));
+    describe('useDotrainRegistry', () => {
+        const mockGetContext = vi.mocked(getDotrainRegistryContext);
+        beforeEach(() => {
+            mockGetContext.mockReset();
+        });
+        it('should return the registry context', () => {
+            const mockContext = {
+                registry: null,
+                manager: {
+                    getCurrentRegistry: vi.fn().mockReturnValue(''),
+                    setRegistry: vi.fn(),
+                    resetToDefault: vi.fn(),
+                    updateUrlWithRegistry: vi.fn(),
+                    isCustomRegistry: vi.fn().mockReturnValue(false)
+                }
+            };
+            mockGetContext.mockReturnValue(mockContext);
+            const result = useDotrainRegistry();
+            expect(mockGetContext).toHaveBeenCalled();
+            expect(result).toEqual(mockContext);
+        });
+    });
+}

package/dist/providers/registry/RegistryManager.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Manages registry URL settings, persisting values in localStorage and URL parameters
+ */
+export declare class RegistryManager {
+    /** The default registry URL to fall back to */
+    private defaultRegistry;
+    /** The currently selected registry URL */
+    private currentRegistry;
+    /** Key used for localStorage and URL parameters */
+    private static STORAGE_KEY;
+    /**
+     * Create a new RegistryManager
+     * @param defaultRegistry The default registry URL to use.
+     */
+    constructor(defaultRegistry: string);
+    /**
+     * Initialize registry from URL param or local storage
+     * @returns The registry URL to use
+     */
+    private loadRegistryFromStorageOrUrl;
+    /**
+     * Get the registry from the URL param
+     * @returns The registry value from URL or null if not present
+     * @throws Error if URL parsing fails
+     */
+    private getRegistryParamFromUrl;
+    /**
+     * Save the registry to local storage
+     * @param registry The registry URL to save
+     * @throws Error if localStorage is not available
+     */
+    private setRegistryToLocalStorage;
+    /**
+     * Retrieve the registry from local storage
+     * @returns The stored registry URL or null if not found
+     * @throws Error if localStorage is not available
+     */
+    private getRegistryFromLocalStorage;
+    /**
+     * Get the currently active registry
+     * @returns The current registry URL, falling back to default if not set
+     */
+    getCurrentRegistry(): string;
+    /**
+     * Set the registry and update both localStorage and URL
+     * @param registry The new registry URL to set
+     */
+    setRegistry(registry: string): void;
+    /**
+     * Reset to the default registry, clearing both localStorage and URL param
+     * @throws Error if localStorage is not available
+     */
+    resetToDefault(): void;
+    /**
+     * Update the URL param to reflect the current or specified registry
+     * @param value The registry value to set in URL, defaults to current registry
+     * @throws Error if URL manipulation fails
+     */
+    updateUrlWithRegistry(value?: string | null): void;
+    /**
+     * Check if the current registry is custom (different from the default)
+     * @returns True if using a non-default registry
+     */
+    isCustomRegistry(): boolean;
+}

package/dist/providers/registry/RegistryManager.js

@@ -0,0 +1,133 @@
+/**
+ * Manages registry URL settings, persisting values in localStorage and URL parameters
+ */
+export class RegistryManager {
+    /** The default registry URL to fall back to */
+    defaultRegistry;
+    /** The currently selected registry URL */
+    currentRegistry;
+    /** Key used for localStorage and URL parameters */
+    static STORAGE_KEY = 'registry';
+    /**
+     * Create a new RegistryManager
+     * @param defaultRegistry The default registry URL to use.
+     */
+    constructor(defaultRegistry) {
+        this.defaultRegistry = defaultRegistry;
+        this.currentRegistry = this.loadRegistryFromStorageOrUrl();
+    }
+    /**
+     * Initialize registry from URL param or local storage
+     * @returns The registry URL to use
+     */
+    loadRegistryFromStorageOrUrl() {
+        const urlParam = this.getRegistryParamFromUrl();
+        if (urlParam) {
+            this.setRegistryToLocalStorage(urlParam);
+            return urlParam;
+        }
+        return this.getRegistryFromLocalStorage() ?? this.defaultRegistry;
+    }
+    /**
+     * Get the registry from the URL param
+     * @returns The registry value from URL or null if not present
+     * @throws Error if URL parsing fails
+     */
+    getRegistryParamFromUrl() {
+        try {
+            return new URL(window.location.href).searchParams.get(RegistryManager.STORAGE_KEY);
+        }
+        catch (error) {
+            throw new Error('Failed to get registry parameter: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Save the registry to local storage
+     * @param registry The registry URL to save
+     * @throws Error if localStorage is not available
+     */
+    setRegistryToLocalStorage(registry) {
+        try {
+            localStorage.setItem(RegistryManager.STORAGE_KEY, registry);
+        }
+        catch (error) {
+            throw new Error('Failed to save to localStorage: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Retrieve the registry from local storage
+     * @returns The stored registry URL or null if not found
+     * @throws Error if localStorage is not available
+     */
+    getRegistryFromLocalStorage() {
+        try {
+            return localStorage.getItem(RegistryManager.STORAGE_KEY);
+        }
+        catch (error) {
+            throw new Error('Failed to access localStorage: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Get the currently active registry
+     * @returns The current registry URL, falling back to default if not set
+     */
+    getCurrentRegistry() {
+        return this.currentRegistry ?? this.defaultRegistry;
+    }
+    /**
+     * Set the registry and update both localStorage and URL
+     * @param registry The new registry URL to set
+     */
+    setRegistry(registry) {
+        this.currentRegistry = registry;
+        this.setRegistryToLocalStorage(registry);
+        this.updateUrlWithRegistry();
+    }
+    /**
+     * Reset to the default registry, clearing both localStorage and URL param
+     * @throws Error if localStorage is not available
+     */
+    resetToDefault() {
+        this.currentRegistry = this.defaultRegistry;
+        try {
+            localStorage.removeItem(RegistryManager.STORAGE_KEY);
+        }
+        catch (error) {
+            throw new Error('Failed to clear registry from localStorage: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+        this.updateUrlWithRegistry(null);
+    }
+    /**
+     * Update the URL param to reflect the current or specified registry
+     * @param value The registry value to set in URL, defaults to current registry
+     * @throws Error if URL manipulation fails
+     */
+    updateUrlWithRegistry(value = this.currentRegistry) {
+        try {
+            const url = new URL(window.location.href);
+            if (value) {
+                url.searchParams.set(RegistryManager.STORAGE_KEY, value);
+            }
+            else {
+                url.searchParams.delete(RegistryManager.STORAGE_KEY);
+            }
+            window.history.pushState({}, '', url.toString());
+        }
+        catch (error) {
+            throw new Error('Failed to update URL parameter: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Check if the current registry is custom (different from the default)
+     * @returns True if using a non-default registry
+     */
+    isCustomRegistry() {
+        return (this.currentRegistry !== undefined &&
+            this.currentRegistry !== null &&
+            this.currentRegistry !== this.defaultRegistry);
+    }
+}

package/dist/providers/registry/RegistryProvider.svelte

@@ -0,0 +1,6 @@
+<script>import { setRegistryContext } from "./context";
+export let registryManager;
+setRegistryContext(registryManager);
+</script>
+
+<slot />

package/dist/providers/registry/RegistryProvider.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+import type { RegistryManager } from './RegistryManager';
+declare const __propDef: {
+    props: {
+        registryManager: RegistryManager;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type RegistryProviderProps = typeof __propDef.props;
+export type RegistryProviderEvents = typeof __propDef.events;
+export type RegistryProviderSlots = typeof __propDef.slots;
+export default class RegistryProvider extends SvelteComponent<RegistryProviderProps, RegistryProviderEvents, RegistryProviderSlots> {
+}
+export {};

package/dist/providers/registry/context.d.ts

@@ -0,0 +1,10 @@
+import type { RegistryManager } from './RegistryManager';
+export declare const REGISTRY_KEY = "registry_key";
+/**
+ * Retrieves the registry manager directly from Svelte's context
+ */
+export declare const getRegistryContext: () => RegistryManager;
+/**
+ * Sets the registry manager in Svelte's context
+ */
+export declare const setRegistryContext: (registry: RegistryManager) => void;

package/dist/providers/registry/context.js

@@ -0,0 +1,46 @@
+import { getContext, setContext } from 'svelte';
+export const REGISTRY_KEY = 'registry_key';
+/**
+ * Retrieves the registry manager directly from Svelte's context
+ */
+export const getRegistryContext = () => {
+    const registry = getContext(REGISTRY_KEY);
+    if (!registry) {
+        throw new Error('No registry manager was found in Svelte context. Did you forget to wrap your component with RegistryProvider?');
+    }
+    return registry;
+};
+/**
+ * Sets the registry manager in Svelte's context
+ */
+export const setRegistryContext = (registry) => {
+    setContext(REGISTRY_KEY, registry);
+};
+if (import.meta.vitest) {
+    const { describe, it, expect, vi, beforeEach } = import.meta.vitest;
+    vi.mock('svelte', async (importOriginal) => ({
+        ...(await importOriginal()),
+        getContext: vi.fn()
+    }));
+    describe('getRegistryContext', () => {
+        const mockGetContext = vi.mocked(getContext);
+        beforeEach(() => {
+            mockGetContext.mockReset();
+        });
+        it('should return the registry from context when it exists', () => {
+            const mockRegistry = {};
+            mockGetContext.mockImplementation((key) => {
+                if (key === REGISTRY_KEY)
+                    return mockRegistry;
+                return undefined;
+            });
+            const result = getRegistryContext();
+            expect(mockGetContext).toHaveBeenCalledWith(REGISTRY_KEY);
+            expect(result).toEqual(mockRegistry);
+        });
+        it('should throw an error when registry is not in context', () => {
+            mockGetContext.mockReturnValue(undefined);
+            expect(() => getRegistryContext()).toThrow('No registry manager was found in Svelte context. Did you forget to wrap your component with RegistryProvider?');
+        });
+    });
+}

package/dist/providers/registry/useRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { RegistryManager } from './RegistryManager';
+/**
+ * Hook to access registry manager information from context
+ * Must be used within a component that is a child of RegistryProvider
+ * @returns An object containing the registry manager
+ */
+export declare function useRegistry(): RegistryManager;

package/dist/providers/registry/useRegistry.js

@@ -0,0 +1,29 @@
+import { getRegistryContext } from './context';
+/**
+ * Hook to access registry manager information from context
+ * Must be used within a component that is a child of RegistryProvider
+ * @returns An object containing the registry manager
+ */
+export function useRegistry() {
+    const registry = getRegistryContext();
+    return registry;
+}
+if (import.meta.vitest) {
+    const { describe, it, expect, vi, beforeEach } = import.meta.vitest;
+    vi.mock('./context', () => ({
+        getRegistryContext: vi.fn()
+    }));
+    describe('useRegistry', () => {
+        const mockGetRegistryContext = vi.mocked(getRegistryContext);
+        beforeEach(() => {
+            mockGetRegistryContext.mockReset();
+        });
+        it('should return registry', () => {
+            const mockRegistry = {};
+            mockGetRegistryContext.mockReturnValue(mockRegistry);
+            const result = useRegistry();
+            expect(mockGetRegistryContext).toHaveBeenCalled();
+            expect(result).toEqual(mockRegistry);
+        });
+    });
+}

package/dist/providers/toasts/ToastProvider.svelte

@@ -0,0 +1,17 @@
+<script>import ToastDetail from "../../components/ToastDetail.svelte";
+import { setToastsContext } from "./context";
+import { writable } from "svelte/store";
+import { fade } from "svelte/transition";
+const toasts = writable([]);
+setToastsContext(toasts);
+</script>
+
+<div class="fixed right-4 top-4 z-[100]">
+	{#each $toasts as toast, i}
+		<div out:fade data-testid="toast">
+			<ToastDetail {toast} {i} />
+		</div>
+	{/each}
+</div>
+
+<slot />

package/dist/providers/toasts/ToastProvider.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type ToastProviderProps = typeof __propDef.props;
+export type ToastProviderEvents = typeof __propDef.events;
+export type ToastProviderSlots = typeof __propDef.slots;
+export default class ToastProvider extends SvelteComponent<ToastProviderProps, ToastProviderEvents, ToastProviderSlots> {
+}
+export {};