@orderly.network/hooks 1.5.13 → 2.0.0-alpha.0

package/lib/orderly/useSymbolLeverage.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "useSymbolLeverage", {
-    enumerable: true,
-    get: function() {
-        return useSymbolLeverage;
-    }
-});
-const _react = require("react");
-const _useQuery = require("../useQuery");
-const _useAccountInfo = require("./useAccountInfo");
-const useSymbolLeverage = (symbol)=>{
-    const { data: info } = (0, _useAccountInfo.useAccountInfo)();
-    const maxAccountLeverage = info?.max_leverage;
-    const res = (0, _useQuery.useQuery)(`/v1/public/info/${symbol}`, {
-        dedupingInterval: 1000 * 60 * 60 * 24,
-        revalidateOnFocus: false,
-        errorRetryCount: 2,
-        errorRetryInterval: 200
-    });
-    const maxSymbolLeverage = (0, _react.useMemo)(()=>{
-        const base = res?.data?.base_imr;
-        if (base) return 1 / base;
-    }, [
-        res
-    ]);
-    const maxLeverage = (0, _react.useMemo)(()=>{
-        if (!maxAccountLeverage || !maxSymbolLeverage) {
-            return "-";
-        }
-        return Math.min(maxAccountLeverage, maxSymbolLeverage);
-    }, [
-        maxAccountLeverage,
-        maxSymbolLeverage
-    ]);
-    return maxLeverage;
-};
-
-//# sourceMappingURL=useSymbolLeverage.js.map

package/lib/orderly/useSymbolLeverage.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/orderly/useSymbolLeverage.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useQuery } from \"../useQuery\";\nimport { useAccountInfo } from \"./useAccountInfo\";\n\nexport const useSymbolLeverage = (symbol: string) : number | \"-\" => {\n  const { data: info } = useAccountInfo();\n\n  const maxAccountLeverage = info?.max_leverage;\n\n  const res = useQuery<any>(`/v1/public/info/${symbol}`, {\n    dedupingInterval: 1000 * 60 * 60 * 24,\n    revalidateOnFocus: false,\n    errorRetryCount: 2,\n    errorRetryInterval: 200,\n  });\n\n  const maxSymbolLeverage = useMemo(() => {\n    const base = res?.data?.base_imr;\n    if (base) return 1 / base;\n  }, [res]);\n\n  const maxLeverage = useMemo(() => {\n    if (!maxAccountLeverage || !maxSymbolLeverage) {\n      return \"-\";\n    }\n\n    return Math.min(maxAccountLeverage, maxSymbolLeverage);\n  }, [maxAccountLeverage, maxSymbolLeverage]);\n\n  return maxLeverage;\n};\n"],"names":["useSymbolLeverage","symbol","data","info","useAccountInfo","maxAccountLeverage","max_leverage","res","useQuery","dedupingInterval","revalidateOnFocus","errorRetryCount","errorRetryInterval","maxSymbolLeverage","useMemo","base","base_imr","maxLeverage","Math","min"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIaA;;;eAAAA;;;uBAJW;0BACC;gCACM;AAExB,MAAMA,oBAAoB,CAACC;IAChC,MAAM,EAAEC,MAAMC,IAAI,EAAE,GAAGC,IAAAA,8BAAc;IAErC,MAAMC,qBAAqBF,MAAMG;IAEjC,MAAMC,MAAMC,IAAAA,kBAAQ,EAAM,CAAC,gBAAgB,EAAEP,OAAO,CAAC,EAAE;QACrDQ,kBAAkB,OAAO,KAAK,KAAK;QACnCC,mBAAmB;QACnBC,iBAAiB;QACjBC,oBAAoB;IACtB;IAEA,MAAMC,oBAAoBC,IAAAA,cAAO,EAAC;QAChC,MAAMC,OAAOR,KAAKL,MAAMc;QACxB,IAAID,MAAM,OAAO,IAAIA;IACvB,GAAG;QAACR;KAAI;IAER,MAAMU,cAAcH,IAAAA,cAAO,EAAC;QAC1B,IAAI,CAACT,sBAAsB,CAACQ,mBAAmB;YAC7C,OAAO;QACT;QAEA,OAAOK,KAAKC,GAAG,CAACd,oBAAoBQ;IACtC,GAAG;QAACR;QAAoBQ;KAAkB;IAE1C,OAAOI;AACT"}

package/lib/orderly/useSymbolPriceRange.d.ts

@@ -1,13 +0,0 @@
-export type PriceRange = {
-    min: number;
-    max: number;
-};
-/**
- * Get the price range for the specified symbol with an optional price
- *
- * @param symbol - The symbol to get the price range for
- * @param price - Optional parameter to set the price
- * @returns PriceRange | undefined - Returns the PriceRange representing the price range or undefined
- */
-export declare const useSymbolPriceRange: (symbol: string, side: "BUY" | "SELL", price?: number) => PriceRange | undefined;
-//# sourceMappingURL=useSymbolPriceRange.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useSymbolPriceRange.d.ts","sourceRoot":"","sources":["../../src/orderly/useSymbolPriceRange.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,UAAU,GAAG;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,WAAY,MAAM,QAAQ,KAAK,GAAG,MAAM,UAAU,MAAM,KAAG,UAAU,GAAG,SAiCvG,CAAA"}

package/lib/orderly/useSymbolPriceRange.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "useSymbolPriceRange", {
-    enumerable: true,
-    get: function() {
-        return useSymbolPriceRange;
-    }
-});
-const _utils = require("@orderly.network/utils");
-const _useSymbolsInfo = require("./useSymbolsInfo");
-const _useMarkPricesStream = require("./useMarkPricesStream");
-const _react = require("react");
-const useSymbolPriceRange = (symbol, side, price)=>{
-    const config = (0, _useSymbolsInfo.useSymbolsInfo)();
-    const priceRange = config?.[symbol]("price_range");
-    const priceScrope = config?.[symbol]("price_scope");
-    const { data: prices } = (0, _useMarkPricesStream.useMarkPricesStream)();
-    const markPrice = price || prices?.[symbol];
-    /// max mark_price_i * (1+price_range)
-    /// min mark_price_i * (1-price_range)
-    const range = (0, _react.useMemo)(()=>{
-        if (config === undefined || markPrice === undefined) {
-            return undefined;
-        }
-        if (priceRange === undefined || Number.isNaN(markPrice)) {
-            return undefined;
-        }
-        if (side === "BUY") {
-            return {
-                max: new _utils.Decimal(markPrice).mul(1 + priceRange).toNumber(),
-                min: new _utils.Decimal(markPrice).mul(1 - priceScrope).toNumber()
-            };
-        }
-        return {
-            max: new _utils.Decimal(markPrice).mul(1 + priceScrope).toNumber(),
-            min: new _utils.Decimal(markPrice).mul(1 - priceRange).toNumber()
-        };
-    }, [
-        symbol,
-        side,
-        priceRange,
-        markPrice
-    ]);
-    return range;
-};
-
-//# sourceMappingURL=useSymbolPriceRange.js.map

package/lib/orderly/useSymbolPriceRange.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/orderly/useSymbolPriceRange.ts"],"sourcesContent":["import { Decimal } from \"@orderly.network/utils\";\nimport { useSymbolsInfo } from \"./useSymbolsInfo\";\nimport { useMarkPricesStream } from \"./useMarkPricesStream\";\nimport { useEffect, useMemo, useState } from \"react\";\n\n// Define the PriceRange type to represent a range of prices\nexport type PriceRange = {\n    min: number,\n    max: number,\n};\n\n/**\n * Get the price range for the specified symbol with an optional price\n *\n * @param symbol - The symbol to get the price range for\n * @param price - Optional parameter to set the price\n * @returns PriceRange | undefined - Returns the PriceRange representing the price range or undefined\n */\nexport const useSymbolPriceRange = (symbol: string, side: \"BUY\" | \"SELL\", price?: number): PriceRange | undefined => {\n    const config = useSymbolsInfo();\n    const priceRange = config?.[symbol](\"price_range\");\n    const priceScrope = config?.[symbol](\"price_scope\");\n    const { data: prices } = useMarkPricesStream();\n    const markPrice = price || prices?.[symbol];\n\n    /// max mark_price_i * (1+price_range)\n    /// min mark_price_i * (1-price_range)\n\n    const range = useMemo(() => {\n        if (config === undefined || markPrice === undefined) {\n            return undefined;\n        }\n\n        if (priceRange === undefined || Number.isNaN(markPrice)) {\n            return undefined;\n        }\n\n        if (side === \"BUY\") {\n            return {\n                max: new Decimal(markPrice).mul((1 + priceRange)).toNumber(),\n                min: new Decimal(markPrice).mul((1 - priceScrope)).toNumber(),\n            };\n        }\n\n        return {\n            max: new Decimal(markPrice).mul((1 + priceScrope)).toNumber(),\n            min: new Decimal(markPrice).mul((1 - priceRange)).toNumber(),\n        };\n    }, [symbol, side, priceRange, markPrice]);\n\n    return range;\n}"],"names":["useSymbolPriceRange","symbol","side","price","config","useSymbolsInfo","priceRange","priceScrope","data","prices","useMarkPricesStream","markPrice","range","useMemo","undefined","Number","isNaN","max","Decimal","mul","toNumber","min"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAkBaA;;;eAAAA;;;uBAlBW;gCACO;qCACK;uBACS;AAetC,MAAMA,sBAAsB,CAACC,QAAgBC,MAAsBC;IACtE,MAAMC,SAASC,IAAAA,8BAAc;IAC7B,MAAMC,aAAaF,QAAQ,CAACH,OAAO,CAAC;IACpC,MAAMM,cAAcH,QAAQ,CAACH,OAAO,CAAC;IACrC,MAAM,EAAEO,MAAMC,MAAM,EAAE,GAAGC,IAAAA,wCAAmB;IAC5C,MAAMC,YAAYR,SAASM,QAAQ,CAACR,OAAO;IAE3C,sCAAsC;IACtC,sCAAsC;IAEtC,MAAMW,QAAQC,IAAAA,cAAO,EAAC;QAClB,IAAIT,WAAWU,aAAaH,cAAcG,WAAW;YACjD,OAAOA;QACX;QAEA,IAAIR,eAAeQ,aAAaC,OAAOC,KAAK,CAACL,YAAY;YACrD,OAAOG;QACX;QAEA,IAAIZ,SAAS,OAAO;YAChB,OAAO;gBACHe,KAAK,IAAIC,cAAO,CAACP,WAAWQ,GAAG,CAAE,IAAIb,YAAac,QAAQ;gBAC1DC,KAAK,IAAIH,cAAO,CAACP,WAAWQ,GAAG,CAAE,IAAIZ,aAAca,QAAQ;YAC/D;QACJ;QAEA,OAAO;YACHH,KAAK,IAAIC,cAAO,CAACP,WAAWQ,GAAG,CAAE,IAAIZ,aAAca,QAAQ;YAC3DC,KAAK,IAAIH,cAAO,CAACP,WAAWQ,GAAG,CAAE,IAAIb,YAAac,QAAQ;QAC9D;IACJ,GAAG;QAACnB;QAAQC;QAAMI;QAAYK;KAAU;IAExC,OAAOC;AACX"}

package/lib/orderly/useSymbolsInfo.d.ts

@@ -1,7 +0,0 @@
-import { type API } from "@orderly.network/types";
-export declare const useSymbolsInfo: () => {
-    [x: string]: (key?: keyof API.SymbolExt | undefined, defaultValue?: (string | number) | undefined) => any;
-} & {
-    isNil: boolean;
-};
-//# sourceMappingURL=useSymbolsInfo.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useSymbolsInfo.d.ts","sourceRoot":"","sources":["../../src/orderly/useSymbolsInfo.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAIlD,eAAO,MAAM,cAAc;;;;CAgC1B,CAAC"}

package/lib/orderly/useSymbolsInfo.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "useSymbolsInfo", {
-    enumerable: true,
-    get: function() {
-        return useSymbolsInfo;
-    }
-});
-const _useQuery = require("../useQuery");
-const _createGetter = require("../utils/createGetter");
-const _utils = require("@orderly.network/utils");
-const useSymbolsInfo = ()=>{
-    const { data } = (0, _useQuery.useQuery)(`/v1/public/info`, {
-        focusThrottleInterval: 1000 * 60 * 60 * 24,
-        dedupingInterval: 1000 * 60 * 60 * 24,
-        revalidateOnFocus: false,
-        formatter (data) {
-            if (!data?.rows || !data?.rows?.length) {
-                return {};
-            }
-            const obj = Object.create(null);
-            for(let index = 0; index < data.rows.length; index++){
-                const item = data.rows[index];
-                const arr = item.symbol.split("_");
-                const base_dp = (0, _utils.getPrecisionByNumber)(item.base_tick);
-                const quote_dp = (0, _utils.getPrecisionByNumber)(item.quote_tick);
-                obj[item.symbol] = {
-                    ...item,
-                    base_dp,
-                    quote_dp,
-                    base: arr[1],
-                    quote: arr[2],
-                    type: arr[0],
-                    name: `${arr[1]}-${arr[0]}`
-                };
-            }
-            return obj;
-        }
-    });
-    return (0, _createGetter.createGetter)(data);
-};
-
-//# sourceMappingURL=useSymbolsInfo.js.map

package/lib/orderly/useSymbolsInfo.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/orderly/useSymbolsInfo.ts"],"sourcesContent":["import { useQuery } from \"../useQuery\";\nimport { type API } from \"@orderly.network/types\";\nimport { createGetter } from \"../utils/createGetter\";\nimport { getPrecisionByNumber } from \"@orderly.network/utils\";\n\nexport const useSymbolsInfo = () => {\n  const { data } = useQuery<Record<string, API.SymbolExt>>(`/v1/public/info`, {\n    focusThrottleInterval: 1000 * 60 * 60 * 24,\n    dedupingInterval: 1000 * 60 * 60 * 24,\n    revalidateOnFocus: false,\n    formatter(data: { rows: API.Symbol[] }) {\n      if (!data?.rows || !data?.rows?.length) {\n        return {};\n      }\n      const obj = Object.create(null);\n\n      for (let index = 0; index < data.rows.length; index++) {\n        const item = data.rows[index];\n        const arr = item.symbol.split(\"_\");\n        const base_dp = getPrecisionByNumber(item.base_tick);\n        const quote_dp = getPrecisionByNumber(item.quote_tick);\n        obj[item.symbol] = {\n          ...item,\n          base_dp,\n          quote_dp,\n          base: arr[1],\n          quote: arr[2],\n          type: arr[0],\n          name: `${arr[1]}-${arr[0]}`,\n        };\n      }\n\n      return obj;\n    },\n  });\n\n  return createGetter<API.SymbolExt, string>(data);\n};\n"],"names":["useSymbolsInfo","data","useQuery","focusThrottleInterval","dedupingInterval","revalidateOnFocus","formatter","rows","length","obj","Object","create","index","item","arr","symbol","split","base_dp","getPrecisionByNumber","base_tick","quote_dp","quote_tick","base","quote","type","name","createGetter"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;0BALY;8BAEI;uBACQ;AAE9B,MAAMA,iBAAiB;IAC5B,MAAM,EAAEC,IAAI,EAAE,GAAGC,IAAAA,kBAAQ,EAAgC,CAAC,eAAe,CAAC,EAAE;QAC1EC,uBAAuB,OAAO,KAAK,KAAK;QACxCC,kBAAkB,OAAO,KAAK,KAAK;QACnCC,mBAAmB;QACnBC,WAAUL,IAA4B;YACpC,IAAI,CAACA,MAAMM,QAAQ,CAACN,MAAMM,MAAMC,QAAQ;gBACtC,OAAO,CAAC;YACV;YACA,MAAMC,MAAMC,OAAOC,MAAM,CAAC;YAE1B,IAAK,IAAIC,QAAQ,GAAGA,QAAQX,KAAKM,IAAI,CAACC,MAAM,EAAEI,QAAS;gBACrD,MAAMC,OAAOZ,KAAKM,IAAI,CAACK,MAAM;gBAC7B,MAAME,MAAMD,KAAKE,MAAM,CAACC,KAAK,CAAC;gBAC9B,MAAMC,UAAUC,IAAAA,2BAAoB,EAACL,KAAKM,SAAS;gBACnD,MAAMC,WAAWF,IAAAA,2BAAoB,EAACL,KAAKQ,UAAU;gBACrDZ,GAAG,CAACI,KAAKE,MAAM,CAAC,GAAG;oBACjB,GAAGF,IAAI;oBACPI;oBACAG;oBACAE,MAAMR,GAAG,CAAC,EAAE;oBACZS,OAAOT,GAAG,CAAC,EAAE;oBACbU,MAAMV,GAAG,CAAC,EAAE;oBACZW,MAAM,CAAC,EAAEX,GAAG,CAAC,EAAE,CAAC,CAAC,EAAEA,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC7B;YACF;YAEA,OAAOL;QACT;IACF;IAEA,OAAOiB,IAAAA,0BAAY,EAAwBzB;AAC7C"}

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

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

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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,30 +0,0 @@
-import { API } from "@orderly.network/types";
-export declare const useTPSLOrder: (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<Omit<import("@orderly.network/types").BaseAlgoOrderEntity<import("@orderly.network/types").AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price"> & Partial<Pick<import("@orderly.network/types").BaseAlgoOrderEntity<import("@orderly.network/types").AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price">> & {
-    tp_pnl: number;
-    tp_offset: number;
-    tp_offset_percentage: number;
-    sl_pnl: number;
-    sl_offset: number;
-    sl_offset_percentage: number;
-}>, {
-    setValue: (key: string, value: string | number) => void;
-    setValues: (values: Partial<Partial<Omit<import("@orderly.network/types").BaseAlgoOrderEntity<import("@orderly.network/types").AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price"> & Partial<Pick<import("@orderly.network/types").BaseAlgoOrderEntity<import("@orderly.network/types").AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price">> & {
-        tp_pnl: number;
-        tp_offset: number;
-        tp_offset_percentage: number;
-        sl_pnl: number;
-        sl_offset: number;
-        sl_offset_percentage: number;
-    }>>) => void;
-    submit: () => Promise<void>;
-    errors: import("./useTPSL").ValidateError | null;
-    validate: () => Promise<import("@orderly.network/types").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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orderly/useTakeProfitAndStopLoss/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAY,MAAM,wBAAwB,CAAC;AAGvD,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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "useTPSLOrder", {
-    enumerable: true,
-    get: function() {
-        return useTPSLOrder;
-    }
-});
-const _types = require("@orderly.network/types");
-const _useTPSL = require("./useTPSL");
-const useTPSLOrder = (/**
-   * 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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/orderly/useTakeProfitAndStopLoss/index.ts"],"sourcesContent":["import { API, SDKError } from \"@orderly.network/types\";\nimport { useTaskProfitAndStopLossInternal } from \"./useTPSL\";\n\nexport const useTPSLOrder = (\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":["useTPSLOrder","position","options","SDKError","symbol","average_open_price","position_qty","result","useTaskProfitAndStopLossInternal"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;uBAHiB;yBACmB;AAE1C,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

@@ -1,57 +0,0 @@
-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<Omit<import("@orderly.network/types").BaseAlgoOrderEntity<AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price"> & Partial<Pick<import("@orderly.network/types").BaseAlgoOrderEntity<AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price">> & {
-    /**
-     * 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;
-}>, {
-    /**
-     * 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 TP/SL order
-     */
-    submit: () => Promise<void>;
-    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

@@ -1 +0,0 @@
-{"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,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG;IACzC;;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,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;IA/BC;;OAEG;YACK,MAAM;eACH,MAAM;0BACK,MAAM;IAE5B;;OAEG;YACK,MAAM;eACH,MAAM;0BACK,MAAM;;IA0B5B;;OAEG;oBACa,MAAM,SAAS,MAAM,GAAG,MAAM,KAAK,IAAI;wBACnC,QAAQ,iBAAiB,CAAC,KAAK,IAAI;IAEvD;;OAEG;YACK,MAAM,QAAQ,IAAI,CAAC;YAMnB,aAAa,GAAG,IAAI;IAC5B;;OAEG;cACO,MAAM,QACd,gBACE,kBAAkB,gBAAgB,GAAG,kBAAkB,KAAK,CAC7D,CACF;EAoSJ,CAAC"}

package/lib/orderly/useTakeProfitAndStopLoss/useTPSL.js

@@ -1,218 +0,0 @@
-"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)=>{
-        // console.log("-------->>>>>", key, value);
-        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));
-            });
-        });
-    };
-    // 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");
-        }
-        // filter the order that is not activated
-        orderBody.child_orders = orderBody.child_orders.filter((order)=>order.is_activated);
-        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 === orderEntity.child_orders.length;
-        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

@@ -1 +0,0 @@
-{"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<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\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  /**\n   * return the computed & formatted order\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 TP/SL 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    /**\n     *\n     */\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);\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      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    // console.log(\"-------->>>>>\", key, value);\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    // filter the order that is not activated\n    orderBody.child_orders = orderBody.child_orders.filter(\n      (order: API.AlgoOrderExt) => order.is_activated\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 === orderEntity.child_orders.length;\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","filter","is_activated","deleteOrder","order_id","updatedOrderEntity","orderEntity","crateUpdateOrder","needDelete","omit","setValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}