@ch20026103/anysis 0.0.19-alpha1 → 0.0.19-beta

package/dist/cjs/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/cjs/stockSkills/dmi.js

@@ -0,0 +1,206 @@
+"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);
+};
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+}());
+exports.default = Dmi;

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var dmi_1 = require("./dmi");
+var test_data_test_1 = require("./test_data.test");
+describe("test dmi methods", function () {
+    it("test init & next", function () {
+        var dmi = new dmi_1.default();
+        var period = 14;
+        // Calculate all values using loop
+        var results = dmi.calculateDmiValues(test_data_test_1.default, period);
+        var lastResult = results[results.length - 1];
+        // Verify consistency
+        // Re-run step-by-step
+        var state = dmi.init(test_data_test_1.default[0], period);
+        for (var i = 1; i < test_data_test_1.default.length; i++) {
+            state = dmi.next(test_data_test_1.default[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_1.default();
+        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_1.default();
+        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/cjs/stockSkills/ichimoku.d.ts

@@ -15,7 +15,7 @@ interface IchimokuType {
     init: (data: NewStockType) => IchimokuResType;
     next: (data: NewStockType, preList: IchimokuResType) => IchimokuResType;
 }
-export default class IchimokuCloud implements IchimokuType {
+export default class Ichimoku implements IchimokuType {
     init(data: NewStockType): IchimokuResType;
     /**
      * 優化說明：

package/dist/cjs/stockSkills/ichimoku.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var IchimokuCloud = /** @class */ (function () {
-    function IchimokuCloud() {
+var Ichimoku = /** @class */ (function () {
+    function Ichimoku() {
     }
-    Object.defineProperty(IchimokuCloud.prototype, "init", {
+    Object.defineProperty(Ichimoku.prototype, "init", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -21,7 +21,7 @@ var IchimokuCloud = /** @class */ (function () {
      * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
      * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
      */
-    Object.defineProperty(IchimokuCloud.prototype, "next", {
+    Object.defineProperty(Ichimoku.prototype, "next", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -38,7 +38,7 @@ var IchimokuCloud = /** @class */ (function () {
         }
     });
     // 核心計算邏輯
-    Object.defineProperty(IchimokuCloud.prototype, "calcIchimoku", {
+    Object.defineProperty(Ichimoku.prototype, "calcIchimoku", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -66,7 +66,7 @@ var IchimokuCloud = /** @class */ (function () {
      * 1. 移除 .slice()，避免產生 Garbage Collection。
      * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
      */
-    Object.defineProperty(IchimokuCloud.prototype, "getMidPrice", {
+    Object.defineProperty(Ichimoku.prototype, "getMidPrice", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -91,6 +91,6 @@ var IchimokuCloud = /** @class */ (function () {
             return (maxH + minL) / 2;
         }
     });
-    return IchimokuCloud;
+    return Ichimoku;
 }());
-exports.default = IchimokuCloud;
+exports.default = Ichimoku;

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

@@ -17,7 +17,7 @@ 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 () {
+(0, vitest_1.describe)("Ichimoku Algo", function () {
     var ichimoku;
     (0, vitest_1.beforeEach)(function () {
         ichimoku = new ichimoku_1.default();

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

@@ -15,7 +15,7 @@ interface IchimokuType {
     init: (data: NewStockType) => IchimokuResType;
     next: (data: NewStockType, preList: IchimokuResType) => IchimokuResType;
 }
-export default class IchimokuCloud implements IchimokuType {
+export default class Ichimoku implements IchimokuType {
     init(data: NewStockType): IchimokuResType;
     /**
      * 優化說明：

package/dist/esm/stockSkills/ichimoku.js

@@ -1,7 +1,7 @@
-var IchimokuCloud = /** @class */ (function () {
-    function IchimokuCloud() {
+var Ichimoku = /** @class */ (function () {
+    function Ichimoku() {
     }
-    Object.defineProperty(IchimokuCloud.prototype, "init", {
+    Object.defineProperty(Ichimoku.prototype, "init", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -19,7 +19,7 @@ var IchimokuCloud = /** @class */ (function () {
      * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
      * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
      */
-    Object.defineProperty(IchimokuCloud.prototype, "next", {
+    Object.defineProperty(Ichimoku.prototype, "next", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -36,7 +36,7 @@ var IchimokuCloud = /** @class */ (function () {
         }
     });
     // 核心計算邏輯
-    Object.defineProperty(IchimokuCloud.prototype, "calcIchimoku", {
+    Object.defineProperty(Ichimoku.prototype, "calcIchimoku", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -64,7 +64,7 @@ var IchimokuCloud = /** @class */ (function () {
      * 1. 移除 .slice()，避免產生 Garbage Collection。
      * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
      */
-    Object.defineProperty(IchimokuCloud.prototype, "getMidPrice", {
+    Object.defineProperty(Ichimoku.prototype, "getMidPrice", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -89,6 +89,6 @@ var IchimokuCloud = /** @class */ (function () {
             return (maxH + minL) / 2;
         }
     });
-    return IchimokuCloud;
+    return Ichimoku;
 }());
-export default IchimokuCloud;
+export default Ichimoku;

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

@@ -10,15 +10,15 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { beforeEach, describe, expect, it } from "vitest";
-import IchimokuCloud from "./ichimoku";
+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("IchimokuCloud Algo", function () {
+describe("Ichimoku Algo", function () {
     var ichimoku;
     beforeEach(function () {
-        ichimoku = new IchimokuCloud();
+        ichimoku = new Ichimoku();
     });
     describe("init", function () {
         it("should initialize with correct structure", function () {
@@ -112,7 +112,7 @@ describe("IchimokuCloud Algo", function () {
             // 注意：上面的 init 和 next 已經把資料寫死為 100 了，這在單元測試有點難搞
             // 所以我們用更簡單的方法：在 next 過程中精準控制
             // --- 重來：精準控制版 ---
-            var ichi = new IchimokuCloud();
+            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++) {

package/dist/umd/index.js

@@ -1869,10 +1869,10 @@
         return Mfi;
     }());
 
-    var IchimokuCloud = /** @class */ (function () {
-        function IchimokuCloud() {
+    var Ichimoku = /** @class */ (function () {
+        function Ichimoku() {
         }
-        Object.defineProperty(IchimokuCloud.prototype, "init", {
+        Object.defineProperty(Ichimoku.prototype, "init", {
             enumerable: false,
             configurable: true,
             writable: true,
@@ -1890,7 +1890,7 @@
          * 如果你的框架 (如 React state) 強制要求 immutable，則需要改回 [...prev, data] 的寫法。
          * 下面的寫法假設可以 Mutation (這在 Class 內部運算或 Backend 處理很常見)。
          */
-        Object.defineProperty(IchimokuCloud.prototype, "next", {
+        Object.defineProperty(Ichimoku.prototype, "next", {
             enumerable: false,
             configurable: true,
             writable: true,
@@ -1907,7 +1907,7 @@
             }
         });
         // 核心計算邏輯
-        Object.defineProperty(IchimokuCloud.prototype, "calcIchimoku", {
+        Object.defineProperty(Ichimoku.prototype, "calcIchimoku", {
             enumerable: false,
             configurable: true,
             writable: true,
@@ -1935,7 +1935,7 @@
          * 1. 移除 .slice()，避免產生 Garbage Collection。
          * 2. 使用反向迴圈 (i--)，通常在 JS 引擎中微幅快一點，且語意上是「從現在往回看」。
          */
-        Object.defineProperty(IchimokuCloud.prototype, "getMidPrice", {
+        Object.defineProperty(Ichimoku.prototype, "getMidPrice", {
             enumerable: false,
             configurable: true,
             writable: true,
@@ -1960,7 +1960,7 @@
                 return (maxH + minL) / 2;
             }
         });
-        return IchimokuCloud;
+        return Ichimoku;
     }());
 
     function add(a, b) {
@@ -2003,7 +2003,7 @@
     exports.Boll = Boll;
     exports.Ema = Ema;
     exports.Gold = Gold;
-    exports.Ichimoku = IchimokuCloud;
+    exports.Ichimoku = Ichimoku;
     exports.Kd = Kd;
     exports.Ma = Ma;
     exports.Macd = MACD;

package/package.json

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