@ch20026103/anysis 0.0.18 → 0.0.19-alpha1

package/demo/main.js

@@ -1,9 +1,9 @@
 /* eslint @typescript-eslint/no-var-requires: "off" */
 const axios = require("axios");
-const { Mfi } = require("../dist/cjs/index.js");
+const { Ichimoku } = require("../dist/cjs/index.js");
 
 // 使用示例
-const mfi = new Mfi();
+const ad = new Ichimoku();
 function DemoDay(stockId) {
   axios
     .get(
@@ -45,11 +45,11 @@ function DemoDay(stockId) {
       }
 
 
-      let mfiData = mfi.init(response[0], 14);
+      let adData = ad.init(response[0], 14);
       for (let i = 1; i < response.length; i++) {
-        mfiData = mfi.next(response[i], mfiData, 14);
+        adData = ad.next(response[i], adData, 14);
       }
-      console.log(mfiData);
+      console.log(adData);
     })
     .catch((error) => {
       console.error(error);

package/dist/cjs/index.d.ts

@@ -20,6 +20,7 @@ export { default as Vma } from "./stockSkills/vma.js";
 export { default as Williams } from "./stockSkills/williams.js";
 export { default as ObvEma } from "./stockSkills/obv_ema.js";
 export { default as Mfi } from "./stockSkills/mfi.js";
+export { default as Ichimoku } from "./stockSkills/ichimoku.js";
 export { add } from "./test/add.js";
 export { minus } from "./test/minus.js";
 export { default as calculateDivisionFactor } from "./utils/calculateDivisionFactor.js";

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLsusbOutput = exports.isJSON = exports.calculateDivisionFactor = exports.minus = exports.add = exports.Mfi = exports.ObvEma = exports.Williams = exports.Vma = exports.Week = exports.dateFormat = exports.Rsi = exports.Obv = exports.Macd = exports.Ma = exports.Kd = exports.Gold = exports.Ema = exports.Boll = exports.calcSeasonalIndicesNoTrend = exports.weightMovingAverages = exports.movingAverages = exports.exponentialSmoothing = exports.findTroughByGradient = exports.findPeaksByGradient = exports.SwingExtremesType = exports.SwingExtremes = exports.slope = exports.simpleRegressionModel = exports.Angle = void 0;
+exports.parseLsusbOutput = exports.isJSON = exports.calculateDivisionFactor = exports.minus = exports.add = exports.Ichimoku = exports.Mfi = exports.ObvEma = exports.Williams = exports.Vma = exports.Week = exports.dateFormat = exports.Rsi = exports.Obv = exports.Macd = exports.Ma = exports.Kd = exports.Gold = exports.Ema = exports.Boll = exports.calcSeasonalIndicesNoTrend = exports.weightMovingAverages = exports.movingAverages = exports.exponentialSmoothing = exports.findTroughByGradient = exports.findPeaksByGradient = exports.SwingExtremesType = exports.SwingExtremes = exports.slope = exports.simpleRegressionModel = exports.Angle = void 0;
 /*
   請注意，在 src/index.ts 中，我的導入包含文件擴展名(.js)。
   如果需要支持 Node.js 和構建工具（ex: webpack），則不需要這樣做。 **因為commonJs默認js副檔名**
@@ -51,6 +51,8 @@ var obv_ema_js_1 = require("./stockSkills/obv_ema.js");
 Object.defineProperty(exports, "ObvEma", { enumerable: true, get: function () { return obv_ema_js_1.default; } });
 var mfi_js_1 = require("./stockSkills/mfi.js");
 Object.defineProperty(exports, "Mfi", { enumerable: true, get: function () { return mfi_js_1.default; } });
+var ichimoku_js_1 = require("./stockSkills/ichimoku.js");
+Object.defineProperty(exports, "Ichimoku", { enumerable: true, get: function () { return ichimoku_js_1.default; } });
 var add_js_1 = require("./test/add.js");
 Object.defineProperty(exports, "add", { enumerable: true, get: function () { return add_js_1.add; } });
 var minus_js_1 = require("./test/minus.js");

package/dist/cjs/stockSkills/ichimoku.d.ts

@@ -0,0 +1,35 @@
+import { StockListType, StockType } from "./types";
+type NewStockType = Required<Pick<StockType, "v" | "h" | "l" | "c">> & StockType;
+export type IchimokuValType = {
+    tenkan: number | null;
+    kijun: number | null;
+    senkouA: number | null;
+    senkouB: number | null;
+    chikou: number | null;
+};
+export type IchimokuResType = {
+    dataset: Readonly<StockListType>;
+    ichimoku: IchimokuValType;
+};
+interface IchimokuType {
+    init: (data: NewStockType) => IchimokuResType;
+    next: (data: NewStockType, preList: IchimokuResType) => IchimokuResType;
+}
+export default class IchimokuCloud implements IchimokuType {
+    init(data: NewStockType): IchimokuResType;
+    /**
+     * 優化說明：
+     * 如果 preList.dataset 是一個可變陣列，我們直接 push 以達到最佳效能 O(1)。
+     * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
+     * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
+     */
+    next(data: NewStockType, preList: IchimokuResType): IchimokuResType;
+    private calcIchimoku;
+    /**
+     * 優化：
+     * 1. 移除 .slice()，避免產生 Garbage Collection。
+     * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
+     */
+    private getMidPrice;
+}
+export {};

package/dist/cjs/stockSkills/ichimoku.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IchimokuCloud = /** @class */ (function () {
+    function IchimokuCloud() {
+    }
+    Object.defineProperty(IchimokuCloud.prototype, "init", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data) {
+            var dataset = [data];
+            return {
+                dataset: dataset,
+                ichimoku: this.calcIchimoku(dataset, dataset.length - 1),
+            };
+        }
+    });
+    /**
+     * 優化說明：
+     * 如果 preList.dataset 是一個可變陣列，我們直接 push 以達到最佳效能 O(1)。
+     * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
+     * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
+     */
+    Object.defineProperty(IchimokuCloud.prototype, "next", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, preList) {
+            // 強制轉型以進行 push (避免 typescript 報錯 readonly)
+            var mutableDataset = preList.dataset;
+            mutableDataset.push(data);
+            // 只需要計算最後一筆
+            var currentResult = this.calcIchimoku(mutableDataset, mutableDataset.length - 1);
+            return {
+                dataset: mutableDataset,
+                ichimoku: currentResult,
+            };
+        }
+    });
+    // 核心計算邏輯
+    Object.defineProperty(IchimokuCloud.prototype, "calcIchimoku", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataList, i) {
+            var currentData = dataList[i];
+            // 優化：直接傳入 index 與 list，不產生新陣列
+            var tenkanVal = this.getMidPrice(dataList, i, 9);
+            var kijunVal = this.getMidPrice(dataList, i, 26);
+            var senkouBVal = this.getMidPrice(dataList, i, 52);
+            var senkouAVal = null;
+            if (tenkanVal !== null && kijunVal !== null) {
+                senkouAVal = (tenkanVal + kijunVal) / 2;
+            }
+            return {
+                tenkan: tenkanVal,
+                kijun: kijunVal,
+                senkouA: senkouAVal,
+                senkouB: senkouBVal,
+                chikou: currentData.c,
+            };
+        }
+    });
+    /**
+     * 優化：
+     * 1. 移除 .slice()，避免產生 Garbage Collection。
+     * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
+     */
+    Object.defineProperty(IchimokuCloud.prototype, "getMidPrice", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list, currentIndex, periods) {
+            if (currentIndex < periods - 1) {
+                return null;
+            }
+            // 計算視窗的起始 index
+            var start = currentIndex - (periods - 1);
+            // 初始化最大最小
+            // 小技巧：直接拿第一個值當初始值，避免 Infinity 的比較
+            var maxH = list[start].h;
+            var minL = list[start].l;
+            // 從 start + 1 開始遍歷到 currentIndex
+            for (var j = start + 1; j <= currentIndex; j++) {
+                var _a = list[j], h = _a.h, l = _a.l;
+                if (h > maxH)
+                    maxH = h;
+                if (l < minL)
+                    minL = l;
+            }
+            return (maxH + minL) / 2;
+        }
+    });
+    return IchimokuCloud;
+}());
+exports.default = IchimokuCloud;

package/dist/cjs/stockSkills/ichimoku.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/stockSkills/ichimoku.test.js

@@ -0,0 +1,158 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var vitest_1 = require("vitest");
+var ichimoku_1 = require("./ichimoku");
+// 輔助函式：快速產生測試用的假資料
+var createStock = function (idx, override) {
+    return __assign({ t: idx, o: 100, c: 100, h: 100, l: 100, v: 1000 }, override);
+};
+(0, vitest_1.describe)("IchimokuCloud Algo", function () {
+    var ichimoku;
+    (0, vitest_1.beforeEach)(function () {
+        ichimoku = new ichimoku_1.default();
+    });
+    (0, vitest_1.describe)("init", function () {
+        (0, vitest_1.it)("should initialize with correct structure", function () {
+            var data = createStock(0, { c: 150 });
+            var res = ichimoku.init(data);
+            (0, vitest_1.expect)(res.dataset).toHaveLength(1);
+            (0, vitest_1.expect)(res.dataset[0]).toEqual(data);
+            // 第一筆資料，除了 chikou (收盤價) 外，其他應為 null
+            (0, vitest_1.expect)(res.ichimoku.chikou).toBe(150);
+            (0, vitest_1.expect)(res.ichimoku.tenkan).toBeNull();
+            (0, vitest_1.expect)(res.ichimoku.kijun).toBeNull();
+            (0, vitest_1.expect)(res.ichimoku.senkouA).toBeNull();
+            (0, vitest_1.expect)(res.ichimoku.senkouB).toBeNull();
+        });
+    });
+    (0, vitest_1.describe)("next & Logic Calculation", function () {
+        (0, vitest_1.it)("should accumulate dataset correctly", function () {
+            var res = ichimoku.init(createStock(0));
+            res = ichimoku.next(createStock(1), res);
+            res = ichimoku.next(createStock(2), res);
+            (0, vitest_1.expect)(res.dataset).toHaveLength(3);
+            (0, vitest_1.expect)(res.dataset[2].t).toBe(2);
+        });
+        (0, vitest_1.it)("should calculate Tenkan-sen (9 periods) correctly", function () {
+            // 策略：建立 8 筆資料，確認 Tenkan 為 null
+            // 再加第 9 筆，確認 Tenkan 有值
+            // 設定數據：High 逐漸增加 (10~90)，Low 保持 0
+            // 預期結果：(MaxHigh(90) + MinLow(0)) / 2 = 45
+            var res = ichimoku.init(createStock(0, { h: 10, l: 0 }));
+            // 加入第 2 到第 8 筆 (共 8 筆)
+            for (var i = 1; i < 8; i++) {
+                res = ichimoku.next(createStock(i, { h: (i + 1) * 10, l: 0 }), res);
+                (0, vitest_1.expect)(res.ichimoku.tenkan).toBeNull(); // 資料不足 9 筆
+            }
+            // 加入第 9 筆
+            res = ichimoku.next(createStock(8, { h: 90, l: 0 }), res);
+            // 驗證
+            (0, vitest_1.expect)(res.dataset).toHaveLength(9);
+            (0, vitest_1.expect)(res.ichimoku.tenkan).toBe(45); // (90 + 0) / 2
+        });
+        (0, vitest_1.it)("should calculate Kijun-sen (26 periods) correctly", function () {
+            // 策略：直接灌入 25 筆資料
+            // 第 1 筆 Low = 10，第 26 筆 High = 110，中間平穩
+            // Kijun = (110 + 10) / 2 = 60
+            var res = ichimoku.init(createStock(0, { h: 50, l: 10 })); // 最低點在 index 0
+            // 填補中間資料 (index 1 ~ 24)
+            for (var i = 1; i < 25; i++) {
+                res = ichimoku.next(createStock(i, { h: 50, l: 50 }), res);
+                (0, vitest_1.expect)(res.ichimoku.kijun).toBeNull(); // 資料不足 26 筆
+            }
+            // 加入第 26 筆 (index 25)
+            res = ichimoku.next(createStock(25, { h: 110, l: 50 }), res); // 最高點在 index 25
+            (0, vitest_1.expect)(res.dataset).toHaveLength(26);
+            (0, vitest_1.expect)(res.ichimoku.kijun).toBe(60); // (110 + 10) / 2
+        });
+        (0, vitest_1.it)("should calculate Senkou Span A correctly", function () {
+            // Senkou A = (Tenkan + Kijun) / 2
+            // 我們需要至少 26 筆資料讓 Kijun 有值 (此時 Tenkan 也有值)
+            var res = ichimoku.init(createStock(0));
+            // 我們設計一個場景：
+            // 過去 9 天 (Tenkan window): Max=20, Min=10 -> Tenkan = 15
+            // 過去 26 天 (Kijun window): Max=30, Min=0 -> Kijun = 15
+            // 預期 Senkou A = (15 + 15) / 2 = 15
+            // 先塞入前段資料
+            for (var i = 1; i < 26; i++) {
+                // 為了方便控制，我們讓最後一筆資料決定極值
+                // 這裡隨便塞，只要最後一筆能控制範圍即可，因為我們邏輯是找區間最大最小
+                // 但為了確保 Kijun 區間的 Min 是 0，我們在 index 0 設 l=0
+                // 為了確保 Kijun 區間的 Max 是 30，我們在 index 0 設 h=30 (如果它是最大)
+                // 簡單化：讓資料全部平躺，最後一瞬間拉高拉低
+                // 這裡不用迴圈邏輯太複雜，直接用輔助函式慢慢疊
+                res = ichimoku.next(createStock(i), res);
+            }
+            // 重新建立一個乾淨的測試流程，比較好控制數學
+            // Reset
+            res = ichimoku.init(createStock(0, { h: 100, l: 100 }));
+            // 填充 24 筆 (共 25 筆)
+            for (var i = 1; i < 25; i++) {
+                res = ichimoku.next(createStock(i, { h: 100, l: 100 }), res);
+            }
+            // 第 26 筆 (Index 25) 進來，決定生死
+            // Kijun 看過去 26 筆 (idx 0~25)
+            // Tenkan 看過去 9 筆 (idx 17~25)
+            // 設定目標：
+            // Tenkan: Max=110, Min=90 => Avg=100
+            // Kijun: Max=120, Min=80 => Avg=100
+            // SenkouA => 100
+            // 修改 dataset 裡的值 (模擬真實波動)
+            // 讓 index 0 (很久以前) 有個極低值 80 (影響 Kijun 不影響 Tenkan)
+            // 讓 index 0 有個極高值 120 (影響 Kijun 不影響 Tenkan)
+            // 注意：上面的 init 和 next 已經把資料寫死為 100 了，這在單元測試有點難搞
+            // 所以我們用更簡單的方法：在 next 過程中精準控制
+            // --- 重來：精準控制版 ---
+            var ichi = new ichimoku_1.default();
+            var r = ichi.init(createStock(0, { h: 120, l: 80 })); // Kijun Range: H=120, L=80
+            // 填滿中間 16 筆 (Index 1~16)，數值平穩不影響極值，且不讓 Tenkan 抓到
+            for (var i = 1; i <= 16; i++) {
+                r = ichi.next(createStock(i, { h: 100, l: 100 }), r);
+            }
+            // 接下來 8 筆 (Index 17~24)，準備進入 Tenkan 範圍
+            // 我們讓 Tenkan 範圍 (包含下一筆 index 25) 為 H=110, L=90
+            for (var i = 17; i <= 24; i++) {
+                r = ichi.next(createStock(i, { h: 110, l: 90 }), r);
+            }
+            // 第 26 筆 (Index 25)
+            r = ichi.next(createStock(25, { h: 110, l: 90 }), r);
+            // 驗證 Tenkan (看 index 17~25)
+            // MaxH = 110, MinL = 90 => 100
+            (0, vitest_1.expect)(r.ichimoku.tenkan).toBe(100);
+            // 驗證 Kijun (看 index 0~25)
+            // MaxH = 120 (from index 0), MinL = 80 (from index 0) => 100
+            (0, vitest_1.expect)(r.ichimoku.kijun).toBe(100);
+            // 驗證 Senkou A
+            (0, vitest_1.expect)(r.ichimoku.senkouA).toBe(100);
+        });
+        (0, vitest_1.it)("should calculate Senkou Span B (52 periods) correctly", function () {
+            var res = ichimoku.init(createStock(0, { h: 200, l: 0 })); // 極值在最開始
+            // 填到 50 筆
+            for (var i = 1; i < 51; i++) {
+                res = ichimoku.next(createStock(i, { h: 100, l: 100 }), res);
+                (0, vitest_1.expect)(res.ichimoku.senkouB).toBeNull();
+            }
+            // 第 52 筆
+            res = ichimoku.next(createStock(51, { h: 100, l: 100 }), res);
+            // 52 期間 (0~51): Max=200, Min=0 => 100
+            (0, vitest_1.expect)(res.ichimoku.senkouB).toBe(100);
+        });
+        (0, vitest_1.it)("should handle Chikou Span (just close price)", function () {
+            var res = ichimoku.init(createStock(0, { c: 555 }));
+            (0, vitest_1.expect)(res.ichimoku.chikou).toBe(555);
+            res = ichimoku.next(createStock(1, { c: 888 }), res);
+            (0, vitest_1.expect)(res.ichimoku.chikou).toBe(888);
+        });
+    });
+});

package/dist/esm/index.d.ts

@@ -20,6 +20,7 @@ export { default as Vma } from "./stockSkills/vma.js";
 export { default as Williams } from "./stockSkills/williams.js";
 export { default as ObvEma } from "./stockSkills/obv_ema.js";
 export { default as Mfi } from "./stockSkills/mfi.js";
+export { default as Ichimoku } from "./stockSkills/ichimoku.js";
 export { add } from "./test/add.js";
 export { minus } from "./test/minus.js";
 export { default as calculateDivisionFactor } from "./utils/calculateDivisionFactor.js";

package/dist/esm/index.js

@@ -23,6 +23,7 @@ export { default as Vma } from "./stockSkills/vma.js";
 export { default as Williams } from "./stockSkills/williams.js";
 export { default as ObvEma } from "./stockSkills/obv_ema.js";
 export { default as Mfi } from "./stockSkills/mfi.js";
+export { default as Ichimoku } from "./stockSkills/ichimoku.js";
 export { add } from "./test/add.js";
 export { minus } from "./test/minus.js";
 export { default as calculateDivisionFactor } from "./utils/calculateDivisionFactor.js";

package/dist/esm/stockSkills/ichimoku.d.ts

@@ -0,0 +1,35 @@
+import { StockListType, StockType } from "./types";
+type NewStockType = Required<Pick<StockType, "v" | "h" | "l" | "c">> & StockType;
+export type IchimokuValType = {
+    tenkan: number | null;
+    kijun: number | null;
+    senkouA: number | null;
+    senkouB: number | null;
+    chikou: number | null;
+};
+export type IchimokuResType = {
+    dataset: Readonly<StockListType>;
+    ichimoku: IchimokuValType;
+};
+interface IchimokuType {
+    init: (data: NewStockType) => IchimokuResType;
+    next: (data: NewStockType, preList: IchimokuResType) => IchimokuResType;
+}
+export default class IchimokuCloud implements IchimokuType {
+    init(data: NewStockType): IchimokuResType;
+    /**
+     * 優化說明：
+     * 如果 preList.dataset 是一個可變陣列，我們直接 push 以達到最佳效能 O(1)。
+     * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
+     * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
+     */
+    next(data: NewStockType, preList: IchimokuResType): IchimokuResType;
+    private calcIchimoku;
+    /**
+     * 優化：
+     * 1. 移除 .slice()，避免產生 Garbage Collection。
+     * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
+     */
+    private getMidPrice;
+}
+export {};

package/dist/esm/stockSkills/ichimoku.js

@@ -0,0 +1,94 @@
+var IchimokuCloud = /** @class */ (function () {
+    function IchimokuCloud() {
+    }
+    Object.defineProperty(IchimokuCloud.prototype, "init", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data) {
+            var dataset = [data];
+            return {
+                dataset: dataset,
+                ichimoku: this.calcIchimoku(dataset, dataset.length - 1),
+            };
+        }
+    });
+    /**
+     * 優化說明：
+     * 如果 preList.dataset 是一個可變陣列，我們直接 push 以達到最佳效能 O(1)。
+     * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
+     * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
+     */
+    Object.defineProperty(IchimokuCloud.prototype, "next", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, preList) {
+            // 強制轉型以進行 push (避免 typescript 報錯 readonly)
+            var mutableDataset = preList.dataset;
+            mutableDataset.push(data);
+            // 只需要計算最後一筆
+            var currentResult = this.calcIchimoku(mutableDataset, mutableDataset.length - 1);
+            return {
+                dataset: mutableDataset,
+                ichimoku: currentResult,
+            };
+        }
+    });
+    // 核心計算邏輯
+    Object.defineProperty(IchimokuCloud.prototype, "calcIchimoku", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataList, i) {
+            var currentData = dataList[i];
+            // 優化：直接傳入 index 與 list，不產生新陣列
+            var tenkanVal = this.getMidPrice(dataList, i, 9);
+            var kijunVal = this.getMidPrice(dataList, i, 26);
+            var senkouBVal = this.getMidPrice(dataList, i, 52);
+            var senkouAVal = null;
+            if (tenkanVal !== null && kijunVal !== null) {
+                senkouAVal = (tenkanVal + kijunVal) / 2;
+            }
+            return {
+                tenkan: tenkanVal,
+                kijun: kijunVal,
+                senkouA: senkouAVal,
+                senkouB: senkouBVal,
+                chikou: currentData.c,
+            };
+        }
+    });
+    /**
+     * 優化：
+     * 1. 移除 .slice()，避免產生 Garbage Collection。
+     * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
+     */
+    Object.defineProperty(IchimokuCloud.prototype, "getMidPrice", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list, currentIndex, periods) {
+            if (currentIndex < periods - 1) {
+                return null;
+            }
+            // 計算視窗的起始 index
+            var start = currentIndex - (periods - 1);
+            // 初始化最大最小
+            // 小技巧：直接拿第一個值當初始值，避免 Infinity 的比較
+            var maxH = list[start].h;
+            var minL = list[start].l;
+            // 從 start + 1 開始遍歷到 currentIndex
+            for (var j = start + 1; j <= currentIndex; j++) {
+                var _a = list[j], h = _a.h, l = _a.l;
+                if (h > maxH)
+                    maxH = h;
+                if (l < minL)
+                    minL = l;
+            }
+            return (maxH + minL) / 2;
+        }
+    });
+    return IchimokuCloud;
+}());
+export default IchimokuCloud;

package/dist/esm/stockSkills/ichimoku.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/stockSkills/ichimoku.test.js

@@ -0,0 +1,156 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { beforeEach, describe, expect, it } from "vitest";
+import IchimokuCloud from "./ichimoku";
+// 輔助函式：快速產生測試用的假資料
+var createStock = function (idx, override) {
+    return __assign({ t: idx, o: 100, c: 100, h: 100, l: 100, v: 1000 }, override);
+};
+describe("IchimokuCloud Algo", function () {
+    var ichimoku;
+    beforeEach(function () {
+        ichimoku = new IchimokuCloud();
+    });
+    describe("init", function () {
+        it("should initialize with correct structure", function () {
+            var data = createStock(0, { c: 150 });
+            var res = ichimoku.init(data);
+            expect(res.dataset).toHaveLength(1);
+            expect(res.dataset[0]).toEqual(data);
+            // 第一筆資料，除了 chikou (收盤價) 外，其他應為 null
+            expect(res.ichimoku.chikou).toBe(150);
+            expect(res.ichimoku.tenkan).toBeNull();
+            expect(res.ichimoku.kijun).toBeNull();
+            expect(res.ichimoku.senkouA).toBeNull();
+            expect(res.ichimoku.senkouB).toBeNull();
+        });
+    });
+    describe("next & Logic Calculation", function () {
+        it("should accumulate dataset correctly", function () {
+            var res = ichimoku.init(createStock(0));
+            res = ichimoku.next(createStock(1), res);
+            res = ichimoku.next(createStock(2), res);
+            expect(res.dataset).toHaveLength(3);
+            expect(res.dataset[2].t).toBe(2);
+        });
+        it("should calculate Tenkan-sen (9 periods) correctly", function () {
+            // 策略：建立 8 筆資料，確認 Tenkan 為 null
+            // 再加第 9 筆，確認 Tenkan 有值
+            // 設定數據：High 逐漸增加 (10~90)，Low 保持 0
+            // 預期結果：(MaxHigh(90) + MinLow(0)) / 2 = 45
+            var res = ichimoku.init(createStock(0, { h: 10, l: 0 }));
+            // 加入第 2 到第 8 筆 (共 8 筆)
+            for (var i = 1; i < 8; i++) {
+                res = ichimoku.next(createStock(i, { h: (i + 1) * 10, l: 0 }), res);
+                expect(res.ichimoku.tenkan).toBeNull(); // 資料不足 9 筆
+            }
+            // 加入第 9 筆
+            res = ichimoku.next(createStock(8, { h: 90, l: 0 }), res);
+            // 驗證
+            expect(res.dataset).toHaveLength(9);
+            expect(res.ichimoku.tenkan).toBe(45); // (90 + 0) / 2
+        });
+        it("should calculate Kijun-sen (26 periods) correctly", function () {
+            // 策略：直接灌入 25 筆資料
+            // 第 1 筆 Low = 10，第 26 筆 High = 110，中間平穩
+            // Kijun = (110 + 10) / 2 = 60
+            var res = ichimoku.init(createStock(0, { h: 50, l: 10 })); // 最低點在 index 0
+            // 填補中間資料 (index 1 ~ 24)
+            for (var i = 1; i < 25; i++) {
+                res = ichimoku.next(createStock(i, { h: 50, l: 50 }), res);
+                expect(res.ichimoku.kijun).toBeNull(); // 資料不足 26 筆
+            }
+            // 加入第 26 筆 (index 25)
+            res = ichimoku.next(createStock(25, { h: 110, l: 50 }), res); // 最高點在 index 25
+            expect(res.dataset).toHaveLength(26);
+            expect(res.ichimoku.kijun).toBe(60); // (110 + 10) / 2
+        });
+        it("should calculate Senkou Span A correctly", function () {
+            // Senkou A = (Tenkan + Kijun) / 2
+            // 我們需要至少 26 筆資料讓 Kijun 有值 (此時 Tenkan 也有值)
+            var res = ichimoku.init(createStock(0));
+            // 我們設計一個場景：
+            // 過去 9 天 (Tenkan window): Max=20, Min=10 -> Tenkan = 15
+            // 過去 26 天 (Kijun window): Max=30, Min=0 -> Kijun = 15
+            // 預期 Senkou A = (15 + 15) / 2 = 15
+            // 先塞入前段資料
+            for (var i = 1; i < 26; i++) {
+                // 為了方便控制，我們讓最後一筆資料決定極值
+                // 這裡隨便塞，只要最後一筆能控制範圍即可，因為我們邏輯是找區間最大最小
+                // 但為了確保 Kijun 區間的 Min 是 0，我們在 index 0 設 l=0
+                // 為了確保 Kijun 區間的 Max 是 30，我們在 index 0 設 h=30 (如果它是最大)
+                // 簡單化：讓資料全部平躺，最後一瞬間拉高拉低
+                // 這裡不用迴圈邏輯太複雜，直接用輔助函式慢慢疊
+                res = ichimoku.next(createStock(i), res);
+            }
+            // 重新建立一個乾淨的測試流程，比較好控制數學
+            // Reset
+            res = ichimoku.init(createStock(0, { h: 100, l: 100 }));
+            // 填充 24 筆 (共 25 筆)
+            for (var i = 1; i < 25; i++) {
+                res = ichimoku.next(createStock(i, { h: 100, l: 100 }), res);
+            }
+            // 第 26 筆 (Index 25) 進來，決定生死
+            // Kijun 看過去 26 筆 (idx 0~25)
+            // Tenkan 看過去 9 筆 (idx 17~25)
+            // 設定目標：
+            // Tenkan: Max=110, Min=90 => Avg=100
+            // Kijun: Max=120, Min=80 => Avg=100
+            // SenkouA => 100
+            // 修改 dataset 裡的值 (模擬真實波動)
+            // 讓 index 0 (很久以前) 有個極低值 80 (影響 Kijun 不影響 Tenkan)
+            // 讓 index 0 有個極高值 120 (影響 Kijun 不影響 Tenkan)
+            // 注意：上面的 init 和 next 已經把資料寫死為 100 了，這在單元測試有點難搞
+            // 所以我們用更簡單的方法：在 next 過程中精準控制
+            // --- 重來：精準控制版 ---
+            var ichi = new IchimokuCloud();
+            var r = ichi.init(createStock(0, { h: 120, l: 80 })); // Kijun Range: H=120, L=80
+            // 填滿中間 16 筆 (Index 1~16)，數值平穩不影響極值，且不讓 Tenkan 抓到
+            for (var i = 1; i <= 16; i++) {
+                r = ichi.next(createStock(i, { h: 100, l: 100 }), r);
+            }
+            // 接下來 8 筆 (Index 17~24)，準備進入 Tenkan 範圍
+            // 我們讓 Tenkan 範圍 (包含下一筆 index 25) 為 H=110, L=90
+            for (var i = 17; i <= 24; i++) {
+                r = ichi.next(createStock(i, { h: 110, l: 90 }), r);
+            }
+            // 第 26 筆 (Index 25)
+            r = ichi.next(createStock(25, { h: 110, l: 90 }), r);
+            // 驗證 Tenkan (看 index 17~25)
+            // MaxH = 110, MinL = 90 => 100
+            expect(r.ichimoku.tenkan).toBe(100);
+            // 驗證 Kijun (看 index 0~25)
+            // MaxH = 120 (from index 0), MinL = 80 (from index 0) => 100
+            expect(r.ichimoku.kijun).toBe(100);
+            // 驗證 Senkou A
+            expect(r.ichimoku.senkouA).toBe(100);
+        });
+        it("should calculate Senkou Span B (52 periods) correctly", function () {
+            var res = ichimoku.init(createStock(0, { h: 200, l: 0 })); // 極值在最開始
+            // 填到 50 筆
+            for (var i = 1; i < 51; i++) {
+                res = ichimoku.next(createStock(i, { h: 100, l: 100 }), res);
+                expect(res.ichimoku.senkouB).toBeNull();
+            }
+            // 第 52 筆
+            res = ichimoku.next(createStock(51, { h: 100, l: 100 }), res);
+            // 52 期間 (0~51): Max=200, Min=0 => 100
+            expect(res.ichimoku.senkouB).toBe(100);
+        });
+        it("should handle Chikou Span (just close price)", function () {
+            var res = ichimoku.init(createStock(0, { c: 555 }));
+            expect(res.ichimoku.chikou).toBe(555);
+            res = ichimoku.next(createStock(1, { c: 888 }), res);
+            expect(res.ichimoku.chikou).toBe(888);
+        });
+    });
+});

package/dist/umd/index.js

@@ -1869,6 +1869,100 @@
         return Mfi;
     }());
 
+    var IchimokuCloud = /** @class */ (function () {
+        function IchimokuCloud() {
+        }
+        Object.defineProperty(IchimokuCloud.prototype, "init", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (data) {
+                var dataset = [data];
+                return {
+                    dataset: dataset,
+                    ichimoku: this.calcIchimoku(dataset, dataset.length - 1),
+                };
+            }
+        });
+        /**
+         * 優化說明：
+         * 如果 preList.dataset 是一個可變陣列，我們直接 push 以達到最佳效能 O(1)。
+         * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
+         * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
+         */
+        Object.defineProperty(IchimokuCloud.prototype, "next", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (data, preList) {
+                // 強制轉型以進行 push (避免 typescript 報錯 readonly)
+                var mutableDataset = preList.dataset;
+                mutableDataset.push(data);
+                // 只需要計算最後一筆
+                var currentResult = this.calcIchimoku(mutableDataset, mutableDataset.length - 1);
+                return {
+                    dataset: mutableDataset,
+                    ichimoku: currentResult,
+                };
+            }
+        });
+        // 核心計算邏輯
+        Object.defineProperty(IchimokuCloud.prototype, "calcIchimoku", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (dataList, i) {
+                var currentData = dataList[i];
+                // 優化：直接傳入 index 與 list，不產生新陣列
+                var tenkanVal = this.getMidPrice(dataList, i, 9);
+                var kijunVal = this.getMidPrice(dataList, i, 26);
+                var senkouBVal = this.getMidPrice(dataList, i, 52);
+                var senkouAVal = null;
+                if (tenkanVal !== null && kijunVal !== null) {
+                    senkouAVal = (tenkanVal + kijunVal) / 2;
+                }
+                return {
+                    tenkan: tenkanVal,
+                    kijun: kijunVal,
+                    senkouA: senkouAVal,
+                    senkouB: senkouBVal,
+                    chikou: currentData.c,
+                };
+            }
+        });
+        /**
+         * 優化：
+         * 1. 移除 .slice()，避免產生 Garbage Collection。
+         * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
+         */
+        Object.defineProperty(IchimokuCloud.prototype, "getMidPrice", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list, currentIndex, periods) {
+                if (currentIndex < periods - 1) {
+                    return null;
+                }
+                // 計算視窗的起始 index
+                var start = currentIndex - (periods - 1);
+                // 初始化最大最小
+                // 小技巧：直接拿第一個值當初始值，避免 Infinity 的比較
+                var maxH = list[start].h;
+                var minL = list[start].l;
+                // 從 start + 1 開始遍歷到 currentIndex
+                for (var j = start + 1; j <= currentIndex; j++) {
+                    var _a = list[j], h = _a.h, l = _a.l;
+                    if (h > maxH)
+                        maxH = h;
+                    if (l < minL)
+                        minL = l;
+                }
+                return (maxH + minL) / 2;
+            }
+        });
+        return IchimokuCloud;
+    }());
+
     function add(a, b) {
         return a + b;
     }
@@ -1909,6 +2003,7 @@
     exports.Boll = Boll;
     exports.Ema = Ema;
     exports.Gold = Gold;
+    exports.Ichimoku = IchimokuCloud;
     exports.Kd = Kd;
     exports.Ma = Ma;
     exports.Macd = MACD;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ch20026103/anysis",
-  "version": "0.0.18",
+  "version": "0.0.19-alpha1",
   "description": "provide many analyze methods in the library.",
   "keywords": [],
   "bugs": "git@github.com:cosmic1330/anysis/issues",