@backtest-kit/ui 7.8.0 → 8.1.0

package/build/index.cjs

@@ -20,6 +20,8 @@ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentS
 const CC_WWWROOT_PATH = process.env.CC_WWWROOT_PATH || "";
 const CC_WWWROOT_HOST = process.env.CC_WWWROOT_HOST || "0.0.0.0";
 const CC_WWWROOT_PORT = parseInt(process.env.CC_WWWROOT_PORT) || 60050;
+const CC_TELEGRAM_CHANNEL = process.env.CC_TELEGRAM_CHANNEL || "";
+const CC_QUICKCHART_HOST = process.env.CC_QUICKCHART_HOST || "";
 const CC_ENABLE_MOCK = !!parseInt(process.env.CC_ENABLE_MOCK) || false;
 
 const serveSubject = new functoolsKit.BehaviorSubject();
@@ -79,6 +81,9 @@ const mockServices$1 = {
     explorerMockService: Symbol("explorerMockService"),
     signalMockService: Symbol("signalMockService"),
     heatMockService: Symbol("heatMockService"),
+    performanceMockService: Symbol("performanceMockService"),
+    environmentMockService: Symbol("environmentMockService"),
+    setupMockService: Symbol("setupMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
@@ -90,6 +95,9 @@ const viewServices$1 = {
     explorerViewService: Symbol("explorerViewService"),
     signalViewService: Symbol("signalViewService"),
     heatViewService: Symbol("heatViewService"),
+    performanceViewService: Symbol("performanceViewService"),
+    environmentViewService: Symbol("environmentViewService"),
+    setupViewService: Symbol("setupViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -770,14 +778,14 @@ class SignalMockService {
     }
 }
 
-const MOCK_DATA_PATH = "./mock/heat.json";
-const MOCK_REPORT_PATH = "./mock/heat-report.md";
+const MOCK_DATA_PATH$3 = "./mock/heat.json";
+const MOCK_REPORT_PATH$1 = "./mock/heat-report.md";
 const READ_HEAT_DATA_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_DATA_PATH, "utf-8");
+    const data = await fs.readFile(MOCK_DATA_PATH$3, "utf-8");
     return JSON.parse(data);
 });
 const READ_HEAT_REPORT_FN = functoolsKit.singleshot(async () => {
-    return await fs.readFile(MOCK_REPORT_PATH, "utf-8");
+    return await fs.readFile(MOCK_REPORT_PATH$1, "utf-8");
 });
 class HeatMockService {
     constructor() {
@@ -1218,7 +1226,7 @@ class StatusViewService {
                         portfolioTotalPnl: currentHeat.portfolioTotalPnl,
                         portfolioSharpeRatio: currentHeat.portfolioSharpeRatio,
                         portfolioTotalTrades: currentHeat.portfolioTotalTrades,
-                        symbols: currentHeat.symbols.map(({ symbol, totalPnl, winRate, profitFactor, maxDrawdown, expectancy, totalTrades }) => ({
+                        symbols: currentHeat.symbols.map(({ symbol, totalPnl, winRate, profitFactor, maxDrawdown, expectancy, totalTrades, sortinoRatio, calmarRatio, recoveryFactor }) => ({
                             symbol,
                             totalPnl,
                             winRate,
@@ -1226,6 +1234,9 @@ class StatusViewService {
                             maxDrawdown,
                             expectancy,
                             totalTrades,
+                            sortinoRatio,
+                            calmarRatio,
+                            recoveryFactor,
                         })),
                         backtest: true,
                     };
@@ -1248,7 +1259,7 @@ class StatusViewService {
                         portfolioTotalPnl: currentHeat.portfolioTotalPnl,
                         portfolioSharpeRatio: currentHeat.portfolioSharpeRatio,
                         portfolioTotalTrades: currentHeat.portfolioTotalTrades,
-                        symbols: currentHeat.symbols.map(({ symbol, totalPnl, winRate, profitFactor, maxDrawdown, expectancy, totalTrades }) => ({
+                        symbols: currentHeat.symbols.map(({ symbol, totalPnl, winRate, profitFactor, maxDrawdown, expectancy, totalTrades, sortinoRatio, calmarRatio, recoveryFactor }) => ({
                             symbol,
                             totalPnl,
                             winRate,
@@ -1256,6 +1267,9 @@ class StatusViewService {
                             maxDrawdown,
                             expectancy,
                             totalTrades,
+                            sortinoRatio,
+                            calmarRatio,
+                            recoveryFactor,
                         })),
                         backtest: false,
                     };
@@ -1836,6 +1850,183 @@ class LiveMetaService {
     }
 }
 
+const MOCK_DATA_PATH$2 = "./mock/performance.json";
+const MOCK_REPORT_PATH = "./mock/performance-report.md";
+const READ_PERFORMANCE_DATA_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_DATA_PATH$2, "utf-8");
+    return JSON.parse(data);
+});
+const READ_PERFORMANCE_REPORT_FN = functoolsKit.singleshot(async () => {
+    return await fs.readFile(MOCK_REPORT_PATH, "utf-8");
+});
+class PerformanceMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getPerformanceData = async () => {
+            this.loggerService.log("performanceMockService getPerformanceData");
+            return await READ_PERFORMANCE_DATA_FN();
+        };
+        this.getPerformanceReport = async () => {
+            this.loggerService.log("performanceMockService getPerformanceReport");
+            return await READ_PERFORMANCE_REPORT_FN();
+        };
+    }
+}
+
+const MOCK_DATA_PATH$1 = "./mock/environment.json";
+const READ_ENVIRONMENT_DATA_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_DATA_PATH$1, "utf-8");
+    return JSON.parse(data);
+});
+class EnvironmentMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getEnvironmentData = async () => {
+            this.loggerService.log("environmentMockService getEnvironmentData");
+            return await READ_ENVIRONMENT_DATA_FN();
+        };
+    }
+}
+
+const MOCK_DATA_PATH = "./mock/setup.json";
+const READ_SETUP_DATA_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_DATA_PATH, "utf-8");
+    return JSON.parse(data);
+});
+class SetupMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getSetupData = async () => {
+            this.loggerService.log("setupMockService getSetupData");
+            return await READ_SETUP_DATA_FN();
+        };
+    }
+}
+
+class PerformanceViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.performanceMockService = inject(TYPES.performanceMockService);
+        this.getPerformanceData = async () => {
+            this.loggerService.log("performanceViewService getPerformanceData");
+            if (CC_ENABLE_MOCK) {
+                return await this.performanceMockService.getPerformanceData();
+            }
+            const [backtestItem] = await backtestKit.Backtest.list();
+            const [liveItem] = await backtestKit.Live.list();
+            if (backtestItem) {
+                return await backtestKit.Performance.getData(backtestItem.symbol, {
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                }, true);
+            }
+            if (liveItem) {
+                return await backtestKit.Performance.getData(liveItem.symbol, {
+                    strategyName: liveItem.strategyName,
+                    exchangeName: liveItem.exchangeName,
+                    frameName: "",
+                }, false);
+            }
+            return null;
+        };
+        this.getPerformanceReport = async () => {
+            this.loggerService.log("performanceViewService getPerformanceReport");
+            if (CC_ENABLE_MOCK) {
+                return await this.performanceMockService.getPerformanceReport();
+            }
+            const [backtestItem] = await backtestKit.Backtest.list();
+            const [liveItem] = await backtestKit.Live.list();
+            if (backtestItem) {
+                return await backtestKit.Performance.getReport(backtestItem.symbol, {
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                }, true);
+            }
+            if (liveItem) {
+                return await backtestKit.Performance.getReport(liveItem.symbol, {
+                    strategyName: liveItem.strategyName,
+                    exchangeName: liveItem.exchangeName,
+                    frameName: "",
+                }, false);
+            }
+            return null;
+        };
+    }
+}
+
+class EnvironmentViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.enviromentMockService = inject(TYPES.environmentMockService);
+        this.getEnvironmentData = async () => {
+            this.loggerService.log("environmentViewService getEnvironmentData");
+            if (CC_ENABLE_MOCK) {
+                return await this.enviromentMockService.getEnvironmentData();
+            }
+            return {
+                quickchart_host: CC_QUICKCHART_HOST,
+                telegram_channel: CC_TELEGRAM_CHANNEL,
+                wwwroot_host: CC_WWWROOT_HOST,
+                wwwroot_path: CC_WWWROOT_PATH,
+                wwwroot_port: CC_WWWROOT_PORT,
+            };
+        };
+    }
+}
+
+const GET_MODE_FN = async () => {
+    const [backtestTarget = null] = await backtestKit.Backtest.list();
+    if (backtestTarget) {
+        return "backtest";
+    }
+    const [liveTarget = null] = await backtestKit.Live.list();
+    if (liveTarget) {
+        return "live";
+    }
+    return "none";
+};
+class SetupViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.setupMockService = inject(TYPES.setupMockService);
+        this.getSetupData = async () => {
+            this.loggerService.log("setupViewService getSetupData");
+            if (CC_ENABLE_MOCK) {
+                return await this.setupMockService.getSetupData();
+            }
+            const broker_enabled = backtestKit.Broker.enable.hasValue();
+            const dump_enabled = backtestKit.Dump.enable.hasValue();
+            const markdown_enabled = backtestKit.Markdown.enable.hasValue();
+            const memory_enabled = backtestKit.Memory.enable.hasValue();
+            const notification_enabled = backtestKit.Notification.enable.hasValue();
+            const recent_enabled = backtestKit.Recent.enable.hasValue();
+            const report_enabled = backtestKit.Report.enable.hasValue();
+            const state_enabled = backtestKit.State.enable.hasValue();
+            const storage_enabled = backtestKit.Storage.enable.hasValue();
+            const running_mode = await GET_MODE_FN();
+            const config = await backtestKit.getConfig();
+            const enable_long = config.CC_ENABLE_LONG_SIGNAL;
+            const enable_short = config.CC_ENABLE_SHORT_SIGNAL;
+            return {
+                broker_enabled,
+                dump_enabled,
+                markdown_enabled,
+                memory_enabled,
+                notification_enabled,
+                recent_enabled,
+                report_enabled,
+                state_enabled,
+                storage_enabled,
+                running_mode,
+                enable_long,
+                enable_short,
+            };
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
     provide(TYPES.exchangeService, () => new ExchangeService());
@@ -1859,6 +2050,9 @@ class LiveMetaService {
     provide(TYPES.explorerMockService, () => new ExplorerMockService());
     provide(TYPES.signalMockService, () => new SignalMockService());
     provide(TYPES.heatMockService, () => new HeatMockService());
+    provide(TYPES.performanceMockService, () => new PerformanceMockService());
+    provide(TYPES.environmentMockService, () => new EnvironmentMockService());
+    provide(TYPES.setupMockService, () => new SetupMockService());
 }
 {
     provide(TYPES.notificationViewService, () => new NotificationViewService());
@@ -1870,6 +2064,9 @@ class LiveMetaService {
     provide(TYPES.explorerViewService, () => new ExplorerViewService());
     provide(TYPES.signalViewService, () => new SignalViewService());
     provide(TYPES.heatViewService, () => new HeatViewService());
+    provide(TYPES.performanceViewService, () => new PerformanceViewService());
+    provide(TYPES.environmentViewService, () => new EnvironmentViewService());
+    provide(TYPES.setupViewService, () => new SetupViewService());
 }
 
 const baseServices = {
@@ -1895,6 +2092,9 @@ const mockServices = {
     explorerMockService: inject(TYPES.explorerMockService),
     signalMockService: inject(TYPES.signalMockService),
     heatMockService: inject(TYPES.heatMockService),
+    performanceMockService: inject(TYPES.performanceMockService),
+    environmentMockService: inject(TYPES.environmentMockService),
+    setupMockService: inject(TYPES.setupMockService),
 };
 const viewServices = {
     notificationViewService: inject(TYPES.notificationViewService),
@@ -1906,6 +2106,9 @@ const viewServices = {
     explorerViewService: inject(TYPES.explorerViewService),
     signalViewService: inject(TYPES.signalViewService),
     heatViewService: inject(TYPES.heatViewService),
+    performanceViewService: inject(TYPES.performanceViewService),
+    environmentViewService: inject(TYPES.environmentViewService),
+    setupViewService: inject(TYPES.setupViewService),
 };
 const ioc = {
     ...baseServices,
@@ -1919,6 +2122,35 @@ init();
 const router$a = Router({
     params: true,
 });
+// SetupMockService endpoints
+router$a.post("/api/v1/mock/setup_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.setupMockService.getSetupData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/setup_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/setup_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // ExchangeMockService endpoints
 router$a.post("/api/v1/mock/candles_signal", async (req, res) => {
     try {
@@ -2530,10 +2762,125 @@ router$a.post("/api/v1/mock/status_info", async (req, res) => {
         });
     }
 });
+// PerformanceMockService endpoints
+router$a.post("/api/v1/mock/performance_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.performanceMockService.getPerformanceData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/performance_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/performance_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/mock/performance_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.performanceMockService.getPerformanceReport();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/performance_report ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/performance_report error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+// EnvironmentMockService endpoints
+router$a.post("/api/v1/mock/environment_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.environmentMockService.getEnvironmentData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/environment_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/environment_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 
 const router$9 = Router({
     params: true,
 });
+// SetupViewService endpoints
+router$9.post("/api/v1/view/setup_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.setupViewService.getSetupData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/setup_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/setup_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // ExchangeViewService endpoints
 router$9.post("/api/v1/view/candles_signal", async (req, res) => {
     try {
@@ -3145,6 +3492,92 @@ router$9.post("/api/v1/view/status_info", async (req, res) => {
         });
     }
 });
+// PerformanceViewService endpoints
+router$9.post("/api/v1/view/performance_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.performanceViewService.getPerformanceData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/performance_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/performance_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$9.post("/api/v1/view/performance_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.performanceViewService.getPerformanceReport();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/performance_report ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/performance_report error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+// EnvironmentViewService endpoints
+router$9.post("/api/v1/view/environment_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.environmentViewService.getEnvironmentData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/environment_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/environment_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 
 const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 function getModulesPath() {