@backtest-kit/ui 7.7.0 → 8.0.0

package/build/index.mjs

@@ -17,6 +17,8 @@ import { existsSync } from 'fs';
 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 BehaviorSubject();
@@ -76,6 +78,8 @@ const mockServices$1 = {
     explorerMockService: Symbol("explorerMockService"),
     signalMockService: Symbol("signalMockService"),
     heatMockService: Symbol("heatMockService"),
+    performanceMockService: Symbol("performanceMockService"),
+    environmentMockService: Symbol("environmentMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
@@ -87,6 +91,8 @@ const viewServices$1 = {
     explorerViewService: Symbol("explorerViewService"),
     signalViewService: Symbol("signalViewService"),
     heatViewService: Symbol("heatViewService"),
+    performanceViewService: Symbol("performanceViewService"),
+    environmentViewService: Symbol("environmentViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -767,14 +773,14 @@ class SignalMockService {
     }
 }
 
-const MOCK_DATA_PATH = "./mock/heat.json";
-const MOCK_REPORT_PATH = "./mock/heat-report.md";
+const MOCK_DATA_PATH$2 = "./mock/heat.json";
+const MOCK_REPORT_PATH$1 = "./mock/heat-report.md";
 const READ_HEAT_DATA_FN = singleshot(async () => {
-    const data = await fs.readFile(MOCK_DATA_PATH, "utf-8");
+    const data = await fs.readFile(MOCK_DATA_PATH$2, "utf-8");
     return JSON.parse(data);
 });
 const READ_HEAT_REPORT_FN = singleshot(async () => {
-    return await fs.readFile(MOCK_REPORT_PATH, "utf-8");
+    return await fs.readFile(MOCK_REPORT_PATH$1, "utf-8");
 });
 class HeatMockService {
     constructor() {
@@ -1215,7 +1221,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,
@@ -1223,6 +1229,9 @@ class StatusViewService {
                             maxDrawdown,
                             expectancy,
                             totalTrades,
+                            sortinoRatio,
+                            calmarRatio,
+                            recoveryFactor,
                         })),
                         backtest: true,
                     };
@@ -1245,7 +1254,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,
@@ -1253,6 +1262,9 @@ class StatusViewService {
                             maxDrawdown,
                             expectancy,
                             totalTrades,
+                            sortinoRatio,
+                            calmarRatio,
+                            recoveryFactor,
                         })),
                         backtest: false,
                     };
@@ -1833,6 +1845,117 @@ class LiveMetaService {
     }
 }
 
+const MOCK_DATA_PATH$1 = "./mock/performance.json";
+const MOCK_REPORT_PATH = "./mock/performance-report.md";
+const READ_PERFORMANCE_DATA_FN = singleshot(async () => {
+    const data = await fs.readFile(MOCK_DATA_PATH$1, "utf-8");
+    return JSON.parse(data);
+});
+const READ_PERFORMANCE_REPORT_FN = 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 = "./mock/environment.json";
+const READ_ENVIRONMENT_DATA_FN = singleshot(async () => {
+    const data = await fs.readFile(MOCK_DATA_PATH, "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();
+        };
+    }
+}
+
+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 Backtest.list();
+            const [liveItem] = await Live.list();
+            if (backtestItem) {
+                return await Performance.getData(backtestItem.symbol, {
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                }, true);
+            }
+            if (liveItem) {
+                return await 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 Backtest.list();
+            const [liveItem] = await Live.list();
+            if (backtestItem) {
+                return await Performance.getReport(backtestItem.symbol, {
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                }, true);
+            }
+            if (liveItem) {
+                return await 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,
+            };
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
     provide(TYPES.exchangeService, () => new ExchangeService());
@@ -1856,6 +1979,8 @@ 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.notificationViewService, () => new NotificationViewService());
@@ -1867,6 +1992,8 @@ 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());
 }
 
 const baseServices = {
@@ -1892,6 +2019,8 @@ const mockServices = {
     explorerMockService: inject(TYPES.explorerMockService),
     signalMockService: inject(TYPES.signalMockService),
     heatMockService: inject(TYPES.heatMockService),
+    performanceMockService: inject(TYPES.performanceMockService),
+    environmentMockService: inject(TYPES.environmentMockService),
 };
 const viewServices = {
     notificationViewService: inject(TYPES.notificationViewService),
@@ -1903,6 +2032,8 @@ const viewServices = {
     explorerViewService: inject(TYPES.explorerViewService),
     signalViewService: inject(TYPES.signalViewService),
     heatViewService: inject(TYPES.heatViewService),
+    performanceViewService: inject(TYPES.performanceViewService),
+    environmentViewService: inject(TYPES.environmentViewService),
 };
 const ioc = {
     ...baseServices,
@@ -2527,6 +2658,92 @@ 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
 
 const router$9 = Router({
     params: true,
@@ -3142,6 +3359,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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
 
 const require$1 = createRequire(import.meta.url);
 function getModulesPath() {