@rainlanguage/ui-components 0.0.1-alpha.37 → 0.0.1-alpha.39

package/dist/components/charts/TanstackLightweightChartLine.svelte

@@ -1,17 +1,13 @@
 <script generics="T">import LightweightChart from "./LightweightChart.svelte";
-import { sortBy } from "lodash";
+import { transformAndSortData } from "./transformAndSortData";
 export let query;
 export let timeTransform;
 export let valueTransform;
 export let lightweightChartsTheme;
-const transformAndSortData = (data2) => {
-  const transformedData = data2.map((d) => ({
-    value: valueTransform(d),
-    time: timeTransform(d)
-  }));
-  return sortBy(transformedData, (d) => d.time);
-};
-$: data = transformAndSortData($query.data ?? []);
+$: data = transformAndSortData($query.data ?? [], {
+  valueTransform,
+  timeTransform
+});
 const createSeries = (chart) => chart.addLineSeries({ lineWidth: 1 });
 </script>
 

package/dist/components/charts/transformAndSortData.d.ts

@@ -0,0 +1,24 @@
+import type { UTCTimestamp } from 'lightweight-charts';
+/**
+ * Filters out data points with duplicate timestamps, keeping only the first occurrence.
+ *
+ * @param data Array of data points with time and value properties
+ * @returns A new array with only unique timestamps
+ */
+export declare const deduplicateByTime: <T extends {
+    time: UTCTimestamp;
+}>(data: T[]) => T[];
+/**
+ * Transforms and sorts data, ensuring unique timestamps.
+ *
+ * @param data The source data to transform
+ * @param options Configuration object with transform functions
+ * @returns Transformed, sorted, and deduplicated data
+ */
+export declare const transformAndSortData: <T>(data: T[], options: {
+    valueTransform: (item: T) => number;
+    timeTransform: (item: T) => UTCTimestamp;
+}) => Array<{
+    value: number;
+    time: UTCTimestamp;
+}>;

package/dist/components/charts/transformAndSortData.js

@@ -0,0 +1,111 @@
+import { sortBy } from 'lodash';
+/**
+ * Filters out data points with duplicate timestamps, keeping only the first occurrence.
+ *
+ * @param data Array of data points with time and value properties
+ * @returns A new array with only unique timestamps
+ */
+export const deduplicateByTime = (data) => {
+    const uniqueData = [];
+    const seenTimes = new Set();
+    for (const dataPoint of data) {
+        if (!seenTimes.has(dataPoint.time)) {
+            uniqueData.push(dataPoint);
+            seenTimes.add(dataPoint.time);
+        }
+    }
+    return uniqueData;
+};
+/**
+ * Transforms and sorts data, ensuring unique timestamps.
+ *
+ * @param data The source data to transform
+ * @param options Configuration object with transform functions
+ * @returns Transformed, sorted, and deduplicated data
+ */
+export const transformAndSortData = (data, options) => {
+    const { valueTransform, timeTransform } = options;
+    const transformedData = data.map((d) => ({
+        value: valueTransform(d),
+        time: timeTransform(d)
+    }));
+    const sortedData = sortBy(transformedData, (d) => d.time);
+    return deduplicateByTime(sortedData);
+};
+if (import.meta.vitest) {
+    const { it, expect, describe } = import.meta.vitest;
+    describe('deduplicateByTime', () => {
+        it('should remove entries with duplicate timestamps', () => {
+            const data = [
+                { time: 100, value: 10 },
+                { time: 200, value: 20 },
+                { time: 200, value: 25 }, // Duplicate timestamp
+                { time: 300, value: 30 }
+            ];
+            const result = deduplicateByTime(data);
+            const expected = [
+                { time: 100, value: 10 },
+                { time: 200, value: 20 }, // First occurrence kept
+                { time: 300, value: 30 }
+            ];
+            expect(result).toEqual(expected);
+        });
+        it('should handle multiple duplicate timestamps', () => {
+            const data = [
+                { time: 100, value: 10 },
+                { time: 100, value: 15 }, // Duplicate
+                { time: 100, value: 18 }, // Duplicate
+                { time: 200, value: 20 }
+            ];
+            const result = deduplicateByTime(data);
+            const expected = [
+                { time: 100, value: 10 }, // Only first one kept
+                { time: 200, value: 20 }
+            ];
+            expect(result).toEqual(expected);
+        });
+        it('should return original array if no duplicates', () => {
+            const data = [
+                { time: 100, value: 10 },
+                { time: 200, value: 20 },
+                { time: 300, value: 30 }
+            ];
+            const result = deduplicateByTime(data);
+            expect(result).toEqual(data);
+            expect(result).not.toBe(data);
+        });
+        it('should handle empty array', () => {
+            const data = [];
+            const result = deduplicateByTime(data);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('transformAndSortData', () => {
+        it('should transform, sort, and deduplicate data', () => {
+            const rawData = [
+                { timestamp: 3000, price: 300 },
+                { timestamp: 1000, price: 100 },
+                { timestamp: 2000, price: 200 },
+                { timestamp: 2000, price: 250 } // Duplicate timestamp
+            ];
+            const result = transformAndSortData(rawData, {
+                valueTransform: (item) => item.price,
+                timeTransform: (item) => item.timestamp
+            });
+            const expected = [
+                { time: 1000, value: 100 },
+                { time: 2000, value: 200 }, // First occurrence kept after sorting
+                { time: 3000, value: 300 }
+            ];
+            expect(result).toEqual(expected);
+        });
+        it('should handle empty data array', () => {
+            const rawData = [];
+            const result = transformAndSortData(rawData, {
+                valueTransform: (item) => item.price,
+                timeTransform: (item) => item.timestamp
+            });
+            expect(result).toEqual([]);
+        });
+    });
+}

package/dist/index.d.ts

@@ -74,7 +74,6 @@ export { createResolvableQuery, createResolvableInfiniteQuery } from './__mocks_
 export { formatTimestampSecondsAsLocal, timestampSecondsToUTCTimestamp, promiseTimeout } from './utils/time';
 export { bigintStringToHex, HEX_INPUT_REGEX } from './utils/hex';
 export { vaultBalanceDisplay } from './utils/vault';
-export { prepareHistoricalOrderChartData } from './services/historicalOrderCharts';
 export { bigintToFloat } from './utils/number';
 export { getExplorerLink } from './services/getExplorerLink';
 export { DEFAULT_PAGE_SIZE, DEFAULT_REFRESH_INTERVAL } from './queries/constants';

package/dist/index.js

@@ -71,7 +71,6 @@ export { createResolvableQuery, createResolvableInfiniteQuery } from './__mocks_
 export { formatTimestampSecondsAsLocal, timestampSecondsToUTCTimestamp, promiseTimeout } from './utils/time';
 export { bigintStringToHex, HEX_INPUT_REGEX } from './utils/hex';
 export { vaultBalanceDisplay } from './utils/vault';
-export { prepareHistoricalOrderChartData } from './services/historicalOrderCharts';
 export { bigintToFloat } from './utils/number';
 export { getExplorerLink } from './services/getExplorerLink';
 // Constants

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rainlanguage/ui-components",
-	"version": "0.0.1-alpha.37",
+	"version": "0.0.1-alpha.39",
 	"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.1.0",
 		"@imask/svelte": "7.6.1",
 		"@observablehq/plot": "0.6.16",
-		"@rainlanguage/orderbook": "0.0.1-alpha.37",
+		"@rainlanguage/orderbook": "0.0.1-alpha.39",
 		"@reown/appkit": "1.6.4",
 		"@reown/appkit-adapter-wagmi": "1.6.4",
 		"@sentry/sveltekit": "7.120.0",
@@ -80,7 +80,7 @@
 		"tailwind-merge": "2.5.4",
 		"thememirror": "2.0.1",
 		"uuid": "9.0.1",
-		"viem": "2.22.8",
+		"viem": "2.24.3",
 		"wagmi": "2.14.7"
 	}
 }