@rainlanguage/ui-components 0.0.1-alpha.16 → 0.0.1-alpha.18

package/dist/components/deployment/DeploymentSteps.svelte

@@ -1,5 +1,5 @@
 <script>import { Alert } from "flowbite-svelte";
-import TokenIOSection from "./TokenIOSection.svelte";
+import TokenIOInput from "./TokenIOInput.svelte";
 import DepositsSection from "./DepositsSection.svelte";
 import ComposedRainlangModal from "./ComposedRainlangModal.svelte";
 import FieldDefinitionsSection from "./FieldDefinitionsSection.svelte";
@@ -47,8 +47,16 @@ onMount(async () => {
 });
 function getAllFieldDefinitions() {
   try {
-    allFieldDefinitionsWithoutDefaults = gui.getAllFieldDefinitions(false);
-    allFieldDefinitionsWithDefaults = gui.getAllFieldDefinitions(true);
+    const allFieldDefinitionsResult = gui.getAllFieldDefinitions(false);
+    if (allFieldDefinitionsResult.error) {
+      throw new Error(allFieldDefinitionsResult.error.msg);
+    }
+    allFieldDefinitionsWithoutDefaults = allFieldDefinitionsResult.value;
+    const allFieldDefinitionsWithDefaultsResult = gui.getAllFieldDefinitions(true);
+    if (allFieldDefinitionsWithDefaultsResult.error) {
+      throw new Error(allFieldDefinitionsWithDefaultsResult.error.msg);
+    }
+    allFieldDefinitionsWithDefaults = allFieldDefinitionsWithDefaultsResult.value;
   } catch (e) {
     DeploymentStepsError.catch(e, DeploymentStepsErrorCode.NO_FIELD_DEFINITIONS);
   }
@@ -240,8 +248,14 @@ const areAllTokensSelected = async () => {
 						<DepositsSection bind:allDepositFields {gui} />
 					{/if}
 
-					{#if allTokenInputs.length > 0 && allTokenOutputs.length > 0 && showAdvancedOptions}
-						<TokenIOSection bind:allTokenInputs bind:allTokenOutputs {gui} />
+					{#if showAdvancedOptions}
+						{#each allTokenInputs as input, i}
+							<TokenIOInput {i} label="Input" vault={input} {gui} />
+						{/each}
+
+						{#each allTokenOutputs as output, i}
+							<TokenIOInput {i} label="Output" vault={output} {gui} />
+						{/each}
 					{/if}
 
 					{#if $deploymentStepsError}

package/dist/components/deployment/DepositInput.svelte

@@ -15,12 +15,20 @@ let tokenInfo = null;
 onMount(() => {
   setCurrentDeposit();
 });
-const setCurrentDeposit = async () => {
+const getCurrentDeposit = () => {
+  const deposits = gui.getDeposits();
+  if (deposits.error) {
+    throw new Error(deposits.error.msg);
+  }
+  return deposits.value.find((d) => d.token === deposit.token?.key);
+};
+const setCurrentDeposit = () => {
   try {
-    currentDeposit = gui.getDeposits().find((d) => d.token === deposit.token?.key);
+    currentDeposit = getCurrentDeposit();
     inputValue = currentDeposit?.amount || "";
-  } catch {
+  } catch (e) {
     currentDeposit = void 0;
+    error = e.message ? e.message : "Error setting current deposit.";
   }
 };
 const getTokenSymbol = async () => {
@@ -41,7 +49,11 @@ function handlePresetClick(preset) {
     inputValue = preset;
     gui?.saveDeposit(deposit.token?.key, preset);
     gui = gui;
-    currentDeposit = gui?.getDeposits().find((d) => d.token === deposit.token?.key);
+    try {
+      currentDeposit = getCurrentDeposit();
+    } catch (e) {
+      error = e.message ? e.message : "Error handling preset click.";
+    }
   }
 }
 function handleInput(e) {
@@ -50,7 +62,11 @@ function handleInput(e) {
       inputValue = e.currentTarget.value;
       gui?.saveDeposit(deposit.token.key, e.currentTarget.value);
       gui = gui;
-      currentDeposit = gui?.getDeposits().find((d) => d.token === deposit.token?.key);
+      try {
+        currentDeposit = getCurrentDeposit();
+      } catch (e2) {
+        error = e2.message ? e2.message : "Error handling input.";
+      }
     }
   }
 }

package/dist/components/deployment/FieldDefinitionInput.svelte

@@ -11,7 +11,11 @@ let currentValue;
 let inputValue = currentValue?.value ? currentValue?.value : fieldDefinition.default || null;
 onMount(() => {
   try {
-    currentValue = gui.getFieldValue(fieldDefinition.binding);
+    const result = gui.getFieldValue(fieldDefinition.binding);
+    if (result.error) {
+      throw new Error(result.error.msg);
+    }
+    currentValue = result.value;
     inputValue = currentValue?.value ? currentValue?.value : fieldDefinition.default || null;
   } catch {
     currentValue = void 0;
@@ -23,7 +27,11 @@ async function handlePresetClick(preset) {
     isPreset: true,
     value: preset.id
   });
-  currentValue = gui.getFieldValue(fieldDefinition.binding);
+  const result = gui.getFieldValue(fieldDefinition.binding);
+  if (result.error) {
+    throw new Error(result.error.msg);
+  }
+  currentValue = result.value;
 }
 async function handleCustomInputChange(value) {
   inputValue = value;
@@ -31,7 +39,11 @@ async function handleCustomInputChange(value) {
     isPreset: false,
     value
   });
-  currentValue = gui.getFieldValue(fieldDefinition.binding);
+  const result = gui.getFieldValue(fieldDefinition.binding);
+  if (result.error) {
+    throw new Error(result.error.msg);
+  }
+  currentValue = result.value;
 }
 </script>
 

package/dist/services/index.d.ts

@@ -1,2 +1,2 @@
-export { fetchParseRegistry, fetchRegistryDotrains } from './registry';
+export { fetchParseRegistry, fetchRegistryDotrains, validateStrategies } from './registry';
 export type { RegistryDotrain, RegistryFile } from './registry';

package/dist/services/index.js

@@ -1 +1 @@
-export { fetchParseRegistry, fetchRegistryDotrains } from './registry';
+export { fetchParseRegistry, fetchRegistryDotrains, validateStrategies } from './registry';

package/dist/services/registry.d.ts

@@ -1,3 +1,4 @@
+import type { InvalidStrategyDetail, ValidStrategyDetail } from '../types/strategy';
 export type RegistryFile = {
     name: string;
     url: string;
@@ -6,6 +7,10 @@ export type RegistryDotrain = {
     name: string;
     dotrain: string;
 };
+export interface StrategyValidationResult {
+    validStrategies: ValidStrategyDetail[];
+    invalidStrategies: InvalidStrategyDetail[];
+}
 /**
  * Fetches and parses a file registry from a given URL.
  * The registry is expected to be a text file where each line contains a file name and URL separated by a space.
@@ -23,3 +28,4 @@ export declare const fetchParseRegistry: (url: string) => Promise<{
     url: string;
 }[]>;
 export declare const fetchRegistryDotrains: (url: string) => Promise<RegistryDotrain[]>;
+export declare function validateStrategies(registryDotrains: RegistryDotrain[]): Promise<StrategyValidationResult>;

package/dist/services/registry.js

@@ -1,3 +1,4 @@
+import { DotrainOrderGui } from '@rainlanguage/orderbook/js_api';
 /**
  * Fetches and parses a file registry from a given URL.
  * The registry is expected to be a text file where each line contains a file name and URL separated by a space.
@@ -52,6 +53,40 @@ export const fetchRegistryDotrains = async (url) => {
     }));
     return dotrains;
 };
+export async function validateStrategies(registryDotrains) {
+    const strategiesPromises = registryDotrains.map(async (registryDotrain) => {
+        try {
+            const result = await DotrainOrderGui.getStrategyDetails(registryDotrain.dotrain);
+            if (result.error) {
+                throw new Error(result.error.msg);
+            }
+            return {
+                valid: true,
+                data: {
+                    ...registryDotrain,
+                    details: result.value
+                }
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                data: {
+                    name: registryDotrain.name,
+                    error: error instanceof Error ? error.message : String(error)
+                }
+            };
+        }
+    });
+    const strategiesResults = await Promise.all(strategiesPromises);
+    const validStrategies = strategiesResults
+        .filter((result) => result.valid)
+        .map((result) => result.data);
+    const invalidStrategies = strategiesResults
+        .filter((result) => !result.valid)
+        .map((result) => result.data);
+    return { validStrategies, invalidStrategies };
+}
 if (import.meta.vitest) {
     const { describe, it, expect, vi } = import.meta.vitest;
     describe('getFileRegistry', () => {
@@ -130,4 +165,125 @@ file2.rain https://example.com/file2.rain`;
             await expect(fetchRegistryDotrains('https://example.com/registry')).rejects.toThrow('Error fetching dotrain for file1.rain: Network error');
         });
     });
+    describe('validateStrategies', async () => {
+        // Mock the DotrainOrderGui dependency
+        vi.mock('@rainlanguage/orderbook/js_api', () => ({
+            DotrainOrderGui: {
+                getStrategyDetails: vi.fn()
+            }
+        }));
+        // Import DotrainOrderGui after mocking
+        const { DotrainOrderGui } = await import('@rainlanguage/orderbook/js_api');
+        beforeEach(() => {
+            vi.resetAllMocks();
+        });
+        it('should validate strategies and categorize them properly', async () => {
+            // Input data
+            const registryDotrains = [
+                { name: 'valid.rain', dotrain: 'valid dotrain content' },
+                { name: 'invalid.rain', dotrain: 'invalid dotrain content' },
+                { name: 'another-valid.rain', dotrain: 'another valid content' }
+            ];
+            // Set up mock responses for the DotrainOrderGui
+            DotrainOrderGui.getStrategyDetails
+                .mockResolvedValueOnce({
+                value: { name: 'Valid Strategy', description: 'A valid strategy' },
+                error: null
+            })
+                .mockResolvedValueOnce({
+                error: { msg: 'Invalid syntax' },
+                value: null
+            })
+                .mockResolvedValueOnce({
+                value: { name: 'Another Valid', description: 'Another valid strategy' },
+                error: null
+            });
+            // Call the function with our test data
+            const result = await validateStrategies(registryDotrains);
+            // Verify DotrainOrderGui was called correctly
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledTimes(3);
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('valid dotrain content');
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('invalid dotrain content');
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('another valid content');
+            // Verify the valid strategies are processed correctly
+            expect(result.validStrategies).toHaveLength(2);
+            expect(result.validStrategies[0].name).toBe('valid.rain');
+            expect(result.validStrategies[0].dotrain).toBe('valid dotrain content');
+            expect(result.validStrategies[0].details).toEqual({
+                name: 'Valid Strategy',
+                description: 'A valid strategy'
+            });
+            // Verify the invalid strategies are processed correctly
+            expect(result.invalidStrategies).toHaveLength(1);
+            expect(result.invalidStrategies[0].name).toBe('invalid.rain');
+            expect(result.invalidStrategies[0].error).toBe('Invalid syntax');
+        });
+        it('should handle exceptions thrown during strategy validation', async () => {
+            // Input data
+            const registryDotrains = [{ name: 'error.rain', dotrain: 'will throw error' }];
+            // Mock the DotrainOrderGui to throw an exception
+            DotrainOrderGui.getStrategyDetails.mockRejectedValueOnce(new Error('Unexpected parsing error'));
+            // Call the function
+            const result = await validateStrategies(registryDotrains);
+            // Verify results
+            expect(result.validStrategies).toHaveLength(0);
+            expect(result.invalidStrategies).toHaveLength(1);
+            expect(result.invalidStrategies[0].name).toBe('error.rain');
+            expect(result.invalidStrategies[0].error).toBe('Unexpected parsing error');
+        });
+        it('should handle non-Error objects being thrown', async () => {
+            // Input data
+            const registryDotrains = [{ name: 'string-error.rain', dotrain: 'will throw string' }];
+            // Mock the DotrainOrderGui to throw a string instead of an Error
+            DotrainOrderGui.getStrategyDetails.mockRejectedValueOnce('String error message');
+            // Call the function
+            const result = await validateStrategies(registryDotrains);
+            // Verify results
+            expect(result.validStrategies).toHaveLength(0);
+            expect(result.invalidStrategies).toHaveLength(1);
+            expect(result.invalidStrategies[0].name).toBe('string-error.rain');
+            expect(result.invalidStrategies[0].error).toBe('String error message');
+        });
+        it('should process an empty array of strategies', async () => {
+            const result = await validateStrategies([]);
+            expect(result.validStrategies).toEqual([]);
+            expect(result.invalidStrategies).toEqual([]);
+            expect(DotrainOrderGui.getStrategyDetails).not.toHaveBeenCalled();
+        });
+        it('should handle mixed validation results correctly', async () => {
+            // Create a mix of scenarios
+            const registryDotrains = [
+                { name: 'valid1.rain', dotrain: 'valid content 1' },
+                { name: 'error.rain', dotrain: 'will throw error' },
+                { name: 'valid2.rain', dotrain: 'valid content 2' },
+                { name: 'invalid.rain', dotrain: 'invalid content' }
+            ];
+            // Set up mock responses
+            DotrainOrderGui.getStrategyDetails
+                .mockResolvedValueOnce({
+                value: { strategyName: 'Strategy 1', description: 'Description 1' },
+                error: null
+            })
+                .mockRejectedValueOnce(new Error('Processing error'))
+                .mockResolvedValueOnce({
+                value: { strategyName: 'Strategy 2', description: 'Description 2' },
+                error: null
+            })
+                .mockResolvedValueOnce({
+                error: { msg: 'Validation failed' },
+                value: null
+            });
+            // Call the function
+            const result = await validateStrategies(registryDotrains);
+            // Verify results
+            expect(result.validStrategies).toHaveLength(2);
+            expect(result.validStrategies[0].name).toBe('valid1.rain');
+            expect(result.validStrategies[1].name).toBe('valid2.rain');
+            expect(result.invalidStrategies).toHaveLength(2);
+            expect(result.invalidStrategies[0].name).toBe('error.rain');
+            expect(result.invalidStrategies[0].error).toBe('Processing error');
+            expect(result.invalidStrategies[1].name).toBe('invalid.rain');
+            expect(result.invalidStrategies[1].error).toBe('Validation failed');
+        });
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rainlanguage/ui-components",
-	"version": "0.0.1-alpha.16",
+	"version": "0.0.1-alpha.18",
 	"description": "A component library for building Svelte applications to be used with Raindex.",
 	"license": "LicenseRef-DCL-1.0",
 	"author": "Rain Open Source Software Ltd",
@@ -53,7 +53,7 @@
 		"@fontsource/dm-sans": "^5.0.18",
 		"@imask/svelte": "^7.3.0",
 		"@observablehq/plot": "^0.6.13",
-		"@rainlanguage/orderbook": "0.0.1-alpha.16",
+		"@rainlanguage/orderbook": "0.0.1-alpha.18",
 		"@reown/appkit": "^1.6.4",
 		"@reown/appkit-adapter-wagmi": "^1.6.4",
 		"@sentry/sveltekit": "^7.107.0",

package/dist/components/deployment/TokenIOSection.svelte

@@ -1,17 +0,0 @@
-<script>import TokenIOInput from "./TokenIOInput.svelte";
-export let allTokenInputs = [];
-export let allTokenOutputs = [];
-export let gui;
-</script>
-
-{#if allTokenInputs.length > 0}
-	{#each allTokenInputs as input, i}
-		<TokenIOInput {i} label="Input" vault={input} {gui} />
-	{/each}
-{/if}
-
-{#if allTokenOutputs.length > 0}
-	{#each allTokenOutputs as output, i}
-		<TokenIOInput {i} label="Output" vault={output} {gui} />
-	{/each}
-{/if}

package/dist/components/deployment/TokenIOSection.svelte.d.ts

@@ -1,21 +0,0 @@
-import { SvelteComponent } from "svelte";
-import type { DotrainOrderGui, OrderIOCfg } from '@rainlanguage/orderbook/js_api';
-declare const __propDef: {
-    props: {
-        allTokenInputs?: OrderIOCfg[];
-        allTokenOutputs?: OrderIOCfg[];
-        gui: DotrainOrderGui;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-    exports?: {} | undefined;
-    bindings?: string | undefined;
-};
-export type TokenIoSectionProps = typeof __propDef.props;
-export type TokenIoSectionEvents = typeof __propDef.events;
-export type TokenIoSectionSlots = typeof __propDef.slots;
-export default class TokenIoSection extends SvelteComponent<TokenIoSectionProps, TokenIoSectionEvents, TokenIoSectionSlots> {
-}
-export {};