@orderly.network/hooks 1.3.0-alpha.0 → 1.4.0-alpha.0

package/lib/orderly/usePrivateDataObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePrivateDataObserver.d.ts","sourceRoot":"","sources":["../../src/orderly/usePrivateDataObserver.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,eAAO,MAAM,sBAAsB;uBAEd,MAAM,KAAK,IAAI,MAAM,EAAE,cAAc,CAAC;UA4K1D,CAAC"}
+{"version":3,"file":"usePrivateDataObserver.d.ts","sourceRoot":"","sources":["../../src/orderly/usePrivateDataObserver.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMjD,eAAO,MAAM,sBAAsB;uBAEd,MAAM,KAAK,IAAI,MAAM,EAAE,cAAc,CAAC;UAgK1D,CAAC"}

package/lib/orderly/usePrivateDataObserver.js

@@ -15,35 +15,31 @@ const _useAccount = require("../useAccount");
 const _infinite = require("swr/infinite");
 const _useEventEmitter = require("../useEventEmitter");
 const _swr1 = require("../utils/swr");
+const _algoOrderMergeHandler = require("../services/orderMerge/algoOrderMergeHandler");
+const _ws = require("../utils/ws");
 const usePrivateDataObserver = (options)=>{
     const ws = (0, _useWS.useWS)();
     // const { mutate } = useSWRConfig();
     const ee = (0, _useEventEmitter.useEventEmitter)();
     const { state } = (0, _useAccount.useAccount)();
     // TODO: remove this when the WS service provides the correct data
-    const algoOrderCacheQuneue = (0, _react.useRef)([]);
+    // const algoOrderCacheQuneue = useRef<API.AlgoOrder[]>([]);
     const updateOrders = (data, isAlgoOrder)=>{
-        const map = options.getKeysMap("orders");
-        // console.log("$$$$$$$$$$$$", data, algoOrderCacheQuneue.current);
-        if (isAlgoOrder) {
-            /// TODO: remove this when the WS service provides the correct data
-            if (algoOrderCacheQuneue.current.length) {
-                const index = algoOrderCacheQuneue.current.findIndex((item)=>item.order_id === data.algoOrderId);
-                if (index > -1) {
-                    data = {
-                        ...data,
-                        ...algoOrderCacheQuneue.current[index]
-                    };
-                    algoOrderCacheQuneue.current.splice(index, 1);
-                }
-            }
-        }
-        map.forEach((getKey, key)=>{
+        const keysMap = options.getKeysMap("orders");
+        keysMap.forEach((getKey, key)=>{
             (0, _swr.mutate)((0, _infinite.unstable_serialize)((index, prevData)=>[
                     getKey(index, prevData),
                     state.accountId
                 ]), (prevData)=>{
-                return (0, _swr1.updateOrdersHandler)(key, data, prevData);
+                try {
+                    if (isAlgoOrder) {
+                        const result = (0, _swr1.updateAlgoOrdersHandler)(key, data, prevData);
+                        return result;
+                    }
+                    return (0, _swr1.updateOrdersHandler)(key, data, prevData);
+                } catch (error) {
+                    return prevData;
+                }
             }, {
                 revalidate: false
             });
@@ -53,9 +49,10 @@ const usePrivateDataObserver = (options)=>{
         //   ...data,
         //   status: data.status || (data as WSMessage.AlgoOrder).algoStatus,
         // });
+        const formattedData = isAlgoOrder ? _algoOrderMergeHandler.AlgoOrderMergeHandler.groupOrders(data) : (0, _ws.object2underscore)(data);
         ee.emit("orders:changed", {
-            ...data,
-            status: data.status || data.algoStatus
+            ...formattedData,
+            status: isAlgoOrder ? formattedData.algo_status : data.status
         });
     };
     // orders
@@ -75,17 +72,7 @@ const usePrivateDataObserver = (options)=>{
         if (!state.accountId) return;
         const unsubscribe = ws.privateSubscribe("algoexecutionreport", {
             onMessage: (data)=>{
-                setTimeout(()=>{
-                    if (Array.isArray(data)) {
-                        data.forEach((item)=>{
-                            updateOrders(item, true);
-                        // ee.emit("orders:changed", { ...item, status: item.algoStatus });
-                        });
-                    } else {
-                        updateOrders(data, true);
-                    // ee.emit("orders:changed", { ...data, status: data.algoStatus });
-                    }
-                }, 100);
+                updateOrders(data, true);
             }
         });
         return ()=>unsubscribe?.();
@@ -148,16 +135,16 @@ const usePrivateDataObserver = (options)=>{
     }, [
         state.accountId
     ]);
-    // cache algo orders
-    (0, _react.useEffect)(()=>{
-        const handler = (data)=>{
-            algoOrderCacheQuneue.current.push(data);
-        };
-        ee.on("algoOrder:cache", handler);
-        return ()=>{
-            ee.off("algoOrder:cache", handler);
-        };
-    }, []);
+// cache algo orders
+// useEffect(() => {
+//   const handler = (data: API.AlgoOrder) => {
+//     algoOrderCacheQuneue.current.push(data);
+//   };
+//   ee.on("algoOrder:cache", handler);
+//   return () => {
+//     ee.off("algoOrder:cache", handler);
+//   };
+// }, []);
 };
 
 //# sourceMappingURL=usePrivateDataObserver.js.map

package/lib/orderly/usePrivateDataObserver.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/orderly/usePrivateDataObserver.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useWS } from \"../useWS\";\nimport { mutate } from \"swr\";\nimport { WSMessage, API } from \"@orderly.network/types\";\nimport { useAccount } from \"../useAccount\";\nimport { unstable_serialize } from \"swr/infinite\";\nimport { useDebouncedCallback } from \"use-debounce\";\nimport { useEventEmitter } from \"../useEventEmitter\";\nimport { getKeyFunction } from \"../dataProvider\";\nimport { parseJSON } from \"../utils/json\";\nimport { updateOrdersHandler } from \"../utils/swr\";\n\nexport const usePrivateDataObserver = (options: {\n  // onUpdateOrders: (data: any) => void;\n  getKeysMap: (type: string) => Map<string, getKeyFunction>;\n}) => {\n  const ws = useWS();\n  // const { mutate } = useSWRConfig();\n  const ee = useEventEmitter();\n  const { state } = useAccount();\n\n  // TODO: remove this when the WS service provides the correct data\n  const algoOrderCacheQuneue = useRef<API.AlgoOrder[]>([]);\n\n  const updateOrders = (\n    data: WSMessage.AlgoOrder | WSMessage.Order,\n    isAlgoOrder: boolean\n  ) => {\n    const map = options.getKeysMap(\"orders\");\n\n    // console.log(\"$$$$$$$$$$$$\", data, algoOrderCacheQuneue.current);\n\n    if (isAlgoOrder) {\n      /// TODO: remove this when the WS service provides the correct data\n      if (algoOrderCacheQuneue.current.length) {\n        const index = algoOrderCacheQuneue.current.findIndex(\n          (item: any) =>\n            item.order_id === (data as WSMessage.AlgoOrder).algoOrderId\n        );\n\n        if (index > -1) {\n          data = {\n            ...data,\n            ...algoOrderCacheQuneue.current[index],\n          };\n          algoOrderCacheQuneue.current.splice(index, 1);\n        }\n      }\n    }\n\n    map.forEach((getKey, key) => {\n      mutate(\n        unstable_serialize((index, prevData) => [\n          getKey(index, prevData),\n          state.accountId,\n        ]),\n        (prevData?: any[]) => {\n          return updateOrdersHandler(key, data, prevData);\n        },\n        {\n          revalidate: false,\n        }\n      );\n    });\n\n    //  emit events;\n    // ee.emit(\"orders:changed\", {\n    //   ...data,\n    //   status: data.status || (data as WSMessage.AlgoOrder).algoStatus,\n    // });\n\n    ee.emit(\"orders:changed\", {\n      ...data,\n      status: data.status || (data as WSMessage.AlgoOrder).algoStatus,\n    });\n  };\n\n  // orders\n  useEffect(() => {\n    if (!state.accountId) return;\n    const unsubscribe = ws.privateSubscribe(\"executionreport\", {\n      onMessage: (data: any) => {\n        updateOrders(data, false);\n      },\n    });\n\n    return () => unsubscribe?.();\n  }, [state.accountId]);\n\n  // algo orders\n  useEffect(() => {\n    if (!state.accountId) return;\n    const unsubscribe = ws.privateSubscribe(\"algoexecutionreport\", {\n      onMessage: (data: any) => {\n        setTimeout(() => {\n          if (Array.isArray(data)) {\n            data.forEach((item) => {\n              updateOrders(item, true);\n\n              // ee.emit(\"orders:changed\", { ...item, status: item.algoStatus });\n            });\n          } else {\n            updateOrders(data, true);\n            // ee.emit(\"orders:changed\", { ...data, status: data.algoStatus });\n          }\n        }, 100);\n      },\n    });\n\n    return () => unsubscribe?.();\n  }, [state.accountId]);\n\n  // positions\n  useEffect(() => {\n    if (!state.accountId) return;\n    const key = [\"/v1/positions\", state.accountId];\n    const unsubscribe = ws.privateSubscribe(\"position\", {\n      onMessage: (data: { positions: WSMessage.Position[] }) => {\n        const { positions: nextPostions } = data;\n\n        // console.log(\"ws----- positions data-----\", data);\n\n        // updatePositions();\n\n        mutate(\n          key,\n          (prevPositions: any) => {\n            // return nextPostions;\n            if (!!prevPositions) {\n              return {\n                ...prevPositions,\n                rows: prevPositions.rows.map((row: any) => {\n                  const item = nextPostions.find(\n                    (item) => item.symbol === row.symbol\n                  );\n                  if (item) {\n                    return {\n                      symbol: item.symbol,\n                      position_qty: item.positionQty,\n                      cost_position: item.costPosition,\n                      last_sum_unitary_funding: item.lastSumUnitaryFunding,\n                      pending_long_qty: item.pendingLongQty,\n                      pending_short_qty: item.pendingShortQty,\n                      settle_price: item.settlePrice,\n                      average_open_price: item.averageOpenPrice,\n                      unsettled_pnl: item.unsettledPnl,\n                      mark_price: item.markPrice,\n                      est_liq_price: item.estLiqPrice,\n                      timestamp: Date.now(),\n                      imr: item.imr,\n                      mmr: item.mmr,\n                      IMR_withdraw_orders: item.imrwithOrders,\n                      MMR_with_orders: item.mmrwithOrders,\n                      pnl_24_h: item.pnl24H,\n                      fee_24_h: item.fee24H,\n                    };\n                  }\n\n                  return row;\n                }),\n              };\n            }\n          },\n          {\n            revalidate: false,\n          }\n        );\n      },\n    });\n    return () => {\n      unsubscribe?.();\n    };\n  }, [state.accountId]);\n\n  // cache algo orders\n  useEffect(() => {\n    const handler = (data: API.AlgoOrder) => {\n      algoOrderCacheQuneue.current.push(data);\n    };\n\n    ee.on(\"algoOrder:cache\", handler);\n\n    return () => {\n      ee.off(\"algoOrder:cache\", handler);\n    };\n  }, []);\n};\n"],"names":["usePrivateDataObserver","options","ws","useWS","ee","useEventEmitter","state","useAccount","algoOrderCacheQuneue","useRef","updateOrders","data","isAlgoOrder","map","getKeysMap","current","length","index","findIndex","item","order_id","algoOrderId","splice","forEach","getKey","key","mutate","unstable_serialize","prevData","accountId","updateOrdersHandler","revalidate","emit","status","algoStatus","useEffect","unsubscribe","privateSubscribe","onMessage","setTimeout","Array","isArray","positions","nextPostions","prevPositions","rows","row","find","symbol","position_qty","positionQty","cost_position","costPosition","last_sum_unitary_funding","lastSumUnitaryFunding","pending_long_qty","pendingLongQty","pending_short_qty","pendingShortQty","settle_price","settlePrice","average_open_price","averageOpenPrice","unsettled_pnl","unsettledPnl","mark_price","markPrice","est_liq_price","estLiqPrice","timestamp","Date","now","imr","mmr","IMR_withdraw_orders","imrwithOrders","MMR_with_orders","mmrwithOrders","pnl_24_h","pnl24H","fee_24_h","fee24H","handler","push","on","off"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../src/orderly/usePrivateDataObserver.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useWS } from \"../useWS\";\nimport { mutate } from \"swr\";\nimport { WSMessage, API } from \"@orderly.network/types\";\nimport { useAccount } from \"../useAccount\";\nimport { unstable_serialize } from \"swr/infinite\";\nimport { useDebouncedCallback } from \"use-debounce\";\nimport { useEventEmitter } from \"../useEventEmitter\";\nimport { getKeyFunction } from \"../dataProvider\";\nimport { parseJSON } from \"../utils/json\";\nimport { updateOrdersHandler, updateAlgoOrdersHandler } from \"../utils/swr\";\nimport { AlgoOrderMergeHandler } from \"../services/orderMerge/algoOrderMergeHandler\";\nimport { object2underscore } from \"../utils/ws\";\n\nexport const usePrivateDataObserver = (options: {\n  // onUpdateOrders: (data: any) => void;\n  getKeysMap: (type: string) => Map<string, getKeyFunction>;\n}) => {\n  const ws = useWS();\n  // const { mutate } = useSWRConfig();\n  const ee = useEventEmitter();\n  const { state } = useAccount();\n\n  // TODO: remove this when the WS service provides the correct data\n  // const algoOrderCacheQuneue = useRef<API.AlgoOrder[]>([]);\n\n  const updateOrders = (\n    data: WSMessage.AlgoOrder[] | WSMessage.Order,\n    isAlgoOrder: boolean\n  ) => {\n    const keysMap = options.getKeysMap(\"orders\");\n\n    keysMap.forEach((getKey, key) => {\n      mutate(\n        unstable_serialize((index, prevData) => [\n          getKey(index, prevData),\n          state.accountId,\n        ]),\n        (prevData?: any[]) => {\n          try {\n            if (isAlgoOrder) {\n              const result = updateAlgoOrdersHandler(\n                key,\n                data as WSMessage.AlgoOrder[],\n                prevData!\n              );\n\n              return result;\n            }\n            return updateOrdersHandler(key, data as WSMessage.Order, prevData);\n          } catch (error) {\n            return prevData;\n          }\n        },\n        {\n          revalidate: false,\n        }\n      );\n    });\n\n    //  emit events;\n    // ee.emit(\"orders:changed\", {\n    //   ...data,\n    //   status: data.status || (data as WSMessage.AlgoOrder).algoStatus,\n    // });\n\n    const formattedData = isAlgoOrder\n      ? AlgoOrderMergeHandler.groupOrders(data as WSMessage.AlgoOrder[])\n      : object2underscore(data);\n\n    ee.emit(\"orders:changed\", {\n      ...formattedData,\n      status: isAlgoOrder\n        ? formattedData.algo_status\n        : (data as WSMessage.Order).status,\n    });\n  };\n\n  // orders\n  useEffect(() => {\n    if (!state.accountId) return;\n    const unsubscribe = ws.privateSubscribe(\"executionreport\", {\n      onMessage: (data: any) => {\n        updateOrders(data, false);\n      },\n    });\n\n    return () => unsubscribe?.();\n  }, [state.accountId]);\n\n  // algo orders\n  useEffect(() => {\n    if (!state.accountId) return;\n    const unsubscribe = ws.privateSubscribe(\"algoexecutionreport\", {\n      onMessage: (data: any) => {\n        updateOrders(data, true);\n      },\n    });\n\n    return () => unsubscribe?.();\n  }, [state.accountId]);\n\n  // positions\n  useEffect(() => {\n    if (!state.accountId) return;\n    const key = [\"/v1/positions\", state.accountId];\n    const unsubscribe = ws.privateSubscribe(\"position\", {\n      onMessage: (data: { positions: WSMessage.Position[] }) => {\n        const { positions: nextPostions } = data;\n\n        // console.log(\"ws----- positions data-----\", data);\n\n        // updatePositions();\n\n        mutate(\n          key,\n          (prevPositions: any) => {\n            // return nextPostions;\n            if (!!prevPositions) {\n              return {\n                ...prevPositions,\n                rows: prevPositions.rows.map((row: any) => {\n                  const item = nextPostions.find(\n                    (item) => item.symbol === row.symbol\n                  );\n                  if (item) {\n                    return {\n                      symbol: item.symbol,\n                      position_qty: item.positionQty,\n                      cost_position: item.costPosition,\n                      last_sum_unitary_funding: item.lastSumUnitaryFunding,\n                      pending_long_qty: item.pendingLongQty,\n                      pending_short_qty: item.pendingShortQty,\n                      settle_price: item.settlePrice,\n                      average_open_price: item.averageOpenPrice,\n                      unsettled_pnl: item.unsettledPnl,\n                      mark_price: item.markPrice,\n                      est_liq_price: item.estLiqPrice,\n                      timestamp: Date.now(),\n                      imr: item.imr,\n                      mmr: item.mmr,\n                      IMR_withdraw_orders: item.imrwithOrders,\n                      MMR_with_orders: item.mmrwithOrders,\n                      pnl_24_h: item.pnl24H,\n                      fee_24_h: item.fee24H,\n                    };\n                  }\n\n                  return row;\n                }),\n              };\n            }\n          },\n          {\n            revalidate: false,\n          }\n        );\n      },\n    });\n    return () => {\n      unsubscribe?.();\n    };\n  }, [state.accountId]);\n\n  // cache algo orders\n  // useEffect(() => {\n  //   const handler = (data: API.AlgoOrder) => {\n  //     algoOrderCacheQuneue.current.push(data);\n  //   };\n\n  //   ee.on(\"algoOrder:cache\", handler);\n\n  //   return () => {\n  //     ee.off(\"algoOrder:cache\", handler);\n  //   };\n  // }, []);\n};\n"],"names":["usePrivateDataObserver","options","ws","useWS","ee","useEventEmitter","state","useAccount","updateOrders","data","isAlgoOrder","keysMap","getKeysMap","forEach","getKey","key","mutate","unstable_serialize","index","prevData","accountId","result","updateAlgoOrdersHandler","updateOrdersHandler","error","revalidate","formattedData","AlgoOrderMergeHandler","groupOrders","object2underscore","emit","status","algo_status","useEffect","unsubscribe","privateSubscribe","onMessage","positions","nextPostions","prevPositions","rows","map","row","item","find","symbol","position_qty","positionQty","cost_position","costPosition","last_sum_unitary_funding","lastSumUnitaryFunding","pending_long_qty","pendingLongQty","pending_short_qty","pendingShortQty","settle_price","settlePrice","average_open_price","averageOpenPrice","unsettled_pnl","unsettledPnl","mark_price","markPrice","est_liq_price","estLiqPrice","timestamp","Date","now","imr","mmr","IMR_withdraw_orders","imrwithOrders","MMR_with_orders","mmrwithOrders","pnl_24_h","pnl24H","fee_24_h","fee24H"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/orderly/useTakeProfitAndStopLoss/__test__/useTakeProfitAndStopLoss.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=useTakeProfitAndStopLoss.test.d.ts.map

package/lib/orderly/useTakeProfitAndStopLoss/__test__/useTakeProfitAndStopLoss.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTakeProfitAndStopLoss.test.d.ts","sourceRoot":"","sources":["../../../../src/orderly/useTakeProfitAndStopLoss/__test__/useTakeProfitAndStopLoss.test.tsx"],"names":[],"mappings":""}

package/lib/orderly/useTakeProfitAndStopLoss/__test__/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/lib/orderly/useTakeProfitAndStopLoss/__test__/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../../src/orderly/useTakeProfitAndStopLoss/__test__/utils.test.ts"],"names":[],"mappings":""}

package/lib/orderly/useTakeProfitAndStopLoss/index.d.ts

@@ -0,0 +1,32 @@
+import { API, AlgoOrderEntity } from "@orderly.network/types";
+export declare const useStopOrder: (position: Partial<API.PositionTPSLExt> & Pick<API.PositionTPSLExt, "symbol" | "average_open_price" | "position_qty">, options?: {
+    /**
+     * You can set the default value for the take profit and stop loss order,
+     * it is usually used when editing order
+     */
+    defaultOrder?: API.AlgoOrder;
+}) => [Partial<import("@orderly.network/types").Optional<import("@orderly.network/types").BaseAlgoOrderEntity<import("@orderly.network/types").AlgoOrderRootType.TP_SL & {
+    tp_pnl: number;
+    tp_offset: number;
+    tp_offset_percentage: number;
+    sl_pnl: number;
+    sl_offset: number;
+    sl_offset_percentage: number;
+}>, "type" | "side" | "order_type" | "trigger_price">>, {
+    setValue: (key: string, value: string | number) => void;
+    setValues: (values: Partial<Partial<import("@orderly.network/types").Optional<import("@orderly.network/types").BaseAlgoOrderEntity<import("@orderly.network/types").AlgoOrderRootType.TP_SL & {
+        tp_pnl: number;
+        tp_offset: number;
+        tp_offset_percentage: number;
+        sl_pnl: number;
+        sl_offset: number;
+        sl_offset_percentage: number;
+    }>, "type" | "side" | "order_type" | "trigger_price">>>) => void;
+    submit: () => Promise<void>;
+    create: () => Promise<void>;
+    update: (orderId: number) => Promise<any>;
+    errors: import("./useTPSL").ValidateError | null;
+    validate: () => Promise<AlgoOrderEntity<import("@orderly.network/types").AlgoOrderRootType.TP_SL | import("@orderly.network/types").AlgoOrderRootType.POSITIONAL_TP_SL>>;
+}];
+export type { ComputedAlgoOrder } from "./useTPSL";
+//# sourceMappingURL=index.d.ts.map

package/lib/orderly/useTakeProfitAndStopLoss/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orderly/useTakeProfitAndStopLoss/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,eAAe,EAAY,MAAM,wBAAwB,CAAC;AAIxE,eAAO,MAAM,YAAY,aAIb,QAAQ,IAAI,eAAe,CAAC,GACpC,KAAK,IAAI,eAAe,EAAE,QAAQ,GAAG,oBAAoB,GAAG,cAAc,CAAC,YACnE;IACR;;;OAGG;IACH,YAAY,CAAC,EAAE,IAAI,SAAS,CAAC;CAC9B;;;;;;;;;;;;;;;;;;;;;;EAuBF,CAAC;AAEF,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC"}

package/lib/orderly/useTakeProfitAndStopLoss/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useStopOrder", {
+    enumerable: true,
+    get: function() {
+        return useStopOrder;
+    }
+});
+const _types = require("@orderly.network/types");
+const _useTPSL = require("./useTPSL");
+const useStopOrder = (/**
+   * Position that needs to set take profit and stop loss
+   */ position, options)=>{
+    if (!position) {
+        throw new _types.SDKError("Position is required");
+    }
+    if (!position.symbol) {
+        throw new _types.SDKError("Symbol is required");
+    }
+    if (typeof position.average_open_price === "undefined") {
+        throw new _types.SDKError("Average open price is required");
+    }
+    if (typeof position.position_qty === "undefined") {
+        throw new _types.SDKError("Position quantity is required");
+    }
+    // const { data: markPrice } = useMarkPrice(position.symbol);
+    const result = (0, _useTPSL.useTaskProfitAndStopLossInternal)(position, options);
+    return result;
+};
+
+//# sourceMappingURL=index.js.map

package/lib/orderly/useTakeProfitAndStopLoss/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/orderly/useTakeProfitAndStopLoss/index.ts"],"sourcesContent":["import { API, AlgoOrderEntity, SDKError } from \"@orderly.network/types\";\nimport { useTaskProfitAndStopLossInternal } from \"./useTPSL\";\nimport { useMarkPrice } from \"../useMarkPrice\";\n\nexport const useStopOrder = (\n  /**\n   * Position that needs to set take profit and stop loss\n   */\n  position: Partial<API.PositionTPSLExt> &\n    Pick<API.PositionTPSLExt, \"symbol\" | \"average_open_price\" | \"position_qty\">,\n  options?: {\n    /**\n     * You can set the default value for the take profit and stop loss order,\n     * it is usually used when editing order\n     */\n    defaultOrder?: API.AlgoOrder;\n  }\n): ReturnType<typeof useTaskProfitAndStopLossInternal> => {\n  if (!position) {\n    throw new SDKError(\"Position is required\");\n  }\n\n  if (!position.symbol) {\n    throw new SDKError(\"Symbol is required\");\n  }\n\n  if (typeof position.average_open_price === \"undefined\") {\n    throw new SDKError(\"Average open price is required\");\n  }\n\n  if (typeof position.position_qty === \"undefined\") {\n    throw new SDKError(\"Position quantity is required\");\n  }\n\n  // const { data: markPrice } = useMarkPrice(position.symbol);\n\n  const result = useTaskProfitAndStopLossInternal(position, options);\n\n  return result;\n};\n\nexport type { ComputedAlgoOrder } from \"./useTPSL\";\n"],"names":["useStopOrder","position","options","SDKError","symbol","average_open_price","position_qty","result","useTaskProfitAndStopLossInternal"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIaA;;;eAAAA;;;uBAJkC;yBACE;AAG1C,MAAMA,eAAe,CAC1B;;GAEC,GACDC,UAEAC;IAQA,IAAI,CAACD,UAAU;QACb,MAAM,IAAIE,eAAQ,CAAC;IACrB;IAEA,IAAI,CAACF,SAASG,MAAM,EAAE;QACpB,MAAM,IAAID,eAAQ,CAAC;IACrB;IAEA,IAAI,OAAOF,SAASI,kBAAkB,KAAK,aAAa;QACtD,MAAM,IAAIF,eAAQ,CAAC;IACrB;IAEA,IAAI,OAAOF,SAASK,YAAY,KAAK,aAAa;QAChD,MAAM,IAAIH,eAAQ,CAAC;IACrB;IAEA,6DAA6D;IAE7D,MAAMI,SAASC,IAAAA,yCAAgC,EAACP,UAAUC;IAE1D,OAAOK;AACT"}

package/lib/orderly/useTakeProfitAndStopLoss/useTPSL.d.ts

@@ -0,0 +1,59 @@
+import { API, AlgoOrderEntity } from "@orderly.network/types";
+import { AlgoOrderRootType } from "@orderly.network/types";
+export type ComputedAlgoOrder = Partial<AlgoOrderEntity<AlgoOrderRootType.TP_SL & {
+    /**
+     * Computed take profit
+     */
+    tp_pnl: number;
+    tp_offset: number;
+    tp_offset_percentage: number;
+    /**
+     * Computed stop loss
+     */
+    sl_pnl: number;
+    sl_offset: number;
+    sl_offset_percentage: number;
+}>>;
+export type ValidateError = {
+    [P in keyof ComputedAlgoOrder]?: {
+        type: string;
+        message: string;
+    };
+};
+/**
+ * @hidden
+ */
+export declare const useTaskProfitAndStopLossInternal: (position: Partial<API.PositionTPSLExt> & Pick<API.PositionTPSLExt, "symbol" | "average_open_price" | "position_qty">, options?: {
+    defaultOrder?: API.AlgoOrder;
+}) => [Partial<import("@orderly.network/types").Optional<import("@orderly.network/types").BaseAlgoOrderEntity<AlgoOrderRootType.TP_SL & {
+    /**
+     * Computed take profit
+     */
+    tp_pnl: number;
+    tp_offset: number;
+    tp_offset_percentage: number;
+    /**
+     * Computed stop loss
+     */
+    sl_pnl: number;
+    sl_offset: number;
+    sl_offset_percentage: number;
+}>, "type" | "side" | "order_type" | "trigger_price">>, {
+    /**
+     * Update the take profit and stop loss order, this will merge the new data with the old one
+     */
+    setValue: (key: string, value: number | string) => void;
+    setValues: (values: Partial<ComputedAlgoOrder>) => void;
+    /**
+     * Submit the take profit and stop loss order
+     */
+    submit: () => Promise<void>;
+    /**
+     * Create the take profit and stop loss order, auto-detect the order type
+     */
+    create: () => Promise<void>;
+    update: (orderId: number) => Promise<any>;
+    errors: ValidateError | null;
+    validate: () => Promise<AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL | AlgoOrderRootType.TP_SL>>;
+}];
+//# sourceMappingURL=useTPSL.d.ts.map

package/lib/orderly/useTakeProfitAndStopLoss/useTPSL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTPSL.d.ts","sourceRoot":"","sources":["../../../src/orderly/useTakeProfitAndStopLoss/useTPSL.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,GAAG,EACH,eAAe,EAGhB,MAAM,wBAAwB,CAAC;AAIhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAO3D,MAAM,MAAM,iBAAiB,GAAG,OAAO,CACrC,eAAe,CACb,iBAAiB,CAAC,KAAK,GAAG;IACxB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CACF,CACF,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;KACzB,CAAC,IAAI,MAAM,iBAAiB,CAAC,CAAC,EAAE;QAC/B,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB;CACF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gCAAgC,aACjC,QAAQ,IAAI,eAAe,CAAC,GACpC,KAAK,IAAI,eAAe,EAAE,QAAQ,GAAG,oBAAoB,GAAG,cAAc,CAAC,YACnE;IACR,YAAY,CAAC,EAAE,IAAI,SAAS,CAAC;CAC9B;IAhCG;;OAEG;YACK,MAAM;eACH,MAAM;0BACK,MAAM;IAE5B;;OAEG;YACK,MAAM;eACH,MAAM;0BACK,MAAM;;IAwB9B;;OAEG;oBACa,MAAM,SAAS,MAAM,GAAG,MAAM,KAAK,IAAI;wBACnC,QAAQ,iBAAiB,CAAC,KAAK,IAAI;IAEvD;;OAEG;YACK,MAAM,QAAQ,IAAI,CAAC;IAC3B;;OAEG;YACK,MAAM,QAAQ,IAAI,CAAC;sBACT,MAAM,KAAK,QAAQ,GAAG,CAAC;YACjC,aAAa,GAAG,IAAI;cAClB,MAAM,QACd,gBACE,kBAAkB,gBAAgB,GAAG,kBAAkB,KAAK,CAC7D,CACF;EAgSJ,CAAC"}

package/lib/orderly/useTakeProfitAndStopLoss/useTPSL.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTaskProfitAndStopLossInternal", {
+    enumerable: true,
+    get: function() {
+        return useTaskProfitAndStopLossInternal;
+    }
+});
+const _react = require("react");
+const _types = require("@orderly.network/types");
+const _utils = require("./utils");
+const _useMutation = require("../../useMutation");
+const _factory = require("../../services/orderCreator/factory");
+const _utils1 = require("../usePositionStream/utils");
+const _useSymbolsInfo = require("../useSymbolsInfo");
+const _useMarkPrice = require("../useMarkPrice");
+const _ramda = require("ramda");
+const useTaskProfitAndStopLossInternal = (position, options)=>{
+    const [order, setOrder] = (0, _react.useState)({
+        algo_order_id: options?.defaultOrder?.algo_order_id,
+        symbol: position.symbol,
+        side: Number(position.position_qty) > 0 ? _types.OrderSide.BUY : _types.OrderSide.SELL,
+        quantity: options?.defaultOrder?.quantity || Math.abs(position.position_qty),
+        algo_type: options?.defaultOrder?.algo_type
+    });
+    const symbolInfo = (0, _useSymbolsInfo.useSymbolsInfo)()[position.symbol]();
+    const { data: markPrice } = (0, _useMarkPrice.useMarkPrice)(order.symbol);
+    const [doCreateOrder] = (0, _useMutation.useMutation)("/v1/algo/order");
+    const [doUpdateOrder] = (0, _useMutation.useMutation)("/v1/algo/order", "PUT");
+    const [doDeleteOrder] = (0, _useMutation.useMutation)("/v1/algo/order", "DELETE");
+    const [errors, setErrors] = (0, _react.useState)(null);
+    (0, _react.useEffect)(()=>{
+        if (!options?.defaultOrder) return;
+        const trigger_prices = (0, _utils1.findTPSLFromOrder)(options.defaultOrder);
+        if (trigger_prices.tp_trigger_price) {
+            setOrderValue("tp_trigger_price", trigger_prices.tp_trigger_price, {
+                ignoreValidate: true
+            });
+        }
+        if (trigger_prices.sl_trigger_price) {
+            setOrderValue("sl_trigger_price", trigger_prices.sl_trigger_price, {
+                ignoreValidate: true
+            });
+        }
+    }, []);
+    const _setOrderValue = (key, value, options)=>{
+        ;
+        setOrder((prev)=>{
+            const side = position.position_qty > 0 ? _types.OrderSide.BUY : _types.OrderSide.SELL;
+            if (key === "sl_pnl") {
+                value = value ? `-${value}` : "";
+            }
+            const newValue = (0, _utils.calculateHelper)(key, {
+                key,
+                value,
+                entryPrice: position.average_open_price,
+                qty: side === _types.OrderSide.BUY ? Number(prev.quantity) : -Number(prev.quantity),
+                orderSide: side
+            }, {
+                symbol: symbolInfo
+            });
+            ;
+            return {
+                ...prev,
+                ...newValue,
+                ignoreValidate: options?.ignoreValidate
+            };
+        });
+    };
+    const setOrderValue = async (key, value, options)=>{
+        if (key === "quantity") {
+            setOrder((prev)=>({
+                    ...prev,
+                    quantity: value
+                }));
+            if (typeof order.sl_trigger_price !== "undefined") {
+                _setOrderValue("sl_trigger_price", order.sl_trigger_price, {
+                    ignoreValidate: true
+                });
+            }
+            if (typeof order.tp_trigger_price !== "undefined") {
+                _setOrderValue("tp_trigger_price", order.tp_trigger_price, {
+                    ignoreValidate: true
+                });
+            }
+            return;
+        }
+        _setOrderValue(key, value, options);
+    };
+    /**
+   * calculate value config
+   */ const valueConfig = {
+        symbol: symbolInfo,
+        maxQty: Math.abs(position.position_qty),
+        markPrice
+    };
+    // auto validate when order changed
+    (0, _react.useEffect)(()=>{
+        requestAnimationFrame(()=>{
+            if (order.ignoreValidate) return;
+            const orderCreator = getOrderCreator();
+            orderCreator.validate(order, valueConfig).then((errors)=>{
+                setErrors(errors);
+            });
+        });
+    }, [
+        order,
+        valueConfig.markPrice,
+        order.quantity
+    ]);
+    const setValues = (values)=>{
+        const keys = Object.keys(values);
+        keys.forEach((key)=>{
+            setOrderValue(key, values[key]);
+        });
+    };
+    const validate = ()=>{
+        const orderCreator = getOrderCreator();
+        return new Promise((resolve, reject)=>{
+            return orderCreator.validate(order, valueConfig).then((errors)=>{
+                ;
+                if (errors) {
+                    setErrors(errors);
+                    return reject(errors);
+                }
+                resolve(orderCreator.create(order, valueConfig));
+            });
+        });
+    };
+    (0, _react.useEffect)(()=>{
+    // setError(validate());
+    }, [
+        order
+    ]);
+    const compare = ()=>{
+        const quantityNum = Number(order.quantity);
+        if (isNaN(quantityNum)) return false;
+        return quantityNum === Math.abs(Number(position.position_qty));
+    };
+    const getOrderCreator = ()=>{
+        // if the order is existed, and the order type is POSITIONAL_TP_SL, always return POSITIONAL_TP_SL
+        // else use qty to determine the order type
+        if (options?.defaultOrder?.algo_type === _types.AlgoOrderRootType.TP_SL) {
+            return _factory.OrderFactory.create(_types.AlgoOrderRootType.TP_SL);
+        }
+        return _factory.OrderFactory.create(compare() ? _types.AlgoOrderRootType.POSITIONAL_TP_SL : _types.AlgoOrderRootType.TP_SL);
+    };
+    const submit = async ()=>{
+        const defaultOrder = options?.defaultOrder;
+        const orderId = defaultOrder?.algo_order_id;
+        const algoType = defaultOrder?.algo_type;
+        // if algo_order_id is not existed, create new order
+        if (!orderId) {
+            return createOrder();
+        }
+        // if algo_order_id is existed and algoType = POSITION_TP_SL
+        if (algoType === _types.AlgoOrderRootType.POSITIONAL_TP_SL) {
+            // if order.qty = position.qty, update order
+            if (compare()) {
+                return updateOrder(orderId);
+            }
+            // if order.qty != position.qty, create new tp/sl order
+            return createOrder();
+        }
+        // if algo_order_id is existed and algoType = TP_SL, delete order and create new order
+        return updateOrder(orderId);
+    };
+    const createOrder = ()=>{
+        const orderCreator = getOrderCreator();
+        const orderBody = orderCreator.create(order, valueConfig);
+        if (orderBody.child_orders.length === 0) {
+            throw new _types.SDKError("No child orders");
+        }
+        return doCreateOrder(orderBody);
+    };
+    const deleteOrder = (orderId, symbol)=>{
+        return doDeleteOrder(null, {
+            order_id: orderId,
+            symbol
+        });
+    };
+    const updateOrder = (orderId)=>{
+        const orderCreator = getOrderCreator();
+        const [updatedOrderEntity, orderEntity] = orderCreator.crateUpdateOrder(// @ts-ignore
+        order, options?.defaultOrder, valueConfig);
+        if (updatedOrderEntity.child_orders.length === 0) {
+            return Promise.resolve("Not any order needs to update");
+        }
+        const needDelete = orderEntity.child_orders.filter((order)=>typeof order.is_activated === "boolean" && !order.is_activated).length === 2;
+        if (needDelete) {
+            return deleteOrder(orderId, order.symbol);
+        }
+        return doUpdateOrder({
+            order_id: orderId,
+            ...updatedOrderEntity
+        });
+    };
+    return [
+        (0, _ramda.omit)([
+            "ignoreValidate"
+        ], order),
+        {
+            submit,
+            create: submit,
+            update: updateOrder,
+            setValue: setOrderValue,
+            setValues,
+            // createPositionTPSL: submit,
+            // createTPSL: submit,
+            validate,
+            errors
+        }
+    ];
+};
+
+//# sourceMappingURL=useTPSL.js.map

package/lib/orderly/useTakeProfitAndStopLoss/useTPSL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/orderly/useTakeProfitAndStopLoss/useTPSL.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nimport {\n  API,\n  AlgoOrderEntity,\n  OrderSide,\n  SDKError,\n} from \"@orderly.network/types\";\nimport { UpdateOrderKey, calculateHelper } from \"./utils\";\nimport { useMutation } from \"../../useMutation\";\nimport { OrderFactory } from \"../../services/orderCreator/factory\";\nimport { AlgoOrderRootType } from \"@orderly.network/types\";\nimport { TPSLPositionOrderCreator } from \"../../services/orderCreator/tpslPositionOrderCreator\";\nimport { findTPSLFromOrder } from \"../usePositionStream/utils\";\nimport { useSymbolsInfo } from \"../useSymbolsInfo\";\nimport { useMarkPrice } from \"../useMarkPrice\";\nimport { omit } from \"ramda\";\n\nexport type ComputedAlgoOrder = Partial<\n  AlgoOrderEntity<\n    AlgoOrderRootType.TP_SL & {\n      /**\n       * Computed take profit\n       */\n      tp_pnl: number;\n      tp_offset: number;\n      tp_offset_percentage: number;\n\n      /**\n       * Computed stop loss\n       */\n      sl_pnl: number;\n      sl_offset: number;\n      sl_offset_percentage: number;\n    }\n  >\n>;\n\nexport type ValidateError = {\n  [P in keyof ComputedAlgoOrder]?: {\n    type: string;\n    message: string;\n  };\n};\n\n/**\n * @hidden\n */\nexport const useTaskProfitAndStopLossInternal = (\n  position: Partial<API.PositionTPSLExt> &\n    Pick<API.PositionTPSLExt, \"symbol\" | \"average_open_price\" | \"position_qty\">,\n  options?: {\n    defaultOrder?: API.AlgoOrder;\n  }\n): [\n  ComputedAlgoOrder,\n  {\n    /**\n     * Update the take profit and stop loss order, this will merge the new data with the old one\n     */\n    setValue: (key: string, value: number | string) => void;\n    setValues: (values: Partial<ComputedAlgoOrder>) => void;\n    // getOrderEntity: () => AlgoOrderEntity<AlgoOrderRootType.TP_SL|AlgoOrderRootType.POSITIONAL_TP_SL>;\n    /**\n     * Submit the take profit and stop loss order\n     */\n    submit: () => Promise<void>;\n    /**\n     * Create the take profit and stop loss order, auto-detect the order type\n     */\n    create: () => Promise<void>;\n    update: (orderId: number) => Promise<any>;\n    errors: ValidateError | null;\n    validate: () => Promise<\n      AlgoOrderEntity<\n        AlgoOrderRootType.POSITIONAL_TP_SL | AlgoOrderRootType.TP_SL\n      >\n    >;\n  }\n] => {\n  const [order, setOrder] = useState<\n    ComputedAlgoOrder & {\n      ignoreValidate?: boolean;\n    }\n  >({\n    algo_order_id: options?.defaultOrder?.algo_order_id,\n    symbol: position.symbol as string,\n    side: Number(position.position_qty) > 0 ? OrderSide.BUY : OrderSide.SELL,\n    quantity:\n      options?.defaultOrder?.quantity || Math.abs(position.position_qty),\n    algo_type: options?.defaultOrder?.algo_type as AlgoOrderRootType,\n  });\n\n  const symbolInfo = useSymbolsInfo()[position.symbol!]();\n  const { data: markPrice } = useMarkPrice(order.symbol!);\n\n  const [doCreateOrder] = useMutation(\"/v1/algo/order\");\n  const [doUpdateOrder] = useMutation(\"/v1/algo/order\", \"PUT\");\n  const [doDeleteOrder] = useMutation(\"/v1/algo/order\", \"DELETE\");\n\n  const [errors, setErrors] = useState<ValidateError | null>(null);\n\n  useEffect(() => {\n    if (!options?.defaultOrder) return;\n    const trigger_prices = findTPSLFromOrder(options.defaultOrder!);\n    if (trigger_prices.tp_trigger_price) {\n      setOrderValue(\"tp_trigger_price\", trigger_prices.tp_trigger_price, {\n        ignoreValidate: true,\n      });\n    }\n    if (trigger_prices.sl_trigger_price) {\n      setOrderValue(\"sl_trigger_price\", trigger_prices.sl_trigger_price, {\n        ignoreValidate: true,\n      });\n    }\n  }, []);\n\n  const _setOrderValue = (\n    key: string,\n    value: number | string,\n    options?: {\n      ignoreValidate?: boolean;\n    }\n  ) => {\n    console.log(\"[updateOrder:]\", key, value, order.quantity);\n\n    setOrder((prev) => {\n      const side = position.position_qty! > 0 ? OrderSide.BUY : OrderSide.SELL;\n\n      if (key === \"sl_pnl\") {\n        value = value ? `-${value}` : \"\";\n      }\n\n      const newValue = calculateHelper(\n        key,\n        {\n          key,\n          value,\n          entryPrice: position.average_open_price!,\n          qty:\n            side === OrderSide.BUY\n              ? Number(prev.quantity)!\n              : -Number(prev.quantity)!,\n          orderSide: side,\n        },\n        {\n          symbol: symbolInfo,\n        }\n      );\n\n      console.log(\"newValue::\", newValue);\n\n      return {\n        ...prev,\n        ...newValue,\n        ignoreValidate: options?.ignoreValidate,\n      };\n    });\n  };\n\n  const setOrderValue = async (\n    key: string,\n    value: number | string,\n    options?: {\n      ignoreValidate?: boolean;\n    }\n  ) => {\n    if (key === \"quantity\") {\n      setOrder((prev) => ({ ...prev, quantity: value }));\n\n      if (typeof order.sl_trigger_price !== \"undefined\") {\n        _setOrderValue(\"sl_trigger_price\", order.sl_trigger_price, {\n          ignoreValidate: true,\n        });\n      }\n\n      if (typeof order.tp_trigger_price !== \"undefined\") {\n        _setOrderValue(\"tp_trigger_price\", order.tp_trigger_price, {\n          ignoreValidate: true,\n        });\n      }\n\n      return;\n    }\n\n    _setOrderValue(key, value, options);\n  };\n\n  /**\n   * calculate value config\n   */\n  const valueConfig = {\n    symbol: symbolInfo,\n    maxQty: Math.abs(position.position_qty),\n    markPrice,\n  };\n\n  // auto validate when order changed\n  useEffect(() => {\n    requestAnimationFrame(() => {\n      if (order.ignoreValidate) return;\n      const orderCreator = getOrderCreator();\n      orderCreator\n        .validate(order as AlgoOrderEntity, valueConfig)\n        .then((errors) => {\n          setErrors(errors);\n        });\n    });\n  }, [order, valueConfig.markPrice, order.quantity]);\n\n  const setValues = (values: Partial<ComputedAlgoOrder>) => {\n    const keys = Object.keys(values);\n    keys.forEach((key) => {\n      setOrderValue(\n        key as UpdateOrderKey,\n        values[key as keyof ComputedAlgoOrder] as number | string\n      );\n    });\n  };\n\n  const validate = (): Promise<\n    AlgoOrderEntity<\n      AlgoOrderRootType.POSITIONAL_TP_SL | AlgoOrderRootType.TP_SL\n    >\n  > => {\n    const orderCreator = getOrderCreator();\n\n    return new Promise((resolve, reject) => {\n      return orderCreator\n        .validate(\n          order as AlgoOrderEntity<AlgoOrderRootType.TP_SL>,\n          valueConfig\n        )\n        .then((errors) => {\n          console.log(\"errors::\", errors);\n\n          if (errors) {\n            setErrors(errors);\n            return reject(errors);\n          }\n\n          resolve(\n            orderCreator.create(\n              order as AlgoOrderEntity<AlgoOrderRootType.TP_SL>,\n              valueConfig\n            )\n          );\n        });\n    });\n  };\n\n  useEffect(() => {\n    // setError(validate());\n  }, [order]);\n\n  const compare = (): boolean => {\n    const quantityNum = Number(order.quantity);\n    if (isNaN(quantityNum)) return false;\n    return quantityNum === Math.abs(Number(position.position_qty));\n  };\n\n  const getOrderCreator = () => {\n    // if the order is existed, and the order type is POSITIONAL_TP_SL, always return POSITIONAL_TP_SL\n    // else use qty to determine the order type\n    if (options?.defaultOrder?.algo_type === AlgoOrderRootType.TP_SL) {\n      return OrderFactory.create(AlgoOrderRootType.TP_SL);\n    }\n    return OrderFactory.create(\n      compare() ? AlgoOrderRootType.POSITIONAL_TP_SL : AlgoOrderRootType.TP_SL\n    );\n  };\n\n  const submit = async () => {\n    const defaultOrder = options?.defaultOrder;\n    const orderId = defaultOrder?.algo_order_id;\n    const algoType = defaultOrder?.algo_type;\n\n    // if algo_order_id is not existed, create new order\n    if (!orderId) {\n      return createOrder();\n    }\n\n    // if algo_order_id is existed and algoType = POSITION_TP_SL\n    if (algoType === AlgoOrderRootType.POSITIONAL_TP_SL) {\n      // if order.qty = position.qty, update order\n      if (compare()) {\n        return updateOrder(orderId!);\n      }\n      // if order.qty != position.qty, create new tp/sl order\n      return createOrder();\n    }\n\n    // if algo_order_id is existed and algoType = TP_SL, delete order and create new order\n\n    return updateOrder(orderId!);\n  };\n\n  const createOrder = () => {\n    const orderCreator = getOrderCreator();\n\n    const orderBody = orderCreator.create(\n      order as AlgoOrderEntity<AlgoOrderRootType.TP_SL>,\n      valueConfig\n    );\n\n    if (orderBody.child_orders.length === 0) {\n      throw new SDKError(\"No child orders\");\n    }\n\n    return doCreateOrder(orderBody);\n  };\n\n  const deleteOrder = (orderId: number, symbol: string): Promise<any> => {\n    return doDeleteOrder(null, {\n      order_id: orderId,\n      symbol,\n    });\n  };\n\n  const updateOrder = (orderId: number): Promise<any> => {\n    const orderCreator = getOrderCreator() as TPSLPositionOrderCreator;\n\n    const [updatedOrderEntity, orderEntity] = orderCreator.crateUpdateOrder(\n      // @ts-ignore\n      order,\n      options?.defaultOrder,\n      valueConfig\n    );\n\n    if (updatedOrderEntity.child_orders.length === 0) {\n      return Promise.resolve(\"Not any order needs to update\");\n    }\n\n    const needDelete =\n      orderEntity.child_orders.filter(\n        (order) =>\n          typeof order.is_activated === \"boolean\" && !order.is_activated\n      ).length === 2;\n\n    if (needDelete) {\n      return deleteOrder(orderId, order.symbol!);\n    }\n\n    return doUpdateOrder({\n      order_id: orderId,\n      ...updatedOrderEntity,\n    });\n  };\n\n  return [\n    omit([\"ignoreValidate\"], order) as ComputedAlgoOrder,\n    {\n      submit,\n\n      create: submit,\n\n      update: updateOrder,\n      setValue: setOrderValue,\n      setValues,\n      // createPositionTPSL: submit,\n      // createTPSL: submit,\n      validate,\n      errors,\n    },\n  ];\n};\n"],"names":["useTaskProfitAndStopLossInternal","position","options","order","setOrder","useState","algo_order_id","defaultOrder","symbol","side","Number","position_qty","OrderSide","BUY","SELL","quantity","Math","abs","algo_type","symbolInfo","useSymbolsInfo","data","markPrice","useMarkPrice","doCreateOrder","useMutation","doUpdateOrder","doDeleteOrder","errors","setErrors","useEffect","trigger_prices","findTPSLFromOrder","tp_trigger_price","setOrderValue","ignoreValidate","sl_trigger_price","_setOrderValue","key","value","prev","newValue","calculateHelper","entryPrice","average_open_price","qty","orderSide","valueConfig","maxQty","requestAnimationFrame","orderCreator","getOrderCreator","validate","then","setValues","values","keys","Object","forEach","Promise","resolve","reject","create","compare","quantityNum","isNaN","AlgoOrderRootType","TP_SL","OrderFactory","POSITIONAL_TP_SL","submit","orderId","algoType","createOrder","updateOrder","orderBody","child_orders","length","SDKError","deleteOrder","order_id","updatedOrderEntity","orderEntity","crateUpdateOrder","needDelete","filter","is_activated","omit","update","setValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}