@rainlanguage/ui-components 0.0.1-alpha.226 → 0.0.1-alpha.228

package/dist/__fixtures__/settings.yaml

@@ -93,7 +93,7 @@ orderbooks:
     address: 0x0eA6d458488d1cf51695e1D6e4744e6FB715d37C
     network: ethereum
     subgraph: ethereum
-deployers:
+rainlangs:
   flare:
     address: 0xE3989Ea7486c0F418C764e6c511e86f6E8830FAb
     network: flare

package/dist/components/deployment/DeploymentSteps.svelte

@@ -19,7 +19,7 @@ import DeploymentSectionHeader from "./DeploymentSectionHeader.svelte";
 import { useGui } from "../../hooks/useGui";
 import { fade } from "svelte/transition";
 import ShareChoicesButton from "./ShareChoicesButton.svelte";
-import { useRegistry } from "../../providers/registry/useRegistry";
+import { useRainlang } from "../../providers/rainlang/useRainlang";
 import { useRaindexClient } from "../../hooks/useRaindexClient";
 export let deployment;
 export let orderDetail;
@@ -39,7 +39,7 @@ let selectTokens = void 0;
 let checkingDeployment = false;
 let tokenBalances = /* @__PURE__ */ new Map();
 const gui = useGui();
-const registry = useRegistry();
+const rainlang = useRainlang();
 const raindexClient = useRaindexClient();
 let deploymentStepsError = DeploymentStepsError.error;
 onMount(async () => {
@@ -93,7 +93,7 @@ function updateFields() {
   }
 }
 async function _handleShareChoices() {
-  await handleShareChoices(gui, registry.getCurrentRegistry());
+  await handleShareChoices(gui, rainlang.getCurrentRainlang());
 }
 async function fetchTokenBalance(tokenInfo) {
   if (!$account) return;

package/dist/components/deployment/DeploymentTile.svelte

@@ -4,14 +4,14 @@ export let orderName;
 export let key;
 export let name;
 export let description;
-let customRegistryParam = "";
+let customRainlangParam = "";
 onMount(async () => {
-  customRegistryParam = $page.url.searchParams.get("registry") ? `?registry=${$page.url.searchParams.get("registry")}` : "";
+  customRainlangParam = $page.url.searchParams.get("rainlang") ? `?rainlang=${$page.url.searchParams.get("rainlang")}` : "";
 });
 </script>
 
 <a
-	href={`/deploy/${orderName}/${key}${customRegistryParam}`}
+	href={`/deploy/${orderName}/${key}${customRainlangParam}`}
 	class="flex h-full w-full max-w-sm cursor-pointer flex-col gap-y-4 rounded-3xl border border-gray-200 bg-white p-4 text-left hover:bg-gray-100 dark:border-gray-700 dark:bg-gray-800 dark:hover:bg-gray-700"
 >
 	<h1 class="text-2xl font-semibold text-gray-900 dark:text-white">{name}</h1>

package/dist/components/deployment/InvalidOrdersSection.svelte

@@ -5,7 +5,7 @@
 	class="flex flex-col gap-4 rounded-xl bg-red-100 p-6 dark:bg-red-900"
 	data-testid="invalid-orders"
 >
-	<h2 class="text-xl font-semibold text-gray-900 dark:text-white">Invalid orders in registry</h2>
+	<h2 class="text-xl font-semibold text-gray-900 dark:text-white">Invalid orders in rainlang</h2>
 	<div class="flex flex-col gap-2">
 		{#each ordersWithErrors as order}
 			<div class="flex flex-col gap-1">

package/dist/components/deployment/ValidOrdersSection.svelte

@@ -1,16 +1,16 @@
 <script>import { onMount } from "svelte";
 import { page } from "$app/stores";
 export let orders;
-let customRegistryParam = "";
+let customRainlangParam = "";
 onMount(async () => {
-  customRegistryParam = $page.url.searchParams.get("registry") ? `?registry=${$page.url.searchParams.get("registry")}` : "";
+  customRainlangParam = $page.url.searchParams.get("rainlang") ? `?rainlang=${$page.url.searchParams.get("rainlang")}` : "";
 });
 </script>
 
 <div class="grid grid-cols-1 gap-6 md:grid-cols-2 lg:grid-cols-3" data-testid="valid-orders">
 	{#each orders as order}
 		<a
-			href={`/deploy/${order.name}${customRegistryParam}`}
+			href={`/deploy/${order.name}${customRainlangParam}`}
 			data-testid="order-short-tile"
 			class="flex flex-col gap-y-2 rounded-xl border border-gray-200 p-4 hover:bg-gray-50 dark:border-gray-800 dark:hover:bg-gray-900"
 		>

package/dist/components/input/InputRainlangUrl.svelte

@@ -0,0 +1,40 @@
+<script>import { Button, Input } from "flowbite-svelte";
+import { useRainlang } from "../../providers/rainlang/useRainlang";
+import { loadRainlangUrl } from "../../services/loadRainlangUrl";
+const rainlang = useRainlang();
+let newRainlangUrl = rainlang.getCurrentRainlang();
+let error = null;
+let loading = false;
+async function handleClick() {
+  loading = true;
+  error = null;
+  try {
+    if (!rainlang) {
+      throw new Error("Rainlang manager not yet available.");
+    }
+    await loadRainlangUrl(newRainlangUrl, rainlang);
+  } catch (err) {
+    error = err instanceof Error ? err.message : "Unknown error";
+  }
+  loading = false;
+}
+</script>
+
+<div class="flex w-full flex-col items-end gap-2">
+	<div class="flex w-full items-start gap-4" data-testid="rainlang-input">
+		<Input
+			id="order-url"
+			type="url"
+			placeholder="Enter URL to raw order rainlang file"
+			bind:value={newRainlangUrl}
+		/>
+		<Button class="w-36 text-nowrap" on:click={handleClick} disabled={loading}>
+			{loading ? 'Loading rainlang...' : 'Load rainlang URL'}
+		</Button>
+	</div>
+	<div class="h-4">
+		{#if error}
+			<p data-testid="rainlang-error" class="text-red-500">{error}</p>
+		{/if}
+	</div>
+</div>

package/dist/components/input/InputRainlangUrl.svelte.d.ts

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

package/dist/index.d.ts

@@ -66,7 +66,7 @@ export { default as WalletConnect } from './components/wallet/WalletConnect.svel
 export { default as DisclaimerModal } from './components/deployment/DisclaimerModal.svelte';
 export { default as InvalidOrdersSection } from './components/deployment/InvalidOrdersSection.svelte';
 export { default as ValidOrdersSection } from './components/deployment/ValidOrdersSection.svelte';
-export { default as InputRegistryUrl } from './components/input/InputRegistryUrl.svelte';
+export { default as InputRainlangUrl } from './components/input/InputRainlangUrl.svelte';
 export { default as TransactionList } from './components/transactions/TransactionList.svelte';
 export { default as FixedBottomTransaction } from './components/transactions/FixedBottomTransaction.svelte';
 export { default as LocalDbStatusCard } from './components/LocalDbStatusCard.svelte';
@@ -77,7 +77,7 @@ export { TransactionStatusMessage, TransactionStoreErrorMessage, type Transactio
 export type { VaultActionModalProps, QuoteDebugModalHandler, DebugTradeModalHandler, DisclaimerModalProps, TransactionConfirmationProps, HandleTransactionConfirmationModal } from './types/modal';
 export type { ValidOrderDetail, InvalidOrderDetail } from './types/order.ts';
 export type { ToastProps } from './types/toast';
-export type { DotrainRegistryContext } from './providers/dotrainRegistry/context';
+export type { DotrainRainlangContext } from './providers/dotrainRainlang/context';
 export { createResolvableQuery, createResolvableInfiniteQuery } from './__mocks__/queries';
 export { formatTimestampSecondsAsLocal, timestampSecondsToUTCTimestamp, promiseTimeout } from './services/time';
 export { bigintStringToHex, HEX_INPUT_REGEX } from './utils/hex';
@@ -95,20 +95,20 @@ export { default as logoDark } from './assets/logo-dark.svg';
 export { default as GuiProvider } from './providers/GuiProvider.svelte';
 export { default as RaindexClientProvider } from './providers/RaindexClientProvider.svelte';
 export { default as WalletProvider } from './providers/wallet/WalletProvider.svelte';
-export { default as RegistryProvider } from './providers/registry/RegistryProvider.svelte';
+export { default as RainlangProvider } from './providers/rainlang/RainlangProvider.svelte';
 export { default as ToastProvider } from './providers/toasts/ToastProvider.svelte';
 export { default as TransactionProvider } from './providers/transactions/TransactionProvider.svelte';
 export { default as LocalDbProvider } from './providers/LocalDbProvider.svelte';
-export { default as DotrainRegistryProvider } from './providers/dotrainRegistry/DotrainRegistryProvider.svelte';
+export { default as DotrainRainlangProvider } from './providers/dotrainRainlang/DotrainRainlangProvider.svelte';
 export { useGui } from './hooks/useGui';
 export { useRaindexClient, RAINDEX_CLIENT_CONTEXT_KEY } from './hooks/useRaindexClient';
 export { useLocalDb } from './hooks/useLocalDb';
 export { useAccount } from './providers/wallet/useAccount';
-export { useRegistry } from './providers/registry/useRegistry';
+export { useRainlang } from './providers/rainlang/useRainlang';
 export { useToasts } from './providers/toasts/useToasts';
 export { useTransactions } from './providers/transactions/useTransactions';
-export { useDotrainRegistry } from './providers/dotrainRegistry/useDotrainRegistry';
-export { RegistryManager } from './providers/registry/RegistryManager';
+export { useDotrainRainlang } from './providers/dotrainRainlang/useDotrainRainlang';
+export { RainlangManager } from './providers/rainlang/RainlangManager';
 export { TransactionStore } from './models/Transaction';
 export { TransactionManager } from './providers/transactions/TransactionManager';
 export { mockPageStore } from './__mocks__/stores';

package/dist/index.js

@@ -67,7 +67,7 @@ export { default as WalletConnect } from './components/wallet/WalletConnect.svel
 export { default as DisclaimerModal } from './components/deployment/DisclaimerModal.svelte';
 export { default as InvalidOrdersSection } from './components/deployment/InvalidOrdersSection.svelte';
 export { default as ValidOrdersSection } from './components/deployment/ValidOrdersSection.svelte';
-export { default as InputRegistryUrl } from './components/input/InputRegistryUrl.svelte';
+export { default as InputRainlangUrl } from './components/input/InputRainlangUrl.svelte';
 export { default as TransactionList } from './components/transactions/TransactionList.svelte';
 export { default as FixedBottomTransaction } from './components/transactions/FixedBottomTransaction.svelte';
 export { default as LocalDbStatusCard } from './components/LocalDbStatusCard.svelte';
@@ -96,22 +96,22 @@ export { default as logoDark } from './assets/logo-dark.svg';
 export { default as GuiProvider } from './providers/GuiProvider.svelte';
 export { default as RaindexClientProvider } from './providers/RaindexClientProvider.svelte';
 export { default as WalletProvider } from './providers/wallet/WalletProvider.svelte';
-export { default as RegistryProvider } from './providers/registry/RegistryProvider.svelte';
+export { default as RainlangProvider } from './providers/rainlang/RainlangProvider.svelte';
 export { default as ToastProvider } from './providers/toasts/ToastProvider.svelte';
 export { default as TransactionProvider } from './providers/transactions/TransactionProvider.svelte';
 export { default as LocalDbProvider } from './providers/LocalDbProvider.svelte';
-export { default as DotrainRegistryProvider } from './providers/dotrainRegistry/DotrainRegistryProvider.svelte';
+export { default as DotrainRainlangProvider } from './providers/dotrainRainlang/DotrainRainlangProvider.svelte';
 // Hooks
 export { useGui } from './hooks/useGui';
 export { useRaindexClient, RAINDEX_CLIENT_CONTEXT_KEY } from './hooks/useRaindexClient';
 export { useLocalDb } from './hooks/useLocalDb';
 export { useAccount } from './providers/wallet/useAccount';
-export { useRegistry } from './providers/registry/useRegistry';
+export { useRainlang } from './providers/rainlang/useRainlang';
 export { useToasts } from './providers/toasts/useToasts';
 export { useTransactions } from './providers/transactions/useTransactions';
-export { useDotrainRegistry } from './providers/dotrainRegistry/useDotrainRegistry';
+export { useDotrainRainlang } from './providers/dotrainRainlang/useDotrainRainlang';
 // Classes
-export { RegistryManager } from './providers/registry/RegistryManager';
+export { RainlangManager } from './providers/rainlang/RainlangManager';
 export { TransactionStore } from './models/Transaction';
 export { TransactionManager } from './providers/transactions/TransactionManager';
 // Mocks

package/dist/providers/dotrainRainlang/DotrainRainlangProvider.svelte

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

package/dist/providers/dotrainRainlang/DotrainRainlangProvider.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponent } from "svelte";
+import type { DotrainRainlang } from '@rainlanguage/orderbook';
+import type { RainlangManager } from '../rainlang/RainlangManager';
+declare const __propDef: {
+    props: {
+        rainlang?: DotrainRainlang | null;
+        error: string | undefined;
+        manager: RainlangManager;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type DotrainRainlangProviderProps = typeof __propDef.props;
+export type DotrainRainlangProviderEvents = typeof __propDef.events;
+export type DotrainRainlangProviderSlots = typeof __propDef.slots;
+export default class DotrainRainlangProvider extends SvelteComponent<DotrainRainlangProviderProps, DotrainRainlangProviderEvents, DotrainRainlangProviderSlots> {
+}
+export {};

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

@@ -0,0 +1,9 @@
+import type { DotrainRainlang } from '@rainlanguage/orderbook';
+import type { RainlangManager } from '../rainlang/RainlangManager';
+export type DotrainRainlangContext = {
+    rainlang: DotrainRainlang | null;
+    error?: string;
+    manager: RainlangManager;
+};
+export declare const setDotrainRainlangContext: (context: DotrainRainlangContext) => void;
+export declare const getDotrainRainlangContext: () => DotrainRainlangContext;

package/dist/providers/{dotrainRegistry → dotrainRainlang}/context.js

@@ -1,12 +1,12 @@
 import { getContext, setContext } from 'svelte';
-const DOTRAIN_REGISTRY_CONTEXT_KEY = 'dotrain-registry-context';
-export const setDotrainRegistryContext = (context) => {
-    setContext(DOTRAIN_REGISTRY_CONTEXT_KEY, context);
+const DOTRAIN_RAINLANG_CONTEXT_KEY = 'dotrain-rainlang-context';
+export const setDotrainRainlangContext = (context) => {
+    setContext(DOTRAIN_RAINLANG_CONTEXT_KEY, context);
 };
-export const getDotrainRegistryContext = () => {
-    const ctx = getContext(DOTRAIN_REGISTRY_CONTEXT_KEY);
+export const getDotrainRainlangContext = () => {
+    const ctx = getContext(DOTRAIN_RAINLANG_CONTEXT_KEY);
     if (!ctx) {
-        throw new Error('Dotrain registry context not found. Did you forget to wrap your app in DotrainRegistryProvider?');
+        throw new Error('Dotrain rainlang context not found. Did you forget to wrap your app in DotrainRainlangProvider?');
     }
     return ctx;
 };
@@ -16,25 +16,25 @@ if (import.meta.vitest) {
         ...(await importOriginal()),
         getContext: vi.fn()
     }));
-    describe('getDotrainRegistryContext', () => {
+    describe('getDotrainRainlangContext', () => {
         const mockGetContext = vi.mocked(getContext);
         beforeEach(() => {
             mockGetContext.mockReset();
         });
         it('should return the context when it exists', () => {
-            const mockCtx = { registry: null, manager: {} };
+            const mockCtx = { rainlang: null, manager: {} };
             mockGetContext.mockImplementation((key) => {
-                if (key === DOTRAIN_REGISTRY_CONTEXT_KEY)
+                if (key === DOTRAIN_RAINLANG_CONTEXT_KEY)
                     return mockCtx;
                 return undefined;
             });
-            const result = getDotrainRegistryContext();
-            expect(mockGetContext).toHaveBeenCalledWith(DOTRAIN_REGISTRY_CONTEXT_KEY);
+            const result = getDotrainRainlangContext();
+            expect(mockGetContext).toHaveBeenCalledWith(DOTRAIN_RAINLANG_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?');
+            expect(() => getDotrainRainlangContext()).toThrow('Dotrain rainlang context not found. Did you forget to wrap your app in DotrainRainlangProvider?');
         });
     });
 }

package/dist/providers/dotrainRainlang/useDotrainRainlang.d.ts

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

package/dist/providers/dotrainRainlang/useDotrainRainlang.js

@@ -0,0 +1,35 @@
+import { getDotrainRainlangContext } from './context';
+/**
+ * Hook to access the current Dotrain rainlang context.
+ */
+export function useDotrainRainlang() {
+    return getDotrainRainlangContext();
+}
+if (import.meta.vitest) {
+    const { describe, it, expect, vi, beforeEach } = import.meta.vitest;
+    vi.mock('./context', () => ({
+        getDotrainRainlangContext: vi.fn()
+    }));
+    describe('useDotrainRainlang', () => {
+        const mockGetContext = vi.mocked(getDotrainRainlangContext);
+        beforeEach(() => {
+            mockGetContext.mockReset();
+        });
+        it('should return the rainlang context', () => {
+            const mockContext = {
+                rainlang: null,
+                manager: {
+                    getCurrentRainlang: vi.fn().mockReturnValue(''),
+                    setRainlang: vi.fn(),
+                    resetToDefault: vi.fn(),
+                    updateUrlWithRainlang: vi.fn(),
+                    isCustomRainlang: vi.fn().mockReturnValue(false)
+                }
+            };
+            mockGetContext.mockReturnValue(mockContext);
+            const result = useDotrainRainlang();
+            expect(mockGetContext).toHaveBeenCalled();
+            expect(result).toEqual(mockContext);
+        });
+    });
+}

package/dist/providers/rainlang/RainlangManager.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Manages rainlang URL settings, persisting values in localStorage and URL parameters
+ */
+export declare class RainlangManager {
+    /** The default rainlang URL to fall back to */
+    private defaultRainlang;
+    /** The currently selected rainlang URL */
+    private currentRainlang;
+    /** Key used for localStorage and URL parameters */
+    private static STORAGE_KEY;
+    /**
+     * Create a new RainlangManager
+     * @param defaultRainlang The default rainlang URL to use.
+     */
+    constructor(defaultRainlang: string);
+    /**
+     * Initialize rainlang from URL param or local storage
+     * @returns The rainlang URL to use
+     */
+    private loadRainlangFromStorageOrUrl;
+    /**
+     * Get the rainlang from the URL param
+     * @returns The rainlang value from URL or null if not present
+     * @throws Error if URL parsing fails
+     */
+    private getRainlangParamFromUrl;
+    /**
+     * Save the rainlang to local storage
+     * @param rainlang The rainlang URL to save
+     * @throws Error if localStorage is not available
+     */
+    private setRainlangToLocalStorage;
+    /**
+     * Retrieve the rainlang from local storage
+     * @returns The stored rainlang URL or null if not found
+     * @throws Error if localStorage is not available
+     */
+    private getRainlangFromLocalStorage;
+    /**
+     * Get the currently active rainlang
+     * @returns The current rainlang URL, falling back to default if not set
+     */
+    getCurrentRainlang(): string;
+    /**
+     * Set the rainlang and update both localStorage and URL
+     * @param rainlang The new rainlang URL to set
+     */
+    setRainlang(rainlang: string): void;
+    /**
+     * Reset to the default rainlang, 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 rainlang
+     * @param value The rainlang value to set in URL, defaults to current rainlang
+     * @throws Error if URL manipulation fails
+     */
+    updateUrlWithRainlang(value?: string | null): void;
+    /**
+     * Check if the current rainlang is custom (different from the default)
+     * @returns True if using a non-default rainlang
+     */
+    isCustomRainlang(): boolean;
+}

package/dist/providers/rainlang/RainlangManager.js

@@ -0,0 +1,133 @@
+/**
+ * Manages rainlang URL settings, persisting values in localStorage and URL parameters
+ */
+export class RainlangManager {
+    /** The default rainlang URL to fall back to */
+    defaultRainlang;
+    /** The currently selected rainlang URL */
+    currentRainlang;
+    /** Key used for localStorage and URL parameters */
+    static STORAGE_KEY = 'rainlang';
+    /**
+     * Create a new RainlangManager
+     * @param defaultRainlang The default rainlang URL to use.
+     */
+    constructor(defaultRainlang) {
+        this.defaultRainlang = defaultRainlang;
+        this.currentRainlang = this.loadRainlangFromStorageOrUrl();
+    }
+    /**
+     * Initialize rainlang from URL param or local storage
+     * @returns The rainlang URL to use
+     */
+    loadRainlangFromStorageOrUrl() {
+        const urlParam = this.getRainlangParamFromUrl();
+        if (urlParam) {
+            this.setRainlangToLocalStorage(urlParam);
+            return urlParam;
+        }
+        return this.getRainlangFromLocalStorage() ?? this.defaultRainlang;
+    }
+    /**
+     * Get the rainlang from the URL param
+     * @returns The rainlang value from URL or null if not present
+     * @throws Error if URL parsing fails
+     */
+    getRainlangParamFromUrl() {
+        try {
+            return new URL(window.location.href).searchParams.get(RainlangManager.STORAGE_KEY);
+        }
+        catch (error) {
+            throw new Error('Failed to get rainlang parameter: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Save the rainlang to local storage
+     * @param rainlang The rainlang URL to save
+     * @throws Error if localStorage is not available
+     */
+    setRainlangToLocalStorage(rainlang) {
+        try {
+            localStorage.setItem(RainlangManager.STORAGE_KEY, rainlang);
+        }
+        catch (error) {
+            throw new Error('Failed to save to localStorage: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Retrieve the rainlang from local storage
+     * @returns The stored rainlang URL or null if not found
+     * @throws Error if localStorage is not available
+     */
+    getRainlangFromLocalStorage() {
+        try {
+            return localStorage.getItem(RainlangManager.STORAGE_KEY);
+        }
+        catch (error) {
+            throw new Error('Failed to access localStorage: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Get the currently active rainlang
+     * @returns The current rainlang URL, falling back to default if not set
+     */
+    getCurrentRainlang() {
+        return this.currentRainlang ?? this.defaultRainlang;
+    }
+    /**
+     * Set the rainlang and update both localStorage and URL
+     * @param rainlang The new rainlang URL to set
+     */
+    setRainlang(rainlang) {
+        this.currentRainlang = rainlang;
+        this.setRainlangToLocalStorage(rainlang);
+        this.updateUrlWithRainlang();
+    }
+    /**
+     * Reset to the default rainlang, clearing both localStorage and URL param
+     * @throws Error if localStorage is not available
+     */
+    resetToDefault() {
+        this.currentRainlang = this.defaultRainlang;
+        try {
+            localStorage.removeItem(RainlangManager.STORAGE_KEY);
+        }
+        catch (error) {
+            throw new Error('Failed to clear rainlang from localStorage: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+        this.updateUrlWithRainlang(null);
+    }
+    /**
+     * Update the URL param to reflect the current or specified rainlang
+     * @param value The rainlang value to set in URL, defaults to current rainlang
+     * @throws Error if URL manipulation fails
+     */
+    updateUrlWithRainlang(value = this.currentRainlang) {
+        try {
+            const url = new URL(window.location.href);
+            if (value) {
+                url.searchParams.set(RainlangManager.STORAGE_KEY, value);
+            }
+            else {
+                url.searchParams.delete(RainlangManager.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 rainlang is custom (different from the default)
+     * @returns True if using a non-default rainlang
+     */
+    isCustomRainlang() {
+        return (this.currentRainlang !== undefined &&
+            this.currentRainlang !== null &&
+            this.currentRainlang !== this.defaultRainlang);
+    }
+}

package/dist/providers/rainlang/RainlangProvider.svelte

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

package/dist/providers/rainlang/RainlangProvider.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+import type { RainlangManager } from './RainlangManager';
+declare const __propDef: {
+    props: {
+        rainlangManager: RainlangManager;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type RainlangProviderProps = typeof __propDef.props;
+export type RainlangProviderEvents = typeof __propDef.events;
+export type RainlangProviderSlots = typeof __propDef.slots;
+export default class RainlangProvider extends SvelteComponent<RainlangProviderProps, RainlangProviderEvents, RainlangProviderSlots> {
+}
+export {};

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

@@ -0,0 +1,10 @@
+import type { RainlangManager } from './RainlangManager';
+export declare const RAINLANG_KEY = "rainlang_key";
+/**
+ * Retrieves the rainlang manager directly from Svelte's context
+ */
+export declare const getRainlangContext: () => RainlangManager;
+/**
+ * Sets the rainlang manager in Svelte's context
+ */
+export declare const setRainlangContext: (rainlang: RainlangManager) => void;