@ch20026103/anysis 0.0.19-alpha → 0.0.19-beta

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

@@ -0,0 +1,28 @@
+import { StockListType, StockType } from "./types";
+export type DmiResType = {
+    dataset: StockListType;
+    pDi: number;
+    mDi: number;
+    adx: number;
+    type: number;
+    smoothTr: number;
+    smoothPdm: number;
+    smoothMdm: number;
+    dxBuffer: number[];
+    smoothAdx: number;
+};
+export default class Dmi {
+    init(data: StockType, type: number): DmiResType;
+    next(data: StockType, preList: DmiResType, type: number): DmiResType;
+    calculateDmiValues(list: StockListType, period?: number): {
+        pDi: number;
+        mDi: number;
+        adx: number;
+        c: number;
+        v: number;
+        l: number;
+        h: number;
+        o: number;
+        t: number;
+    }[];
+}

package/dist/esm/stockSkills/dmi.js

@@ -0,0 +1,204 @@
+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);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var Dmi = /** @class */ (function () {
+    function Dmi() {
+    }
+    Object.defineProperty(Dmi.prototype, "init", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, type) {
+            return {
+                dataset: [data],
+                pDi: 0,
+                mDi: 0,
+                adx: 0,
+                type: type,
+                smoothTr: 0,
+                smoothPdm: 0,
+                smoothMdm: 0,
+                dxBuffer: [],
+                smoothAdx: 0,
+            };
+        }
+    });
+    Object.defineProperty(Dmi.prototype, "next", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, preList, type) {
+            preList.dataset.push(data);
+            // Need type + 1 data points to have 'type' periods of change
+            if (preList.dataset.length < type + 1) {
+                return __assign(__assign({}, preList), { pDi: 0, mDi: 0, adx: 0 });
+            }
+            else {
+                var currentTr = 0;
+                var currentPdm = 0;
+                var currentMdm = 0;
+                // Logic to get TR, +DM, -DM for the NEWEST data point
+                // We need the newest point and the one before it.
+                // If we are in the initialization phase (length === type + 1), we process the whole window.
+                // If we are in the incremental phase (length > type + 1), we just process the last step.
+                var newSmoothTr = preList.smoothTr;
+                var newSmoothPdm = preList.smoothPdm;
+                var newSmoothMdm = preList.smoothMdm;
+                if (preList.dataset.length === type + 1) {
+                    // Initialization: Calculate sum of first N periods (using N+1 data points)
+                    var sumTr = 0;
+                    var sumPdm = 0;
+                    var sumMdm = 0;
+                    for (var i = 1; i <= type; i++) {
+                        var curr = preList.dataset[i];
+                        var prev = preList.dataset[i - 1];
+                        // TR
+                        var hl = curr.h - curr.l;
+                        var hpc = Math.abs(curr.h - prev.c);
+                        var lpc = Math.abs(curr.l - prev.c);
+                        var tr = Math.max(hl, hpc, lpc);
+                        // DM
+                        var hph = curr.h - prev.h;
+                        var pll = prev.l - curr.l;
+                        var pdm = 0;
+                        var mdm = 0;
+                        if (hph > pll && hph > 0) {
+                            pdm = hph;
+                        }
+                        if (pll > hph && pll > 0) {
+                            mdm = pll;
+                        }
+                        sumTr += tr;
+                        sumPdm += pdm;
+                        sumMdm += mdm;
+                    }
+                    // Wilder's first value is often just the Sum.
+                    // But to make it consistent with the "Average" view for the formula:
+                    // NextAvg = (PrevAvg * (N-1) + Curr) / N
+                    // The first "PrevAvg" acts as the seed. The seed is usually the Simple Average.
+                    // So we divide by type.
+                    newSmoothTr = sumTr; // Some sources say keep Sum. But standard indicators often normalize to Average range.
+                    // Let's check RSI implementation. RSI divides by type: gains / type.
+                    // So we will divide by type to get the Average TR/DM.
+                    // Wait! DMI standard often keeps the SUM for the first value?
+                    // Wilder's book: "+DM14 is the sum of the +DM for the last 14 days".
+                    // Then subsequent: "+DM14_today = +DM14_yesterday - (+DM14_yesterday/14) + +DM_today".
+                    // This formula maintains the "Sum" magnitude (approx 14x the average).
+                    // BUT, RSI implementation uses Average magnitude (0-100 range inputs usually lead to small AvgGain).
+                    // Let's stick to the RSI pattern: Average.
+                    // Formula: (Avg * (N-1) + Curr) / N. This maintains "Average" magnitude.
+                    // If we used Sum logic: (Sum - Sum/N + Curr) = Sum * (1 - 1/N) + Curr.
+                    // These are mathematically consistent in shape, just scaled by N.
+                    // DI calculation is (Pdm / Tr) * 100. The scale cancels out!
+                    // So using Average is safer for preventing overflow and easier to debug (per-day values).
+                    newSmoothTr = sumTr / type;
+                    newSmoothPdm = sumPdm / type;
+                    newSmoothMdm = sumMdm / type;
+                }
+                else {
+                    // Shift if needed to keep dataset size manageable, though strictly we only need last 2 points
+                    // reusing rsi pattern:
+                    if (preList.dataset.length > type + 1) {
+                        preList.dataset.shift();
+                    }
+                    var curr = preList.dataset[preList.dataset.length - 1];
+                    var prev = preList.dataset[preList.dataset.length - 2];
+                    // TR
+                    var hl = curr.h - curr.l;
+                    var hpc = Math.abs(curr.h - prev.c);
+                    var lpc = Math.abs(curr.l - prev.c);
+                    var tr = Math.max(hl, hpc, lpc);
+                    // DM
+                    var hph = curr.h - prev.h;
+                    var pll = prev.l - curr.l;
+                    var pdm = 0;
+                    var mdm = 0;
+                    if (hph > pll && hph > 0)
+                        pdm = hph;
+                    if (pll > hph && pll > 0)
+                        mdm = pll;
+                    // Wilder's Smoothing (Average form)
+                    newSmoothTr = (preList.smoothTr * (type - 1) + tr) / type;
+                    newSmoothPdm = (preList.smoothPdm * (type - 1) + pdm) / type;
+                    newSmoothMdm = (preList.smoothMdm * (type - 1) + mdm) / type;
+                }
+                // Calculate DI
+                // Avoid division by zero
+                var pDi = newSmoothTr === 0 ? 0 : (newSmoothPdm / newSmoothTr) * 100;
+                var mDi = newSmoothTr === 0 ? 0 : (newSmoothMdm / newSmoothTr) * 100;
+                // Calculate DX
+                var diDiff = Math.abs(pDi - mDi);
+                var diSum = pDi + mDi;
+                var dx = diSum === 0 ? 0 : (diDiff / diSum) * 100;
+                // ADX Logic
+                var dxBuffer = __spreadArray([], preList.dxBuffer, true);
+                var adx = preList.adx;
+                var newSmoothAdx = preList.smoothAdx;
+                if (dxBuffer.length < type) {
+                    dxBuffer.push(dx);
+                    // Special case: if we Just reached 'type' count, we can calc initial ADX
+                    if (dxBuffer.length === type) {
+                        // First ADX is average of the DX buffer?
+                        // "ADX is the 14-day smoothed average of DX".
+                        // First value is simple average of previous 14 DX values.
+                        var sumDx = dxBuffer.reduce(function (a, b) { return a + b; }, 0);
+                        newSmoothAdx = sumDx / type;
+                        adx = newSmoothAdx;
+                    }
+                    else {
+                        // Not enough data for ADX yet
+                        adx = 0;
+                    }
+                }
+                else {
+                    // We already have ADX initialized, so we smooth it
+                    // Note: we don't need to keep growing dxBuffer indefinitely.
+                    // We just needed it for startup.
+                    // Update ADX using Wilder's smoothing
+                    newSmoothAdx = (preList.smoothAdx * (type - 1) + dx) / type;
+                    adx = newSmoothAdx;
+                }
+                return __assign(__assign({}, preList), { pDi: pDi, // +DI
+                    mDi: mDi, // -DI
+                    adx: adx, smoothTr: newSmoothTr, smoothPdm: newSmoothPdm, smoothMdm: newSmoothMdm, dxBuffer: dxBuffer, smoothAdx: newSmoothAdx });
+            }
+        }
+    });
+    // Helper to get formatted results similar to ma.ts
+    Object.defineProperty(Dmi.prototype, "calculateDmiValues", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list, period) {
+            if (period === void 0) { period = 14; }
+            var res = [];
+            var state = this.init(list[0], period);
+            // First point (index 0) has 0 DMI
+            res.push(__assign(__assign({}, list[0]), { pDi: 0, mDi: 0, adx: 0 }));
+            for (var i = 1; i < list.length; i++) {
+                state = this.next(list[i], state, period);
+                res.push(__assign(__assign({}, list[i]), { pDi: state.pDi, mDi: state.mDi, adx: state.adx }));
+            }
+            return res;
+        }
+    });
+    return Dmi;
+}());
+export default Dmi;

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

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

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

@@ -0,0 +1,69 @@
+import Dmi from "./dmi";
+import data from "./test_data.test";
+describe("test dmi methods", function () {
+    it("test init & next", function () {
+        var dmi = new Dmi();
+        var period = 14;
+        // Calculate all values using loop
+        var results = dmi.calculateDmiValues(data, period);
+        var lastResult = results[results.length - 1];
+        // Verify consistency
+        // Re-run step-by-step
+        var state = dmi.init(data[0], period);
+        for (var i = 1; i < data.length; i++) {
+            state = dmi.next(data[i], state, period);
+        }
+        expect(state.pDi).toEqual(lastResult.pDi);
+        expect(state.mDi).toEqual(lastResult.mDi);
+        expect(state.adx).toEqual(lastResult.adx);
+    });
+    it("test values consistency (basic sanity)", function () {
+        // Generate a simple synthetic dataset where Trend is obvious
+        // Upward trend -> +DI should be high, -DI low
+        var upTrendData = [];
+        for (var i = 0; i < 50; i++) {
+            upTrendData.push({
+                c: 10 + i,
+                h: 11 + i,
+                l: 9 + i,
+                o: 10 + i,
+                v: 1000,
+                t: 20210101 + i,
+            });
+        }
+        var dmi = new Dmi();
+        var res = dmi.calculateDmiValues(upTrendData, 14);
+        var last = res[res.length - 1];
+        // +DI should be dominant
+        expect(last.pDi).toBeGreaterThan(last.mDi);
+        // ADX should be high (strong trend)
+        expect(last.adx).toBeGreaterThan(20);
+    });
+    it("test flat trend", function () {
+        // Flat data
+        var flatData = [];
+        for (var i = 0; i < 50; i++) {
+            flatData.push({
+                c: 10,
+                h: 11,
+                l: 9,
+                o: 10,
+                v: 1000,
+                t: 20210101 + i,
+            });
+        }
+        var dmi = new Dmi();
+        var res = dmi.calculateDmiValues(flatData, 14);
+        var last = res[res.length - 1];
+        // No directional movement
+        // h-ph = 0, pl-l = 0.
+        // +DM = 0, -DM = 0.
+        // +DI = 0, -DI = 0.
+        // ADX = 0?
+        // DX = 0.
+        expect(last.pDi).toEqual(0);
+        expect(last.mDi).toEqual(0);
+        // ADX might be 0 or close to 0
+        expect(last.adx).toEqual(0);
+    });
+});

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 Ichimoku 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 Ichimoku = /** @class */ (function () {
+    function Ichimoku() {
+    }
+    Object.defineProperty(Ichimoku.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(Ichimoku.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(Ichimoku.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(Ichimoku.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 Ichimoku;
+}());
+export default Ichimoku;

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 Ichimoku from "./ichimoku";
+// 輔助函式：快速產生測試用的假資料
+var createStock = function (idx, override) {
+    return __assign({ t: idx, o: 100, c: 100, h: 100, l: 100, v: 1000 }, override);
+};
+describe("Ichimoku Algo", function () {
+    var ichimoku;
+    beforeEach(function () {
+        ichimoku = new Ichimoku();
+    });
+    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 Ichimoku();
+            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);
+        });
+    });
+});