@upbit-official/upbit-sdk 0.9.0 → 1.1.0

package/src/lib/index.ts

@@ -1,4 +1,19 @@
 export { createJwtToken } from './jwtAuth';
-export { WsStream, WsStreamManager } from './ws';
-export type { WsStreamOptions } from './ws';
+export { WsEndpoint, WsStream, WsStreamManager } from './ws';
+export type {
+  WsAnnouncementOptions,
+  WsDefaultListSubscriptionsResponse,
+  WsListSubscriptionsResponse,
+  WsSimpleEvent,
+  WsSimpleListSubscriptionsResponse,
+  WsStreamFormat,
+  WsStreamOptions,
+  WsIndicatorOptions,
+  WsIndicatorSubscription,
+  WsIndicatorSignalOptions,
+  WsIndicatorSignalSubscription,
+} from './ws';
 export { jsonParseFloat } from './jsonParseFloat';
+
+export type * from '../internal/ws-simple-types';
+export type { WebSocketAPIErrorMessage, WebSocketUntypedMessage } from '../internal/ws-parser';

package/src/lib/jsonParseFloat.ts

@@ -5,6 +5,7 @@
  */
 const NUMBER_FIELDS: Set<string> = new Set([
   'timestamp',
+  'tms',
   'trade_timestamp',
   'sequential_id',
   'trades_count',
@@ -14,56 +15,81 @@ const NUMBER_FIELDS: Set<string> = new Set([
   'block_elapsed_minutes',
   'fee_level',
   'security_level',
+  'unit',
 ]);
 
 /**
  * Parses a JSON string with type-aware coercion.
  *
- * 1st pass (JSON.parse reviver): float tokens (containing `.`, `e`, `E`) are
- * preserved as their original string representation to avoid precision loss.
- * Uses the reviver's third argument `context.source` (TypeScript 5.2+ / modern runtimes).
+ * 1st pass (JSON.parse reviver): numeric tokens retain their original source
+ * alongside the parsed number. Uses the runtime's reviver `context.source`.
  * Falls back to standard number parsing when `context.source` is unavailable.
  *
  * 2nd pass (constructType): coerces values to match SDK declared types.
  * - `string`-declared fields: `number` → `string`  (e.g. balance `0` → `"0"`)
  * - `number`-declared fields: `string` → `number`  (e.g. timestamp `"123.45"` → `123.45`)
  *
- * Mirrors the behavior of Python SDK's `json.loads(parse_float=str)` + `construct_type()`.
+ * Integer scalars and integer array elements keep their existing number contract;
+ * decimal/exponent scalars and array elements keep their existing source strings.
  */
-export function jsonParseFloat(text: string): unknown {
+export function jsonParseFloat(
+  text: string,
+  numberField?: (key: string, path: string[], root: Record<string, unknown>) => boolean,
+): unknown {
   const parsed = JSON.parse(text, (key: string, value: unknown, context?: { source?: string }) => {
     if (typeof value !== 'number') return value;
     const src = context?.source;
     if (!src) return value;
-    return /[.eE]/.test(src) ? src : value;
+    return new NumericToken(src, value);
   });
-  return constructType(parsed);
+  return constructType(parsed, numberField);
 }
 
-function constructType(data: unknown): unknown {
+/** Internal only: distinguish numeric wire tokens from JSON string values. */
+class NumericToken {
+  constructor(
+    readonly source: string,
+    readonly value: number,
+  ) {}
+}
+
+function constructType(
+  data: unknown,
+  numberField?: (key: string, path: string[], root: Record<string, unknown>) => boolean,
+  path: string[] = [],
+  root?: Record<string, unknown>,
+): unknown {
+  if (data instanceof NumericToken) {
+    return /[.eE]/.test(data.source) ? data.source : data.value;
+  }
   if (Array.isArray(data)) {
-    return data.map(constructType);
+    return data.map((item) => constructType(item, numberField, path, root));
   }
 
   if (data !== null && typeof data === 'object') {
     const obj = data as Record<string, unknown>;
+    root ??= obj;
     const result: Record<string, unknown> = {};
     for (const key of Object.keys(obj)) {
       const value = obj[key];
 
-      if (NUMBER_FIELDS.has(key)) {
+      if (NUMBER_FIELDS.has(key) || numberField?.(key, path, root)) {
         // number-declared field: coerce string → number
-        if (typeof value === 'string') {
+        if (value instanceof NumericToken) {
+          result[key] = value.value;
+        } else if (typeof value === 'string') {
           result[key] = Number(value);
         } else {
           result[key] = value;
         }
+      } else if (value instanceof NumericToken) {
+        result[key] = value.source;
       } else if (typeof value === 'number') {
         // string-declared field: coerce number → string
         result[key] = String(value);
       } else {
         // recurse into nested objects and arrays
-        result[key] = constructType(value);
+        result[key] = constructType(value, numberField, [...path, key], root);
       }
     }
     return result;