@ch20026103/anysis 0.0.2-alpha

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

@@ -0,0 +1,43 @@
+import Gold from "./gold";
+import data from "./test_data.test";
+describe("test Gold methods", function () {
+    it("test findHighPoint()", function () {
+        var gold = new Gold();
+        var hightPoints = gold.findHighPoint(data);
+        expect(hightPoints["20211130"]).toEqual({
+            c: 155.5,
+            h: 164.5,
+            l: 155,
+            o: 158,
+            t: 20211130,
+            v: 83112,
+        });
+    });
+    it("test findLowPoint()", function () {
+        var gold = new Gold();
+        var lowPoints = gold.findLowPoint(data);
+        expect(lowPoints["20211122"]).toEqual({
+            t: 20211122,
+            o: 135,
+            h: 140,
+            l: 134,
+            c: 137.5,
+            v: 9864,
+        });
+    });
+    it("test getGold(", function () {
+        var gold = new Gold();
+        var allGold = gold.getGold(data);
+        expect(allGold).toEqual({
+            highestPoint: 164.5,
+            highestPointDate: 20211130,
+            lowestPoint: 134,
+            lowestPointDate: 20211122,
+            middle: 149.25,
+            strong: 152.85,
+            superStrong: 158.67,
+            superWeak: 139.83,
+            weak: 145.65,
+        });
+    });
+});

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

@@ -0,0 +1,58 @@
+declare type ListType = {
+    c: number;
+}[];
+declare type ResMa5 = {
+    c: number;
+    ma5?: number;
+}[];
+declare type ResMa10 = {
+    c: number;
+    ma10?: number;
+}[];
+declare type ResMa20 = {
+    c: number;
+    ma20?: number;
+}[];
+declare type ResMa60 = {
+    c: number;
+    ma60?: number;
+}[];
+declare type ResMaSelf = {
+    c: number;
+    maSelf?: number;
+}[];
+declare type ResBoll = {
+    c: number;
+    ma25?: number;
+    bollUb?: number;
+    bollLb?: number;
+}[];
+declare type ResAllMa = {
+    c: number;
+    ma5?: number;
+    ma10?: number;
+    ma20?: number;
+    ma25?: number;
+    ma60?: number;
+    bollUb?: number;
+    bollLb?: number;
+}[];
+interface MaType {
+    getAllMa: (list: ListType) => ResAllMa;
+    getMa5: (list: ListType) => ResMa5;
+    getMa10: (list: ListType) => ResMa10;
+    getMa20: (list: ListType) => ResMa20;
+    getMa60: (list: ListType) => ResMa60;
+    getMaSelf: (list: ListType, self: number) => ResMaSelf;
+    getBoll: (list: ListType) => ResBoll;
+}
+export default class Ma implements MaType {
+    getAllMa(list: ListType): ResAllMa;
+    getMa5(list: ListType): ResMa5;
+    getMa10(list: ListType): ResMa10;
+    getMa20(list: ListType): ResMa20;
+    getMa60(list: ListType): ResMa60;
+    getMaSelf(list: ListType, self: number): ResMaSelf;
+    getBoll(list: ListType): ResBoll;
+}
+export {};

package/dist/esm/stockSkills/ma.js

@@ -0,0 +1,167 @@
+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 Ma = /** @class */ (function () {
+    function Ma() {
+    }
+    Object.defineProperty(Ma.prototype, "getAllMa", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var res = [];
+            var responseMa5 = this.getMa5(list);
+            var responseMa10 = this.getMa10(list);
+            var responseMa20 = this.getMa20(list);
+            var responseMa60 = this.getMa60(list);
+            var responseBoll = this.getBoll(list);
+            for (var i = 0; i < list.length; i++) {
+                res[i] = Object.assign(list[i], responseMa5[i], responseMa10[i], responseMa20[i], responseMa60[i], responseBoll[i]);
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(Ma.prototype, "getMa5", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < 4)
+                    res[i] = __assign(__assign({}, list[i]), { ma5: undefined });
+                else {
+                    var sum = list
+                        .slice(i - 4, i + 1)
+                        .reduce(function (pre, current) { return pre + current.c; }, 0);
+                    var ma5 = Math.round((sum / 5) * 100) / 100;
+                    res[i] = __assign(__assign({}, list[i]), { ma5: ma5 });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(Ma.prototype, "getMa10", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < 9)
+                    res[i] = __assign(__assign({}, list[i]), { ma10: undefined });
+                else {
+                    var sum = list
+                        .slice(i - 9, i + 1)
+                        .reduce(function (pre, current) { return pre + current.c; }, 0);
+                    var ma10 = Math.round((sum / 10) * 100) / 100;
+                    res[i] = __assign(__assign({}, list[i]), { ma10: ma10 });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(Ma.prototype, "getMa20", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < 19)
+                    res[i] = __assign(__assign({}, list[i]), { ma20: undefined });
+                else {
+                    var sum = list
+                        .slice(i - 19, i + 1)
+                        .reduce(function (pre, current) { return pre + current.c; }, 0);
+                    var ma20 = Math.round((sum / 20) * 100) / 100;
+                    res[i] = __assign(__assign({}, list[i]), { ma20: ma20 });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(Ma.prototype, "getMa60", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < 59)
+                    res[i] = __assign(__assign({}, list[i]), { ma60: undefined });
+                else {
+                    var sum = list
+                        .slice(i - 59, i + 1)
+                        .reduce(function (pre, current) { return pre + current.c; }, 0);
+                    var ma60 = Math.round((sum / 60) * 100) / 100;
+                    res[i] = __assign(__assign({}, list[i]), { ma60: ma60 });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(Ma.prototype, "getMaSelf", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list, self) {
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < (self - 1))
+                    res[i] = __assign(__assign({}, list[i]), { maSelf: undefined });
+                else {
+                    var sum = list
+                        .slice(i - (self - 1), i + 1)
+                        .reduce(function (pre, current) { return pre + current.c; }, 0);
+                    var maSelf = Math.round((sum / self) * 100) / 100;
+                    res[i] = __assign(__assign({}, list[i]), { maSelf: maSelf });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(Ma.prototype, "getBoll", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var res = [];
+            var _loop_1 = function (i) {
+                if (i < 24)
+                    res[i] = __assign(__assign({}, list[i]), { ma25: undefined, bollUb: undefined, bollLb: undefined });
+                else {
+                    // ma25
+                    var sumMa25 = list
+                        .slice(i - 24, i + 1)
+                        .reduce(function (pre, current) { return pre + current.c; }, 0);
+                    var ma25_1 = Math.round((sumMa25 / 25) * 100) / 100;
+                    // 標準差
+                    var sumBase = res
+                        .slice(i - 24, i + 1)
+                        .reduce(function (pre, current) {
+                        return ma25_1 !== undefined
+                            ? pre + Math.pow(current.c - ma25_1, 2)
+                            : pre;
+                    }, 0);
+                    var base = Math.round(Math.sqrt(sumBase / 25) * 100) / 100;
+                    res[i] = __assign(__assign({}, list[i]), { ma25: ma25_1, bollUb: ma25_1 + 2 * base, bollLb: ma25_1 - 2 * base });
+                }
+            };
+            for (var i = 0; i < list.length; i++) {
+                _loop_1(i);
+            }
+            return res;
+        }
+    });
+    return Ma;
+}());
+export default Ma;

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

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

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

@@ -0,0 +1,96 @@
+import Ma from "./ma";
+import data from "./test_data.test";
+describe("test ma methods", function () {
+    it("test getMa5()", function () {
+        var ma = new Ma();
+        expect(ma.getMa5(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            ma5: 141.1,
+        });
+    });
+    it("test getMa10()", function () {
+        var ma = new Ma();
+        expect(ma.getMa10(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            ma10: 146.7,
+        });
+    });
+    it("test getMa20()", function () {
+        var ma = new Ma();
+        expect(ma.getMa20(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            ma20: 144.88,
+        });
+    });
+    it("test getMa60()", function () {
+        var ma = new Ma();
+        expect(ma.getMa60(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            ma60: 134.86,
+        });
+    });
+    it("test getMaSelf()", function () {
+        var ma = new Ma();
+        expect(ma.getMaSelf(data, 20)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            maSelf: 144.88,
+        });
+    });
+    it("test getBoll()", function () {
+        var ma = new Ma();
+        expect(ma.getBoll(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            ma25: 142.66,
+            bollLb: 126.69999999999999,
+            bollUb: 158.62,
+        });
+    });
+    it("test getAllMa()", function () {
+        var ma = new Ma();
+        expect(ma.getAllMa(data)[data.length - 1]).toEqual({
+            t: 20211214,
+            o: 138,
+            h: 143,
+            l: 138,
+            c: 142,
+            v: 16841,
+            ma5: 141.1,
+            ma10: 146.7,
+            ma20: 144.88,
+            ma60: 134.86,
+            ma25: 142.66,
+            bollUb: 158.62,
+            bollLb: 126.69999999999999,
+        });
+    });
+});

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

@@ -0,0 +1,59 @@
+declare type ItemType = {
+    h: number;
+    l: number;
+    c: number;
+};
+declare type ResEMA12Type = {
+    h: number;
+    l: number;
+    c: number;
+    EMA12?: number;
+}[];
+declare type ResEMA26Type = {
+    h: number;
+    l: number;
+    c: number;
+    EMA26?: number;
+}[];
+declare type ResDifType = {
+    h: number;
+    l: number;
+    c: number;
+    DIF?: number;
+}[];
+declare type ResMacd9Type = {
+    h: number;
+    l: number;
+    c: number;
+    MACD9?: number;
+    OSC?: number;
+}[];
+declare type ResAllMacdType = {
+    h: number;
+    l: number;
+    c: number;
+    EMA12?: number;
+    EMA26?: number;
+    DIF?: number;
+    MACD9?: number;
+    OSC?: number;
+}[];
+interface MacdType {
+    getMACD: (list: ItemType[]) => ResAllMacdType;
+    getDI: (item: ItemType) => number;
+    getStartEMA: (list: ItemType[]) => number;
+    getEMA12: (list: ItemType[]) => ResEMA12Type;
+    getEMA26: (list: ItemType[]) => ResEMA26Type;
+    getDIF: (list: ItemType[], ResEMA12: ResEMA12Type, ResEMA26: ResEMA26Type) => ResDifType;
+    getMACD9: (list: ItemType[], DIF: ResDifType) => ResMacd9Type;
+}
+export default class MACD implements MacdType {
+    getMACD(list: ItemType[]): ResAllMacdType;
+    getDI(item: ItemType): number;
+    getStartEMA(arr: ItemType[]): number;
+    getEMA12(list: ItemType[]): ResEMA12Type;
+    getEMA26(list: ItemType[]): ResEMA26Type;
+    getDIF(list: ItemType[], ResEMA12: ResEMA12Type, ResEMA26: ResEMA26Type): ResDifType;
+    getMACD9(list: ItemType[], DIF: ResDifType): ResMacd9Type;
+}
+export {};

package/dist/esm/stockSkills/macd.js

@@ -0,0 +1,142 @@
+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 MACD = /** @class */ (function () {
+    function MACD() {
+    }
+    Object.defineProperty(MACD.prototype, "getMACD", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            // 首筆RSI
+            var res = [];
+            var EMA12 = this.getEMA12(list);
+            var EMA26 = this.getEMA26(list);
+            var DIF = this.getDIF(list, EMA12, EMA26);
+            var MACD9 = this.getMACD9(list, DIF);
+            for (var i = 0; i < list.length; i++) {
+                res[i] = Object.assign(list[i], DIF[i], MACD9[i]);
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(MACD.prototype, "getDI", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (item) {
+            return (item["h"] + item["l"] + 2 * item["c"]) / 4;
+        }
+    });
+    Object.defineProperty(MACD.prototype, "getStartEMA", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (arr) {
+            var _this = this;
+            var sum = 0;
+            arr.forEach(function (item) {
+                var DI = _this.getDI(item);
+                sum += DI;
+            });
+            return sum / arr.length;
+        }
+    });
+    Object.defineProperty(MACD.prototype, "getEMA12", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var start = list.slice(0, 11);
+            var beforeEMA12 = this.getStartEMA(start);
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < 12)
+                    res[i] = __assign(__assign({}, list[i]), { EMA12: undefined });
+                else {
+                    beforeEMA12 = (beforeEMA12 * 11) / 13 + (this.getDI(list[i]) * 2) / 13;
+                    res[i] = __assign(__assign({}, list[i]), { EMA12: beforeEMA12 });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(MACD.prototype, "getEMA26", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list) {
+            var start = list.slice(0, 25);
+            var beforeEMA26 = this.getStartEMA(start);
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < 26)
+                    res[i] = __assign(__assign({}, list[i]), { EMA26: undefined });
+                else {
+                    beforeEMA26 = (beforeEMA26 * 25) / 27 + (this.getDI(list[i]) * 2) / 27;
+                    res[i] = __assign(__assign({}, list[i]), { EMA26: beforeEMA26 });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(MACD.prototype, "getDIF", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list, ResEMA12, ResEMA26) {
+            var _a, _b;
+            var res = [];
+            for (var i = 0; i < list.length; i++) {
+                if (i < 26)
+                    res[i] = __assign(__assign({}, list[i]), { DIF: undefined });
+                else {
+                    var EMA12 = ((_a = ResEMA12 === null || ResEMA12 === void 0 ? void 0 : ResEMA12[i]) === null || _a === void 0 ? void 0 : _a["EMA12"]) && ResEMA12[i]["EMA12"];
+                    var EMA26 = ((_b = ResEMA26 === null || ResEMA26 === void 0 ? void 0 : ResEMA26[i]) === null || _b === void 0 ? void 0 : _b["EMA26"]) && ResEMA26[i]["EMA26"];
+                    var DIF = EMA12 - EMA26;
+                    res[i] = __assign(__assign({}, list[i]), { DIF: DIF });
+                }
+            }
+            return res;
+        }
+    });
+    Object.defineProperty(MACD.prototype, "getMACD9", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (list, DIF) {
+            var res = [];
+            var beforeMACD9 = 0;
+            for (var i = 0; i < list.length; i++) {
+                if (i < 26)
+                    res[i] = __assign(__assign({}, list[i]), { MACD9: undefined, OSC: undefined });
+                else if (i === 26) {
+                    var MACD9 = DIF.slice(26, 34)
+                        .map(function (item) { return ((item === null || item === void 0 ? void 0 : item.DIF) ? item["DIF"] : 0); })
+                        .reduce(function (accumulator, currentValue) { return accumulator + currentValue; });
+                    var OSC = DIF[i]["DIF"] - MACD9;
+                    res[26] = __assign(__assign({}, list[i]), { MACD9: MACD9, OSC: OSC });
+                    beforeMACD9 = MACD9;
+                }
+                else {
+                    var MACD9 = beforeMACD9 + ((DIF[i]["DIF"] - beforeMACD9) * 2) / 10;
+                    var OSC = DIF[i]["DIF"] - MACD9;
+                    res[i] = __assign(__assign({}, list[i]), { MACD9: MACD9, OSC: OSC });
+                    beforeMACD9 = MACD9;
+                }
+            }
+            return res;
+        }
+    });
+    return MACD;
+}());
+export default MACD;

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

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

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

@@ -0,0 +1,72 @@
+import Macd from "./macd";
+import data from "./test_data.test";
+describe("test macd methods", function () {
+    it("test getEMA12()", function () {
+        var macd = new Macd();
+        expect(macd.getEMA12(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            EMA12: 144.01967137166324,
+        });
+    });
+    it("test getEMA26()", function () {
+        var macd = new Macd();
+        expect(macd.getEMA26(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            EMA26: 142.2290771028552,
+        });
+    });
+    it("test getDIF()", function () {
+        var macd = new Macd();
+        var Ema26 = macd.getEMA26(data);
+        var Ema12 = macd.getEMA12(data);
+        expect(macd.getDIF(data, Ema12, Ema26)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            DIF: 1.7905942688080358,
+        });
+    });
+    it("test getMACD9()", function () {
+        var macd = new Macd();
+        var Ema26 = macd.getEMA26(data);
+        var Ema12 = macd.getEMA12(data);
+        var Dif = macd.getDIF(data, Ema12, Ema26);
+        expect(macd.getMACD9(data, Dif)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            MACD9: 3.461688641153529,
+            OSC: -1.6710943723454932,
+        });
+    });
+    it("test getMACD()", function () {
+        var macd = new Macd();
+        expect(macd.getMACD(data)[data.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            DIF: 1.7905942688080358,
+            MACD9: 3.461688641153529,
+            OSC: -1.6710943723454932,
+        });
+    });
+});

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

@@ -0,0 +1,32 @@
+declare type ListType = {
+    c: number;
+}[];
+declare type ResRsi6Type = {
+    c: number;
+    rsi6?: number;
+}[];
+declare type ResRsi12Type = {
+    c: number;
+    rsi12?: number;
+}[];
+declare type ResAllRsiType = {
+    c: number;
+    rsi6?: number;
+    rsi12?: number;
+}[];
+interface RsiType {
+    getRsi6: (list: ListType) => ResRsi6Type;
+    getRsi12: (list: ListType) => ResRsi12Type;
+    getStartUpAvg: (list: ListType, count: number) => number;
+    getStartDownAvg: (list: ListType, count: number) => number;
+    getRsi: (UpAvg: number, DownAvg: number) => number;
+}
+export default class Rsi implements RsiType {
+    getAllRsi(list: ListType): ResAllRsiType;
+    getRsi6(list: ListType): ResRsi6Type;
+    getRsi12(list: ListType): ResRsi12Type;
+    getStartUpAvg(list: ListType, count: number): number;
+    getStartDownAvg(list: ListType, count: number): number;
+    getRsi(UpAvg: number, DownAvg: number): number;
+}
+export {};