@rainlanguage/ui-components 0.0.1-alpha.13 → 0.0.1-alpha.131

package/dist/services/time.js

@@ -1,3 +1,10 @@
+import dayjs from 'dayjs';
+import bigIntSupport from 'dayjs/plugin/bigIntSupport';
+import localizedFormat from 'dayjs/plugin/localizedFormat';
+import utc from 'dayjs/plugin/utc';
+dayjs.extend(bigIntSupport);
+dayjs.extend(localizedFormat);
+dayjs.extend(utc);
 export const TIME_DELTA_24_HOURS = 60 * 60 * 24;
 export const TIME_DELTA_48_HOURS = TIME_DELTA_24_HOURS * 2;
 export const TIME_DELTA_7_DAYS = TIME_DELTA_24_HOURS * 7;
@@ -6,12 +13,87 @@ export const TIME_DELTA_1_YEAR = TIME_DELTA_24_HOURS * 365;
 export function dateTimestamp(date) {
     return Math.floor(date.getTime() / 1000);
 }
+export function formatTimestampSecondsAsLocal(timestampSeconds) {
+    return dayjs(timestampSeconds * BigInt('1000'))
+        .utc()
+        .format('L LT');
+}
+export function timestampSecondsToUTCTimestamp(timestampSeconds) {
+    return dayjs(timestampSeconds * BigInt('1000')).unix();
+}
+/**
+ * Method to put a timeout on a promise, throws the exception if promise is not settled within the time
+ * @param promise - The original promise
+ * @param time - The time in ms
+ * @param exception - The exception to reject with if time runs out before original promise settlement
+ * @returns A new promise that gets settled with initial promise settlement or rejected with exception value
+ * if the time runs out before the main promise settlement
+ */
+export async function promiseTimeout(promise, time, exception) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let timeout;
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => (timeout = setTimeout(reject, time, exception)))
+    ]).finally(() => clearTimeout(timeout));
+}
 if (import.meta.vitest) {
-    const { it, expect } = import.meta.vitest;
-    it('should get date timestamp in seconds', () => {
-        const date = new Date(2022, 1, 16, 17, 32, 11, 168);
-        const result = dateTimestamp(date);
-        const expected = Math.floor(date.getTime() / 1000);
-        expect(result).toEqual(expected);
+    const { describe, it, expect, vi } = import.meta.vitest;
+    describe('Date and timestamp utilities', () => {
+        describe('formatTimestampSecondsAsLocal', () => {
+            it('converts timestamp to local format', () => {
+                const result = formatTimestampSecondsAsLocal(BigInt('1672531200')); // Jan 1, 2023 12:00 AM
+                expect(result).toBe('01/01/2023 12:00 AM');
+            });
+        });
+        describe('timestampSecondsToUTCTimestamp', () => {
+            it('converts bigint timestamp to UTCTimestamp', () => {
+                const result = timestampSecondsToUTCTimestamp(BigInt('1672531200'));
+                expect(result).toBe(1672531200);
+            });
+        });
+    });
+    describe('promiseTimeout', () => {
+        it('resolves when promise resolves before timeout', async () => {
+            const testValue = 'test';
+            const promise = Promise.resolve(testValue);
+            const result = await promiseTimeout(promise, 100, new Error('Timeout'));
+            expect(result).toBe(testValue);
+        });
+        it('rejects when promise times out', async () => {
+            const promise = new Promise((resolve) => setTimeout(resolve, 200));
+            const exception = new Error('Timeout');
+            await expect(promiseTimeout(promise, 100, exception)).rejects.toThrow(exception);
+        });
+        it('rejects when original promise rejects', async () => {
+            const error = new Error('Original rejection');
+            const promise = Promise.reject(error);
+            await expect(promiseTimeout(promise, 100, new Error('Timeout'))).rejects.toThrow(error);
+        });
+        it('clears timeout after promise resolution', async () => {
+            vi.spyOn(global, 'clearTimeout');
+            const promise = Promise.resolve('test');
+            await promiseTimeout(promise, 100, new Error('Timeout'));
+            expect(clearTimeout).toHaveBeenCalled();
+        });
+        it('clears timeout after promise rejection', async () => {
+            vi.spyOn(global, 'clearTimeout');
+            const promise = Promise.reject(new Error('Original rejection'));
+            try {
+                await promiseTimeout(promise, 100, new Error('Timeout'));
+            }
+            catch {
+                // Ignore the error
+            }
+            expect(clearTimeout).toHaveBeenCalled();
+        });
+    });
+    describe('dateTimestamp', () => {
+        it('should get date timestamp in seconds', () => {
+            const date = new Date(2022, 1, 16, 17, 32, 11, 168);
+            const result = dateTimestamp(date);
+            const expected = Math.floor(date.getTime() / 1000);
+            expect(result).toEqual(expected);
+        });
     });
 }

package/dist/storesGeneric/cachedWritableStore.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Creates a writable Svelte store that persists its value to localStorage.
+ *
+ * @template T - The type of the value stored in the store
+ * @param {string} key - The localStorage key used to store the value
+ * @param {T} defaultValue - The default value to use when no value is found in localStorage
+ * @param {function(T): string} serialize - Function to convert the store value to a string for storage
+ * @param {function(string): T} deserialize - Function to convert the stored string back to the original type
+ * @returns {import('svelte/store').Writable<T>} A writable store that automatically syncs with localStorage
+ *
+ * @example
+ * // Create a store for a boolean value
+ * const darkMode = cachedWritableStore(
+ *   'darkMode',
+ *   false,
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ *
+ * // Create a store for a complex object
+ * const userPreferences = cachedWritableStore(
+ *   'userPrefs',
+ *   { theme: 'light', fontSize: 14 },
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ */
+export declare function cachedWritableStore<T>(key: string, defaultValue: T, serialize: (value: T) => string, deserialize: (serialized: string) => T): import("svelte/store").Writable<T>;
+export declare const cachedWritableString: (key: string, defaultValue?: string) => import("svelte/store").Writable<string>;
+export declare const cachedWritableInt: (key: string, defaultValue?: number) => import("svelte/store").Writable<number>;
+/**
+ * Creates a writable store that can hold an optional value of type T and persists to localStorage.
+ *
+ * @template T - The type of the value stored
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {T | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @param {function} serialize - Function to convert the value to a string for storage
+ * @param {function} deserialize - Function to convert the stored string back to a value
+ * @returns A writable store that persists to localStorage and can hold undefined values
+ */
+export declare const cachedWritableOptionalStore: <T>(key: string, defaultValue: T | undefined, serialize: (value: T) => string, deserialize: (serialized: string) => T) => import("svelte/store").Writable<T | undefined>;
+/**
+ * Creates a writable store that can hold an optional number value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {number | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional number
+ */
+export declare const cachedWritableIntOptional: (key: string, defaultValue?: undefined) => import("svelte/store").Writable<number | undefined>;
+/**
+ * Creates a writable store that can hold an optional string value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {string | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional string
+ */
+export declare const cachedWritableStringOptional: (key: string, defaultValue?: undefined) => import("svelte/store").Writable<string | undefined>;

package/dist/storesGeneric/cachedWritableStore.js

@@ -0,0 +1,93 @@
+import { writable } from 'svelte/store';
+/**
+ * Creates a writable Svelte store that persists its value to localStorage.
+ *
+ * @template T - The type of the value stored in the store
+ * @param {string} key - The localStorage key used to store the value
+ * @param {T} defaultValue - The default value to use when no value is found in localStorage
+ * @param {function(T): string} serialize - Function to convert the store value to a string for storage
+ * @param {function(string): T} deserialize - Function to convert the stored string back to the original type
+ * @returns {import('svelte/store').Writable<T>} A writable store that automatically syncs with localStorage
+ *
+ * @example
+ * // Create a store for a boolean value
+ * const darkMode = cachedWritableStore(
+ *   'darkMode',
+ *   false,
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ *
+ * // Create a store for a complex object
+ * const userPreferences = cachedWritableStore(
+ *   'userPrefs',
+ *   { theme: 'light', fontSize: 14 },
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ */
+export function cachedWritableStore(key, defaultValue, serialize, deserialize) {
+    const getCache = () => {
+        try {
+            const cached = localStorage.getItem(key);
+            return cached !== null ? deserialize(cached) : defaultValue;
+        }
+        catch {
+            return defaultValue;
+        }
+    };
+    const setCache = (value) => {
+        try {
+            if (value !== undefined) {
+                localStorage.setItem(key, serialize(value));
+            }
+            else {
+                localStorage.removeItem(key);
+            }
+        }
+        catch {
+            // Silently ignore localStorage errors to allow the application to function
+            // without persistence in environments where localStorage is unavailable
+        }
+    };
+    const data = writable(getCache());
+    data.subscribe((value) => {
+        setCache(value);
+    });
+    return data;
+}
+export const cachedWritableString = (key, defaultValue = '') => cachedWritableStore(key, defaultValue, (v) => v, (v) => v);
+export const cachedWritableInt = (key, defaultValue = 0) => cachedWritableStore(key, defaultValue, (v) => v.toString(), (v) => {
+    const parsed = Number.parseInt(v);
+    return isNaN(parsed) ? defaultValue : parsed;
+});
+/**
+ * Creates a writable store that can hold an optional value of type T and persists to localStorage.
+ *
+ * @template T - The type of the value stored
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {T | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @param {function} serialize - Function to convert the value to a string for storage
+ * @param {function} deserialize - Function to convert the stored string back to a value
+ * @returns A writable store that persists to localStorage and can hold undefined values
+ */
+export const cachedWritableOptionalStore = (key, defaultValue = undefined, serialize, deserialize) => cachedWritableStore(key, defaultValue, (v) => (v !== undefined ? serialize(v) : ''), (v) => (v !== '' ? deserialize(v) : undefined));
+/**
+ * Creates a writable store that can hold an optional number value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {number | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional number
+ */
+export const cachedWritableIntOptional = (key, defaultValue = undefined) => cachedWritableOptionalStore(key, defaultValue, (v) => v.toString(), (v) => {
+    const parsed = Number.parseInt(v);
+    return isNaN(parsed) ? (defaultValue ?? 0) : parsed;
+});
+/**
+ * Creates a writable store that can hold an optional string value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {string | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional string
+ */
+export const cachedWritableStringOptional = (key, defaultValue = undefined) => cachedWritableOptionalStore(key, defaultValue, (v) => v, (v) => v);

package/dist/types/account.d.ts

@@ -0,0 +1,3 @@
+import type { Readable } from 'svelte/store';
+import type { Hex } from 'viem';
+export type Account = Readable<Hex | null>;

package/dist/types/account.js

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

package/dist/types/appStores.d.ts

@@ -1,19 +1,20 @@
 import type { Readable, Writable } from 'svelte/store';
-import type { ConfigSource, OrderbookConfigSource } from '@rainlanguage/orderbook/js_api';
+import type { AccountCfg, NewConfig, OrderbookCfg, SubgraphCfg } from '@rainlanguage/orderbook';
 export interface AppStoresInterface {
-    settings: Writable<ConfigSource | undefined>;
-    activeSubgraphs: Writable<Record<string, string>>;
-    accounts: Readable<Record<string, string>>;
-    activeAccountsItems: Writable<Record<string, string>>;
-    activeOrderStatus: Writable<boolean | undefined>;
+    settings: Writable<NewConfig>;
+    activeSubgraphs: Writable<Record<string, SubgraphCfg>>;
+    accounts: Readable<Record<string, AccountCfg>>;
+    activeAccountsItems: Writable<Record<string, string>> | undefined;
+    showInactiveOrders: Writable<boolean>;
     orderHash: Writable<string>;
     hideZeroBalanceVaults: Writable<boolean>;
     activeNetworkRef: Writable<string | undefined>;
     activeOrderbookRef: Writable<string | undefined>;
-    activeOrderbook: Readable<OrderbookConfigSource | undefined>;
-    subgraphUrl: Readable<string | undefined>;
+    activeOrderbook: Readable<OrderbookCfg | undefined>;
+    subgraph: Readable<SubgraphCfg | undefined>;
     activeAccounts: Readable<{
-        [k: string]: string;
+        [k: string]: AccountCfg;
     }>;
     showMyItemsOnly: Writable<boolean>;
+    activeNetworkOrderbooks: Readable<Record<string, OrderbookCfg>>;
 }

package/dist/types/modal.d.ts

@@ -1,20 +1,32 @@
-import type { SgOrder } from '@rainlanguage/orderbook/js_api';
-import type { DepositOrWithdrawArgs, OrderRemoveArgs, DeploymentArgs } from './transaction';
-export type DepositOrWithdrawModalProps = {
+import type { SgOrder, SgVault } from '@rainlanguage/orderbook';
+import type { VaultActionArgs } from './transaction';
+import type { Hex } from 'viem';
+export type VaultActionModalProps = {
     open: boolean;
-    args: DepositOrWithdrawArgs;
-};
-export type OrderRemoveModalProps = {
-    open: boolean;
-    args: OrderRemoveArgs;
-};
-export type DeployModalProps = {
-    open: boolean;
-    args: DeploymentArgs;
+    args: VaultActionArgs;
+    onSubmit: (amount: bigint) => void;
 };
 export type DisclaimerModalProps = {
     open: boolean;
     onAccept: () => void;
 };
+export type TransactionConfirmationProps = {
+    open: boolean;
+    modalTitle: string;
+    closeOnConfirm?: boolean;
+    args: {
+        chainId: number;
+        toAddress: Hex;
+        onConfirm: (hash: Hex) => void;
+        entity?: SgOrder | SgVault;
+        calldata: string;
+    };
+};
 export type QuoteDebugModalHandler = (order: SgOrder, rpcUrl: string, orderbook: string, inputIOIndex: number, outputIOIndex: number, pair: string, blockNumber?: number) => void;
 export type DebugTradeModalHandler = (hash: string, rpcUrl: string) => void;
+export type HandleTransactionConfirmationModal = (props: TransactionConfirmationProps, options?: {
+    timeout?: number;
+}) => Promise<{
+    success: boolean;
+    hash?: string;
+}>;

package/dist/types/strategy.d.ts

@@ -1,4 +1,4 @@
-import type { NameAndDescriptionCfg } from '@rainlanguage/orderbook/js_api';
+import type { NameAndDescriptionCfg } from '@rainlanguage/orderbook';
 export type ValidStrategyDetail = {
     details: NameAndDescriptionCfg;
     name: string;

package/dist/types/toast.d.ts

@@ -0,0 +1,11 @@
+export interface ToastProps {
+    message: string;
+    detail?: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    color: 'green' | 'red' | 'yellow' | 'blue';
+    links?: ToastLink[];
+}
+export type ToastLink = {
+    link: string;
+    label: string;
+};

package/dist/types/toast.js

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

package/dist/types/transaction.d.ts

@@ -1,27 +1,66 @@
-import type { ExtendedApprovalCalldata } from '../stores/transactionStore';
-import type { DepositAndAddOrderCalldataResult } from '@rainlanguage/orderbook/js_api';
 import type { Hex } from 'viem';
-import type { SgOrder, SgVault } from '@rainlanguage/orderbook/js_api';
-export type DeploymentArgs = {
-    approvals: ExtendedApprovalCalldata[];
-    deploymentCalldata: DepositAndAddOrderCalldataResult;
-    orderbookAddress: Hex;
-    chainId: number;
+import type { SgVault, VaultCalldataResult, DeploymentTransactionArgs } from '@rainlanguage/orderbook';
+import type { Config } from '@wagmi/core';
+import type { ToastLink } from './toast';
+import type { AwaitSubgraphConfig } from '../services/awaitTransactionIndexing';
+export type DeploymentArgs = DeploymentTransactionArgs & {
     subgraphUrl: string;
     network: string;
 };
-export type DepositOrWithdrawArgs = {
+export type VaultActionArgs = {
     vault: SgVault;
-    onDepositOrWithdraw: () => void;
-    action: 'deposit' | 'withdraw';
     chainId: number;
+    onDeposit?: () => void;
     rpcUrl: string;
     subgraphUrl: string;
+    account: Hex;
 };
-export type OrderRemoveArgs = {
-    order: SgOrder;
-    onRemove: () => void;
+export declare enum TransactionName {
+    REMOVAL = "Order Removal",
+    WITHDRAWAL = "Vault Withdrawal",
+    APPROVAL = "Token Approval",
+    DEPOSIT = "Vault Deposit"
+}
+export declare enum TransactionStatusMessage {
+    IDLE = "Idle",
+    STARTING = "Starting transaction...",
+    CHECKING_ALLOWANCE = "Checking your allowance...",
+    PENDING_WALLET = "Waiting for wallet confirmation...",
+    PENDING_APPROVAL = "Approving token spend...",
+    PENDING_RECEIPT = "Waiting for transaction receipt...",
+    PENDING_DEPLOYMENT = "Deploying your order...",
+    PENDING_WITHDRAWAL = "Withdrawing tokens...",
+    PENDING_DEPOSIT = "Depositing tokens...",
+    PENDING_SUBGRAPH = "Awaiting transaction indexing...",
+    SUCCESS = "Transaction confirmed",
+    ERROR = "Something went wrong"
+}
+export declare enum TransactionStoreErrorMessage {
+    SWITCH_CHAIN_FAILED = "Failed to switch chain.",
+    SUBGRAPH_TIMEOUT_ERROR = "The subgraph took too long to respond. Your transaction may still be processing.",
+    SUBGRAPH_FAILED = "Failed to index transaction.",
+    RECEIPT_FAILED = "Failed to get transaction receipt."
+}
+export type DepositOrWithdrawTransactionArgs = {
+    config: Config;
+    approvalCalldata?: VaultCalldataResult;
+    transactionCalldata: VaultCalldataResult;
+    action: 'deposit' | 'withdraw';
     chainId: number;
-    orderbookAddress: Hex;
+    vault: SgVault;
     subgraphUrl: string;
 };
+export type InternalTransactionArgs = {
+    chainId: number;
+    txHash: Hex;
+    networkKey: string;
+    queryKey: string;
+};
+export type TransactionArgs = InternalTransactionArgs & {
+    name: string;
+    errorMessage: string;
+    successMessage: string;
+    queryKey: string;
+    toastLinks: ToastLink[];
+    awaitSubgraphConfig?: AwaitSubgraphConfig;
+};

package/dist/types/transaction.js

@@ -1 +1,29 @@
-export {};
+export var TransactionName;
+(function (TransactionName) {
+    TransactionName["REMOVAL"] = "Order Removal";
+    TransactionName["WITHDRAWAL"] = "Vault Withdrawal";
+    TransactionName["APPROVAL"] = "Token Approval";
+    TransactionName["DEPOSIT"] = "Vault Deposit";
+})(TransactionName || (TransactionName = {}));
+export var TransactionStatusMessage;
+(function (TransactionStatusMessage) {
+    TransactionStatusMessage["IDLE"] = "Idle";
+    TransactionStatusMessage["STARTING"] = "Starting transaction...";
+    TransactionStatusMessage["CHECKING_ALLOWANCE"] = "Checking your allowance...";
+    TransactionStatusMessage["PENDING_WALLET"] = "Waiting for wallet confirmation...";
+    TransactionStatusMessage["PENDING_APPROVAL"] = "Approving token spend...";
+    TransactionStatusMessage["PENDING_RECEIPT"] = "Waiting for transaction receipt...";
+    TransactionStatusMessage["PENDING_DEPLOYMENT"] = "Deploying your order...";
+    TransactionStatusMessage["PENDING_WITHDRAWAL"] = "Withdrawing tokens...";
+    TransactionStatusMessage["PENDING_DEPOSIT"] = "Depositing tokens...";
+    TransactionStatusMessage["PENDING_SUBGRAPH"] = "Awaiting transaction indexing...";
+    TransactionStatusMessage["SUCCESS"] = "Transaction confirmed";
+    TransactionStatusMessage["ERROR"] = "Something went wrong";
+})(TransactionStatusMessage || (TransactionStatusMessage = {}));
+export var TransactionStoreErrorMessage;
+(function (TransactionStoreErrorMessage) {
+    TransactionStoreErrorMessage["SWITCH_CHAIN_FAILED"] = "Failed to switch chain.";
+    TransactionStoreErrorMessage["SUBGRAPH_TIMEOUT_ERROR"] = "The subgraph took too long to respond. Your transaction may still be processing.";
+    TransactionStoreErrorMessage["SUBGRAPH_FAILED"] = "Failed to index transaction.";
+    TransactionStoreErrorMessage["RECEIPT_FAILED"] = "Failed to get transaction receipt.";
+})(TransactionStoreErrorMessage || (TransactionStoreErrorMessage = {}));

package/dist/utils/configHelpers.d.ts

@@ -0,0 +1,8 @@
+import type { AccountCfg, SubgraphCfg } from '@rainlanguage/orderbook';
+export declare function getMultiSubgraphArgs(subgraphs: Record<string, SubgraphCfg>): {
+    name: string;
+    url: string;
+}[];
+export declare function getAccountsAsOptions(accounts: Record<string, AccountCfg>): {
+    [k: string]: string;
+};

package/dist/utils/configHelpers.js

@@ -0,0 +1,38 @@
+export function getMultiSubgraphArgs(subgraphs) {
+    return Object.entries(subgraphs).map(([name, value]) => ({
+        name,
+        url: value.url
+    }));
+}
+export function getAccountsAsOptions(accounts) {
+    return Object.fromEntries(Object.entries(accounts).map(([key, value]) => [key, value.address]));
+}
+if (import.meta.vitest) {
+    const { expect, it, describe } = import.meta.vitest;
+    describe('getMultiSubgraphArgs', () => {
+        it('should return the correct multi subgraph args', () => {
+            const subgraphs = {
+                subgraph1: { url: 'https://subgraph1.com', key: 'subgraph1' },
+                subgraph2: { url: 'https://subgraph2.com', key: 'subgraph2' }
+            };
+            const result = getMultiSubgraphArgs(subgraphs);
+            expect(result).toEqual([
+                { name: 'subgraph1', url: 'https://subgraph1.com' },
+                { name: 'subgraph2', url: 'https://subgraph2.com' }
+            ]);
+        });
+    });
+    describe('getAccountsAsOptions', () => {
+        it('should return the correct accounts as options', () => {
+            const accounts = {
+                account1: { address: '0x1234567890abcdef', key: 'account1' },
+                account2: { address: '0xabcdef1234567890', key: 'account2' }
+            };
+            const result = getAccountsAsOptions(accounts);
+            expect(result).toEqual({
+                account1: '0x1234567890abcdef',
+                account2: '0xabcdef1234567890'
+            });
+        });
+    });
+}

package/dist/utils/constructHashLink.d.ts

@@ -0,0 +1,23 @@
+import type { SgOrder, SgOrderAsIO, SgVault } from '@rainlanguage/orderbook';
+type OrderOrVault = SgOrder | SgOrderAsIO | SgVault;
+/**
+ * Constructs a link path for an order or vault based on its type and network
+ * @param orderOrVault - The order or vault object
+ * @param type - The type of resource ('orders' or 'vaults')
+ * @param network - The network name
+ * @returns The constructed link path
+ */
+export declare function constructHashLink(orderOrVault: OrderOrVault, type: 'orders' | 'vaults', network: string): string;
+/**
+ * Determines if an order or vault is active
+ * @param orderOrVault - The order or vault object
+ * @returns True if the order is active, false otherwise
+ */
+export declare function isOrderOrVaultActive(orderOrVault: OrderOrVault): boolean;
+/**
+ * Extracts the hash value from an order or vault
+ * @param orderOrVault - The order or vault object
+ * @returns The hash value
+ */
+export declare function extractHash(orderOrVault: OrderOrVault): string;
+export {};

package/dist/utils/constructHashLink.js

@@ -0,0 +1,110 @@
+import fc from 'fast-check';
+import { test } from '@fast-check/vitest';
+function isOrder(obj) {
+    return obj && 'orderHash' in obj;
+}
+/**
+ * Constructs a link path for an order or vault based on its type and network
+ * @param orderOrVault - The order or vault object
+ * @param type - The type of resource ('orders' or 'vaults')
+ * @param network - The network name
+ * @returns The constructed link path
+ */
+export function constructHashLink(orderOrVault, type, network) {
+    if (!orderOrVault) {
+        return `/${type}/${network}`;
+    }
+    const slug = isOrder(orderOrVault) ? orderOrVault.orderHash : orderOrVault?.id;
+    return `/${type}/${network}-${slug || ''}`;
+}
+/**
+ * Determines if an order or vault is active
+ * @param orderOrVault - The order or vault object
+ * @returns True if the order is active, false otherwise
+ */
+export function isOrderOrVaultActive(orderOrVault) {
+    const _isOrder = isOrder(orderOrVault);
+    return _isOrder ? orderOrVault.active : false;
+}
+/**
+ * Extracts the hash value from an order or vault
+ * @param orderOrVault - The order or vault object
+ * @returns The hash value
+ */
+export function extractHash(orderOrVault) {
+    const _isOrder = isOrder(orderOrVault);
+    return _isOrder ? orderOrVault.orderHash : orderOrVault?.id || '';
+}
+if (import.meta.vitest) {
+    const { expect, it, describe } = import.meta.vitest;
+    describe('constructHashLink', () => {
+        test.prop([
+            fc.record({
+                orderHash: fc.string(),
+                active: fc.boolean()
+            }),
+            fc.oneof(fc.constant('orders'), fc.constant('vaults')),
+            fc.string()
+        ])('constructs correct link for orders', (order, type, network) => {
+            const result = constructHashLink(order, type, network);
+            expect(result).toBe(`/${type}/${network}-${order.orderHash}`);
+        });
+        test.prop([
+            fc.record({
+                id: fc.string(),
+                owner: fc.string()
+            }),
+            fc.oneof(fc.constant('orders'), fc.constant('vaults')),
+            fc.string()
+        ])('constructs correct link for vaults', (vault, type, network) => {
+            const result = constructHashLink(vault, type, network);
+            expect(result).toBe(`/${type}/${network}-${vault.id}`);
+        });
+    });
+    describe('isOrderOrVaultActive', () => {
+        test.prop([
+            fc.record({
+                orderHash: fc.string(),
+                active: fc.boolean()
+            })
+        ])('returns correct active status for orders', (order) => {
+            const result = isOrderOrVaultActive(order);
+            expect(result).toBe(order.active);
+        });
+        test.prop([
+            fc.record({
+                id: fc.string(),
+                owner: fc.string()
+            })
+        ])('returns false for vaults', (vault) => {
+            const result = isOrderOrVaultActive(vault);
+            expect(result).toBe(false);
+        });
+    });
+    describe('extractHash', () => {
+        test.prop([
+            fc.record({
+                orderHash: fc.string(),
+                active: fc.boolean()
+            })
+        ])('extracts hash from orders', (order) => {
+            const result = extractHash(order);
+            expect(result).toBe(order.orderHash);
+        });
+        test.prop([
+            fc.record({
+                id: fc.string(),
+                owner: fc.string()
+            })
+        ])('extracts hash from vaults', (vault) => {
+            const result = extractHash(vault);
+            expect(result).toBe(vault.id);
+        });
+        it('handles undefined vault id', () => {
+            // Create a partial vault object with undefined id
+            const vault = { id: undefined };
+            const result = extractHash(vault);
+            expect(result).toBe('');
+        });
+    });
+}