@ch20026103/anysis 0.0.3-alpha → 0.0.5-alpha

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

@@ -1,6 +1,38 @@
 import Kd from "./kd";
 import { data_9904 as data } from "./test_data.test";
 describe("test kd methods", function () {
+    it("test init", function () {
+        var index = data.length - 1;
+        var kd = new Kd();
+        var realData = kd.getKD(data)[index];
+        var init = kd.init(data[0]);
+        var res = init;
+        for (var i = 1; i <= index; i++) {
+            var item = data[i];
+            res = kd.next(item, res, 9);
+        }
+        expect({
+            dataset: {
+                c: realData.c,
+                h: realData.h,
+                l: realData.l,
+            },
+            rsv: realData.rsv,
+            "k-d": realData["k-d"],
+            k: realData.k,
+            d: realData.d,
+        }).toEqual({
+            dataset: {
+                c: res.dataset[res.dataset.length - 1].c,
+                h: res.dataset[res.dataset.length - 1].h,
+                l: res.dataset[res.dataset.length - 1].l,
+            },
+            rsv: res.rsv,
+            "k-d": res["k-d"],
+            k: res.k,
+            d: res.d,
+        });
+    });
     it("test getRSV()", function () {
         var kd = new Kd();
         expect(kd.getRSV(data)[data.length - 1]).toEqual({
@@ -13,7 +45,7 @@ describe("test kd methods", function () {
             rsv: 90.63,
         });
     });
-    it("test getRSV()", function () {
+    it("test getKD()", function () {
         var kd = new Kd();
         expect(kd.getKD(data)[data.length - 1]).toEqual({
             o: 26.4,
@@ -25,7 +57,7 @@ describe("test kd methods", function () {
             rsv: 90.63,
             k: 64.41,
             d: 45.25,
-            'k-d': 19.16
+            "k-d": 19.16,
         });
     });
 });

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

@@ -1,33 +1,34 @@
-declare type ListType = {
+type DataType = {
     c: number;
-}[];
-declare type ResMa5 = {
+};
+type ListType = DataType[];
+type ResMa5 = {
     c: number;
     ma5?: number;
 }[];
-declare type ResMa10 = {
+type ResMa10 = {
     c: number;
     ma10?: number;
 }[];
-declare type ResMa20 = {
+type ResMa20 = {
     c: number;
     ma20?: number;
 }[];
-declare type ResMa60 = {
+type ResMa60 = {
     c: number;
     ma60?: number;
 }[];
-declare type ResMaSelf = {
+type ResMaSelf = {
     c: number;
     maSelf?: number;
 }[];
-declare type ResBoll = {
+type ResBoll = {
     c: number;
     ma25?: number;
     bollUb?: number;
     bollLb?: number;
 }[];
-declare type ResAllMa = {
+type ResAllMa = {
     c: number;
     ma5?: number;
     ma10?: number;
@@ -38,6 +39,20 @@ declare type ResAllMa = {
     bollLb?: number;
 }[];
 interface MaType {
+    init: (data: DataType, type: number) => {
+        dataset: ListType;
+        ma: number;
+        type: number;
+    };
+    next: (data: DataType, preList: {
+        dataset: ListType;
+        ma: number;
+        type: number;
+    }, type: number) => {
+        dataset: ListType;
+        ma: number;
+        type: number;
+    };
     getAllMa: (list: ListType) => ResAllMa;
     getMa5: (list: ListType) => ResMa5;
     getMa10: (list: ListType) => ResMa10;
@@ -47,6 +62,20 @@ interface MaType {
     getBoll: (list: ListType) => ResBoll;
 }
 export default class Ma implements MaType {
+    init(data: DataType, type: number): {
+        dataset: DataType[];
+        ma: number;
+        type: number;
+    };
+    next(data: DataType, preList: {
+        dataset: ListType;
+        ma: number;
+        type: number;
+    }, type: number): {
+        dataset: ListType;
+        ma: number;
+        type: number;
+    };
     getAllMa(list: ListType): ResAllMa;
     getMa5(list: ListType): ResMa5;
     getMa10(list: ListType): ResMa10;

package/dist/esm/stockSkills/ma.js

@@ -12,6 +12,33 @@ var __assign = (this && this.__assign) || function () {
 var Ma = /** @class */ (function () {
     function Ma() {
     }
+    Object.defineProperty(Ma.prototype, "init", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, type) {
+            return { dataset: [data], ma: 0, type: type };
+        }
+    });
+    Object.defineProperty(Ma.prototype, "next", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, preList, type) {
+            preList.dataset.push(data);
+            if (preList.dataset.length < type) {
+                return { dataset: preList.dataset, ma: 0, type: type };
+            }
+            else {
+                if (preList.dataset.length > type) {
+                    preList.dataset.shift();
+                }
+                var sum = preList.dataset.reduce(function (pre, current) { return pre + current.c; }, 0);
+                var ma = Math.round((sum / type) * 100) / 100;
+                return { dataset: preList.dataset, ma: ma, type: type };
+            }
+        }
+    });
     Object.defineProperty(Ma.prototype, "getAllMa", {
         enumerable: false,
         configurable: true,
@@ -116,7 +143,7 @@ var Ma = /** @class */ (function () {
         value: function (list, self) {
             var res = [];
             for (var i = 0; i < list.length; i++) {
-                if (i < (self - 1))
+                if (i < self - 1)
                     res[i] = __assign(__assign({}, list[i]), { maSelf: undefined });
                 else {
                     var sum = list

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

@@ -1,6 +1,18 @@
 import Ma from "./ma";
 import data from "./test_data.test";
 describe("test ma methods", function () {
+    it("test init & next", function () {
+        var index = data.length - 1;
+        var ma = new Ma();
+        var realData = ma.getMa5(data)[index];
+        var init = ma.init(data[0], 5);
+        var res = init;
+        for (var i = 1; i <= index; i++) {
+            var item = data[i];
+            res = ma.next(item, res, 5);
+        }
+        expect(realData.ma5).toEqual(res.ma);
+    });
     it("test getMa5()", function () {
         var ma = new Ma();
         expect(ma.getMa5(data)[data.length - 1]).toEqual({

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

@@ -1,34 +1,34 @@
-declare type ItemType = {
+type ItemType = {
     h: number;
     l: number;
     c: number;
 };
-declare type ResEMA12Type = {
+type ResEMA12Type = {
     h: number;
     l: number;
     c: number;
     EMA12?: number;
 }[];
-declare type ResEMA26Type = {
+type ResEMA26Type = {
     h: number;
     l: number;
     c: number;
     EMA26?: number;
 }[];
-declare type ResDifType = {
+type ResDifType = {
     h: number;
     l: number;
     c: number;
     DIF?: number;
 }[];
-declare type ResMacd9Type = {
+type ResMacd9Type = {
     h: number;
     l: number;
     c: number;
     MACD9?: number;
     OSC?: number;
 }[];
-declare type ResAllMacdType = {
+type ResAllMacdType = {
     h: number;
     l: number;
     c: number;
@@ -39,6 +39,29 @@ declare type ResAllMacdType = {
     OSC?: number;
 }[];
 interface MacdType {
+    init: (data: ItemType) => {
+        dataset: ItemType[];
+        ema12?: number;
+        ema26?: number;
+        dif: number[];
+        macd?: number;
+        osc?: number;
+    };
+    next: (data: ItemType, preList: {
+        dataset: ItemType[];
+        ema12?: number;
+        ema26?: number;
+        dif: number[];
+        macd?: number;
+        osc?: number;
+    }) => {
+        dataset: ItemType[];
+        ema12?: number;
+        ema26?: number;
+        dif: number[];
+        macd?: number;
+        osc?: number;
+    };
     getMACD: (list: ItemType[]) => ResAllMacdType;
     getDI: (item: ItemType) => number;
     getStartEMA: (list: ItemType[]) => number;
@@ -48,6 +71,29 @@ interface MacdType {
     getMACD9: (list: ItemType[], DIF: ResDifType) => ResMacd9Type;
 }
 export default class MACD implements MacdType {
+    init(data: ItemType): {
+        dataset: ItemType[];
+        ema12?: number;
+        ema26?: number;
+        dif: number[];
+        macd?: number;
+        osc?: number;
+    };
+    next(data: ItemType, preList: {
+        dataset: ItemType[];
+        ema12?: number;
+        ema26?: number;
+        dif: number[];
+        macd?: number;
+        osc?: number;
+    }): {
+        dataset: ItemType[];
+        ema12: number | undefined;
+        ema26: number | undefined;
+        dif: number[];
+        macd: number | undefined;
+        osc: number | undefined;
+    };
     getMACD(list: ItemType[]): ResAllMacdType;
     getDI(item: ItemType): number;
     getStartEMA(arr: ItemType[]): number;

package/dist/esm/stockSkills/macd.js

@@ -12,6 +12,93 @@ var __assign = (this && this.__assign) || function () {
 var MACD = /** @class */ (function () {
     function MACD() {
     }
+    Object.defineProperty(MACD.prototype, "init", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data) {
+            return {
+                dataset: [data],
+                ema12: undefined,
+                ema26: undefined,
+                dif: [],
+                macd: undefined,
+                osc: undefined,
+            };
+        }
+    });
+    Object.defineProperty(MACD.prototype, "next", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, preList) {
+            var _a, _b;
+            preList.dataset.push(data);
+            if (preList.dataset.length > 34)
+                preList.dataset.shift();
+            // EMA12
+            var ema12 = undefined;
+            if (preList.dataset.length === 12) {
+                ema12 = this.getStartEMA(preList.dataset);
+                ema12 = (ema12 * 11) / 13 + (this.getDI(data) * 2) / 13;
+                ema12 = Math.round(ema12 * 100) / 100;
+            }
+            else if (preList.dataset.length > 12 && preList.ema12) {
+                ema12 = (preList.ema12 * 11) / 13 + (this.getDI(data) * 2) / 13;
+                ema12 = Math.round(ema12 * 100) / 100;
+            }
+            // EMA26
+            var ema26 = undefined;
+            if (preList.dataset.length === 26) {
+                ema26 = this.getStartEMA(preList.dataset);
+                ema26 = (ema26 * 25) / 27 + (this.getDI(data) * 2) / 27;
+                ema26 = Math.round(ema26 * 100) / 100;
+            }
+            else if (preList.dataset.length > 26 && preList.ema26) {
+                ema26 = (preList.ema26 * 25) / 27 + (this.getDI(data) * 2) / 27;
+                ema26 = Math.round(ema26 * 100) / 100;
+            }
+            // DIF
+            var dif = undefined;
+            if (ema12 && ema26) {
+                dif = ema12 - ema26;
+                dif = Math.round(dif * 100) / 100;
+                (_a = preList.dif) === null || _a === void 0 ? void 0 : _a.push(dif);
+                if (preList.dif.length > 9)
+                    (_b = preList.dif) === null || _b === void 0 ? void 0 : _b.shift();
+            }
+            // MACD & OSC
+            var macd = undefined;
+            var osc = undefined;
+            if (preList.dif.length === 9) {
+                if (preList.macd === undefined) {
+                    macd = preList.dif.reduce(function (accumulator, currentValue) { return accumulator + currentValue; });
+                    for (var i = 0; i < 9; i++) {
+                        var item = preList.dif[i];
+                        macd = macd + ((item - macd) * 2) / 10;
+                        macd = Math.round(macd * 100) / 100;
+                        osc = item - macd;
+                        osc = Math.round(osc * 100) / 100;
+                    }
+                }
+                else {
+                    macd = preList.macd + ((dif - preList.macd) * 2) / 10;
+                    macd = Math.round(macd * 100) / 100;
+                    var item = preList.dif[preList.dif.length - 1];
+                    osc = item - macd;
+                    osc = Math.round(osc * 100) / 100;
+                }
+            }
+            return {
+                dataset: preList.dataset,
+                ema12: ema12,
+                ema26: ema26,
+                dif: preList.dif,
+                macd: macd,
+                osc: osc,
+            };
+        }
+    });
     Object.defineProperty(MACD.prototype, "getMACD", {
         enumerable: false,
         configurable: true,

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

@@ -1,6 +1,30 @@
 import Macd from "./macd";
 import data from "./test_data.test";
 describe("test macd methods", function () {
+    it("test init & next", function () {
+        var _a, _b;
+        var index = data.length - 1;
+        var macd = new Macd();
+        var init = macd.init(data[0]);
+        var res = init;
+        for (var i = 1; i <= index; i++) {
+            var item = data[i];
+            res = macd.next(item, res);
+        }
+        expect({
+            ema12: 144.02,
+            ema26: 142.23,
+            dif: 1.79,
+            macd: 3.46,
+            osc: -1.67,
+        }).toEqual({
+            ema12: res.ema12,
+            ema26: res.ema26,
+            dif: (_a = res.dif) === null || _a === void 0 ? void 0 : _a[((_b = res.dif) === null || _b === void 0 ? void 0 : _b.length) - 1],
+            macd: res.macd,
+            osc: res.osc,
+        });
+    });
     it("test getEMA12()", function () {
         var macd = new Macd();
         expect(macd.getEMA12(data)[data.length - 1]).toEqual({

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

@@ -0,0 +1,44 @@
+type ItemType = {
+    h: number;
+    l: number;
+    c: number;
+    v: number;
+};
+type ResObv = {
+    obv: number;
+} & ItemType;
+interface ObvType {
+    init: (data: ItemType) => {
+        dataset: ItemType[];
+        obv: number;
+        preClose: number;
+    };
+    next: (data: ItemType, preList: {
+        dataset: ItemType[];
+        obv: number;
+        preClose: number;
+    }) => {
+        dataset: ItemType[];
+        obv: number;
+        preClose: number;
+    };
+    getObv: (list: ItemType[], period: number) => ResObv[];
+}
+export default class Obv implements ObvType {
+    init(data: ItemType): {
+        dataset: ItemType[];
+        obv: number;
+        preClose: number;
+    };
+    next(data: ItemType, preList: {
+        dataset: ItemType[];
+        obv: number;
+        preClose: number;
+    }): {
+        dataset: ItemType[];
+        obv: number;
+        preClose: number;
+    };
+    getObv(list: ItemType[]): ResObv[];
+}
+export {};

package/dist/esm/stockSkills/obv.js

@@ -0,0 +1,87 @@
+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 Obv = /** @class */ (function () {
+    function Obv() {
+    }
+    Object.defineProperty(Obv.prototype, "init", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data) {
+            return {
+                dataset: [data],
+                obv: data.v,
+                preClose: data.c,
+            };
+        }
+    });
+    Object.defineProperty(Obv.prototype, "next", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, preList) {
+            var currentVolume = data.v;
+            var currentClose = data.c;
+            // obv
+            var obv = preList.obv;
+            if (currentClose > preList.preClose) {
+                obv += currentVolume;
+            }
+            else if (currentClose < preList.preClose) {
+                obv -= currentVolume;
+            }
+            return {
+                dataset: __spreadArray(__spreadArray([], preList.dataset, true), [data], false),
+                obv: obv,
+                preClose: currentClose,
+            };
+        }
+    });
+    Object.defineProperty(Obv.prototype, "getObv", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var res = [];
+            var obv = 0;
+            for (var i = 0; i < list.length; i++) {
+                var currentVolume = list[i].v;
+                var currentClose = list[i].c;
+                if (i > 0) {
+                    // obv
+                    if (currentClose > list[i - 1].c) {
+                        obv += currentVolume;
+                    }
+                    else if (currentClose < list[i - 1].c) {
+                        obv -= currentVolume;
+                    }
+                }
+                else {
+                    obv = currentVolume;
+                }
+                res[i] = __assign(__assign({}, list[i]), { obv: obv });
+            }
+            return res;
+        }
+    });
+    return Obv;
+}());
+export default Obv;

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

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

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

@@ -0,0 +1,18 @@
+import Obv from "./obv";
+import { data_9904 as data } from "./test_data.test";
+describe("test obv methods", function () {
+    it("test init", function () {
+        var obv = new Obv();
+        var init = obv.init(data[0]);
+        var res = init;
+        for (var i = 1; i < data.length; i++) {
+            var item = data[i];
+            res = obv.next(item, res);
+        }
+        expect(res.obv).toEqual(504538);
+    });
+    it("test getObv()", function () {
+        var kd = new Obv();
+        expect(kd.getObv(data)[data.length - 1].obv).toEqual(504538);
+    });
+});

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

@@ -1,15 +1,15 @@
-declare type ListType = {
+type ListType = {
     c: number;
 }[];
-declare type ResRsi6Type = {
+type ResRsi6Type = {
     c: number;
     rsi6?: number;
 }[];
-declare type ResRsi12Type = {
+type ResRsi12Type = {
     c: number;
     rsi12?: number;
 }[];
-declare type ResAllRsiType = {
+type ResAllRsiType = {
     c: number;
     rsi6?: number;
     rsi12?: number;

package/dist/esm/stockSkills/utils/getWeekLine.d.ts

@@ -1,11 +1,11 @@
-declare type ListType = {
+type ListType = {
     h: number;
     t: number;
     o: number;
     c: number;
     l: number;
 }[];
-export declare type ResType = {
+export type ResType = {
     h: number;
     t: number;
     o: number;

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

@@ -1,17 +1,17 @@
-declare type ListType = {
+type ListType = {
     h: number;
     l: number;
     c: number;
 }[];
-declare type ResWilliams9Type = {
+type ResWilliams9Type = {
     c: number;
     williams9?: number;
 }[];
-declare type ResWilliams18Type = {
+type ResWilliams18Type = {
     c: number;
     williams18?: number;
 }[];
-declare type ResAllWilliamsType = {
+type ResAllWilliamsType = {
     c: number;
     williams18?: number;
     williams9?: number;