@watsonserve/stock-base 0.1.6 → 0.1.7

package/baidu.js

@@ -0,0 +1,137 @@
+import { EnCurrency, EnMarket } from './stock.js';
+import { getMarketCloseTime } from './close-time.js';
+import WebRequest from './web-request.js';
+import { sleep } from './helper.js';
+export class BaiduLoader extends WebRequest {
+    static __instance;
+    async __fetch(url, method = 'GET', params) {
+        if (new URL(this.page.url()).origin !== 'https://finance.baidu.com')
+            throw new Error('Not on finance.baidu.com');
+        let token = '';
+        try {
+            await this.page.waitForFunction(() => !!window['paris_2108']?.getAcsToken, undefined, { timeout: 15000 });
+            token = await this.page.evaluate(() => new Promise(r => window['paris_2108'].getAcsToken(r)));
+        }
+        catch (err) {
+            throw new Error(`failed to get Acs-Token: ${err.message}`);
+        }
+        return super.fetch(url, method, params, { 'Acs-Token': token });
+    }
+    // 匯率
+    async __loadFx(ncs) {
+        try {
+            const data = new Map();
+            for (const nc of ncs) {
+                const body = await this.__fetch('https://finance.pae.baidu.com/vapi/v1/sug', 'GET', { wd: `USD${nc}`, skip_login: 1, finClientType: 'pc' });
+                const fx = body.Result.list[0];
+                data.set(nc, +fx.price);
+            }
+            return Object.fromEntries(data.entries());
+        }
+        catch (err) {
+            throw new Error(`failed to load fx ${err.message}`);
+        }
+    }
+    // 标普500成份股
+    async __sp500(pn = 0, rn = 100) {
+        const params = {
+            financeType: 'index',
+            market: 'us',
+            code: 'SPX',
+            sortKey: 'marketValue',
+            sortType: 'desc',
+            style: 'tablelist',
+            finClientType: 'pc',
+            pn, rn,
+        };
+        try {
+            const resp = await this.__fetch('https://finance.pae.baidu.com/sapi/v1/constituents', 'GET', params);
+            const stocklist = resp.Result.list.body;
+            return stocklist.map(item => {
+                const { code: nc, name: n, rawData } = item;
+                const { lastPx: c, volume: v, marketValue: mv } = rawData;
+                return { nc, n, c, v, mv };
+            });
+        }
+        catch (err) {
+            throw new Error(`failed to load s&p ${err.message}`);
+        }
+    }
+    static async factory() {
+        const baidu = new BaiduLoader();
+        await baidu._mount();
+        return baidu;
+    }
+    static async getInstance() {
+        if (BaiduLoader.__instance)
+            return BaiduLoader.__instance;
+        BaiduLoader.__instance = BaiduLoader.factory().catch(err => {
+            BaiduLoader.__instance = null;
+            throw err;
+        });
+        return BaiduLoader.__instance;
+    }
+    constructor() {
+        super();
+    }
+    async _mount() {
+        await super._mount('https://finance.baidu.com/index/us-SPX?mainTab=成分股');
+        await sleep(1000);
+    }
+    async destroy() {
+        BaiduLoader.__instance = null;
+        await super.destroy();
+    }
+    async loadFxHistory() {
+        const fxs = await Promise.all([EnCurrency.SGD, EnCurrency.HKD, EnCurrency.CNY].map(code => this.__fetch('https://finance.pae.baidu.com/vapi/v1/getquotation', 'GET', { group: 'huilv_kline', ktype: 'day', code: `USD${code}`, count: 204, finClientType: 'pc' })));
+        const [hk, sg, cn] = fxs.map(body => body.Result.newMarketData.marketData.split(';'));
+        const base = new Map(hk.map(line => {
+            const [_0, date, _1, c] = line.split(',');
+            const stamp = getMarketCloseTime(EnMarket.FX, new Date(`${date}T15:00:00Z`).getTime());
+            return [stamp, { date, HKD: +c }];
+        }));
+        sg.forEach(line => {
+            const [_0, date, _1, c] = line.split(',');
+            const stamp = getMarketCloseTime(EnMarket.FX, new Date(`${date}T15:00:00Z`).getTime());
+            const fx = base.get(stamp) || { date };
+            fx.SGD = +c;
+            base.set(stamp, fx);
+        });
+        cn.map(line => {
+            const [_0, date, _1, c] = line.split(',');
+            const stamp = getMarketCloseTime(EnMarket.FX, new Date(`${date}T15:00:00Z`).getTime());
+            const fx = base.get(stamp) || { date };
+            fx.CNY = +c;
+            base.set(stamp, fx);
+        });
+        const result = [];
+        const remain = [];
+        [...base.entries()].forEach(([stamp, fx]) => {
+            const _fx = { stamp, ...fx };
+            if (!fx.HKD || !fx.SGD || !fx.CNY) {
+                remain.push(_fx);
+                return;
+            }
+            result.push(_fx);
+        });
+        return { result, remain };
+    }
+    async loadFx() {
+        const fxs = await this.__loadFx([EnCurrency.SGD, EnCurrency.HKD, EnCurrency.CNY]);
+        const stamp = getMarketCloseTime(EnMarket.FX);
+        return { ...fxs, stamp };
+    }
+    async loadPrices() {
+        let pn = 0, rn = 100;
+        let sts = [];
+        while (true) {
+            const _sts = await this.__sp500(pn, rn);
+            const _len = _sts.length;
+            sts = sts.concat(_sts);
+            if (_len < rn)
+                break;
+            pn += _len;
+        }
+        return sts;
+    }
+}

package/eastmoney.js

@@ -0,0 +1,95 @@
+import { formatFullNc, sleep, ttm } from './helper.js';
+import { EnMarket } from './stock.js';
+import WebRequest from './web-request.js';
+import { getMarketCloseTime } from './close-time.js';
+export class EastmoneyLoader extends WebRequest {
+    static __instance;
+    static async factory() {
+        const eastmoney = new EastmoneyLoader();
+        await eastmoney._mount();
+        return eastmoney;
+    }
+    static async getInstance() {
+        if (EastmoneyLoader.__instance)
+            return EastmoneyLoader.__instance;
+        EastmoneyLoader.__instance = EastmoneyLoader.factory().catch(err => {
+            EastmoneyLoader.__instance = null;
+            throw err;
+        });
+        return EastmoneyLoader.__instance;
+    }
+    async destroy() {
+        EastmoneyLoader.__instance = null;
+        await super.destroy();
+    }
+    constructor() {
+        super();
+    }
+    async loadDividend(nc) {
+        const params = {
+            reportName: 'RPT_USF10_INFO_DIVIDEND',
+            columns: 'SECUCODE,SECURITY_CODE,SECURITY_NAME_ABBR,SECURITY_INNER_CODE,NOTICE_DATE,ASSIGN_TYPE,PLAN_EXPLAIN,EQUITY_RECORD_DATE,BONUS_PAY_DATE,EX_DIVIDEND_DATE,ASSIGN_PERIOD',
+            // filter: `(SECUCODE="${nc}.N")`,
+            filter: `(SECURITY_CODE="${nc.replace('.', '_')}")`,
+            pageNumber: 1,
+            pageSize: 200,
+            sortTypes: -1,
+            sortColumns: 'EX_DIVIDEND_DATE',
+            source: 'SECURITIES',
+            client: 'PC',
+            v: Math.random().toString().substring(2).padStart(17, '0')
+        };
+        const strResp = await super.fetch('https://datacenter.eastmoney.com/securities/api/data/v1/get', params);
+        const data = (JSON.parse(strResp).result?.data || []);
+        const dividend = [];
+        for (const item of data) {
+            const { ASSIGN_TYPE, PLAN_EXPLAIN, NOTICE_DATE, EX_DIVIDEND_DATE, BONUS_PAY_DATE } = item;
+            if ('Cash' === ASSIGN_TYPE || 'Special cash' === ASSIGN_TYPE) {
+                const amount = +PLAN_EXPLAIN.match(/(\d*\.?\d+)美元/)[1]; // 每1股派0.82美元股息
+                if (!amount)
+                    console.warn(item);
+                dividend.push({
+                    currency: 'USD',
+                    amount,
+                    annc: new Date(NOTICE_DATE),
+                    ex: new Date(EX_DIVIDEND_DATE),
+                    paid: new Date(BONUS_PAY_DATE),
+                });
+                continue;
+            }
+        }
+        return formatFullNc(nc, 'US', ttm('ex', dividend), []);
+    }
+    /**
+     * @warning This method requires the Eastmoney page to be loaded and may not work if the page structure changes.
+     */
+    async loadHistory(nc) {
+        await super.goto(`https://quote.eastmoney.com/us/${nc}.html`);
+        await sleep(500);
+        const secid = await super.read('quotecode');
+        const params = {
+            fields1: 'f1,f2,f3,f4,f5,f6',
+            fields2: 'f51,f52,f53,f54,f55,f56,f57,f58,f59,f60,f61',
+            klt: 101, // 60 hour, 101 day, 102 week, 103 month
+            fqt: 0,
+            secid,
+            beg: 0,
+            end: 20500000,
+            // ut: 'bd1d9ddb04089700cf9c27f6f7426281',
+            // lmt: 1000000,
+        };
+        if (WebRequest.isDebug)
+            await sleep(5000);
+        const resp = await super.fetch('https://push2his.eastmoney.com/api/qt/stock/kline/get', params);
+        // const resp = JSON.parse(await fs.readFile(path.join(import.meta.dirname, 'hsbc.json'), 'utf-8'));
+        const { klines } = resp.data;
+        return klines.map(line => {
+            const [date, open, close, hight, low, vol] = line.split(',');
+            return {
+                market: EnMarket.USA,
+                timestamp: getMarketCloseTime(EnMarket.USA, new Date(`${date}T15:00:00Z`).getTime()),
+                st: { nc, n: '', o: +open, c: +close, h: +hight, l: +low, v: +vol }
+            };
+        });
+    }
+}

package/helper.js

@@ -33,3 +33,22 @@ export function ttm(by, list) {
         return sinceTime < Date.UTC(val.getUTCFullYear(), val.getUTCMonth());
     });
 }
+export function toDivPoint(fullNc, div) {
+    const { annc, ex, paid, ...another } = div;
+    return {
+        ...another,
+        nc: fullNc,
+        annc: ~~(annc.getTime() / 1000),
+        ex: ~~(ex.getTime() / 1000),
+        paid: ~~(paid.getTime() / 1000)
+    };
+}
+export function parseUTCDate(str) {
+    return ~~(Date.UTC(+str.slice(0, 4), +str.slice(4, 6) - 1, +str.slice(6, 8)) / 1000);
+}
+export function formatFullNc(nc, market, div, bonus) {
+    const fullNc = `${nc}.${market}`;
+    const dps = div.map(item => toDivPoint(fullNc, item));
+    const bps = bonus.map(item => toDivPoint(fullNc, item));
+    return { fullNc, nc, dps, bps };
+}

package/hkex.js

@@ -0,0 +1,191 @@
+import WebRequest from './web-request.js';
+import { formatFullNc, parseUTCDate, ttm } from './helper.js';
+import { EnMarket } from './stock.js';
+import { A_DAY_MS, A_DAY_S } from './close-time.js';
+export var EnInt;
+(function (EnInt) {
+    EnInt[EnInt["day_1"] = 0] = "day_1";
+    EnInt[EnInt["mo_1"] = 2] = "mo_1";
+    EnInt[EnInt["mo_3"] = 3] = "mo_3";
+    EnInt[EnInt["mo_6"] = 4] = "mo_6";
+    EnInt[EnInt["yr_1"] = 5] = "yr_1";
+    EnInt[EnInt["yrs_2"] = 6] = "yrs_2";
+    EnInt[EnInt["yrs_5"] = 7] = "yrs_5";
+    EnInt[EnInt["yrs_10"] = 8] = "yrs_10";
+    EnInt[EnInt["ytd"] = 9] = "ytd";
+})(EnInt || (EnInt = {}));
+export var EnSpan;
+(function (EnSpan) {
+    EnSpan[EnSpan["min"] = 0] = "min";
+    EnSpan[EnSpan["day"] = 6] = "day";
+    EnSpan[EnSpan["week"] = 7] = "week";
+    EnSpan[EnSpan["month"] = 8] = "month";
+    EnSpan[EnSpan["quarter"] = 9] = "quarter";
+})(EnSpan || (EnSpan = {}));
+const rxDate = /\d+/g;
+function dateCNtoDate(str) {
+    const ymd = str.match(rxDate)?.slice(0, 3).map(i => +i);
+    if (!ymd)
+        return null;
+    if ('number' === typeof ymd?.[1]) {
+        ymd[1] -= 1;
+    }
+    return new Date(Date.UTC.apply(null, ymd));
+}
+const HKDict = Object.entries({
+    'The first day of January': 'New Year\'s Day',
+    'Lunar New Year’s Day': 'Chinese New Year',
+    'Hong Kong Special Administrative Region': 'HK SAR',
+    '香港公眾假期 -': '',
+    'Hong Kong Public Holidays -': '',
+    'The day following': ''
+});
+function simpleTitle(title = '') {
+    return HKDict.reduce((str, [k, v]) => str.replace(k, v), title).trim();
+}
+export class HKEXLoader extends WebRequest {
+    static HKEX_TOKEN = { token: '', t: 0 };
+    static tokenPromise = null;
+    static __instance;
+    async __fetchHkexToken() {
+        const doc = await super.fetch('https://www.hkex.com.hk/Market-Data/Securities-Prices/Equities', { sc_lang: 'zh-HK' });
+        const token = doc.split('//return "Base64-AES-Encrypted-Token";')[1].split('";')[0].split('"')[1];
+        const decodedToken = decodeURIComponent(token);
+        HKEXLoader.HKEX_TOKEN = { token: decodedToken, t: Date.now() };
+        return decodedToken;
+    }
+    async __loadHkexToken() {
+        const expiry = Date.now() - A_DAY_MS;
+        if (HKEXLoader.HKEX_TOKEN?.t > expiry)
+            return HKEXLoader.HKEX_TOKEN.token;
+        if (HKEXLoader.tokenPromise)
+            return HKEXLoader.tokenPromise;
+        HKEXLoader.tokenPromise = this.__fetchHkexToken().catch(err => {
+            HKEXLoader.tokenPromise = null;
+            throw err;
+        });
+        return HKEXLoader.tokenPromise;
+    }
+    static async factory() {
+        const hkex = new HKEXLoader();
+        await hkex._mount();
+        return hkex;
+    }
+    static async getInstance() {
+        if (HKEXLoader.__instance)
+            return HKEXLoader.__instance;
+        HKEXLoader.__instance = HKEXLoader.factory().catch(err => {
+            HKEXLoader.__instance = null;
+            throw err;
+        });
+        return HKEXLoader.__instance;
+    }
+    constructor() {
+        super();
+    }
+    async destroy() {
+        HKEXLoader.__instance = null;
+        await super.destroy();
+    }
+    async loadDividend(nc) {
+        const token = await this.__loadHkexToken();
+        const qid = Date.now();
+        const callback = `jsonp_${qid}`;
+        const params = { sym: +nc, token, lang: 'chi', recperpage: 5, page: 1, qid, callback };
+        const resp = await super.fetch('https://www1.hkex.com.hk/hkexwidget/data/getequityentitlement', params);
+        const strJson = resp.substring(callback.length + 1, resp.length - 1);
+        const { entitlementlist } = JSON.parse(strJson).data;
+        const list = [];
+        for (const item of entitlementlist) {
+            const { detail, announcement_date, ex_date, payment_date, announcement_URL } = item;
+            const annc = dateCNtoDate(announcement_date);
+            const ex = dateCNtoDate(ex_date);
+            const paid = dateCNtoDate(payment_date);
+            const divid = Array.from(detail.match(/(USD|HKD|GBP) (\d+\.\d+)/g) || [])
+                .reduce((pre, item) => {
+                const [currency, amount] = item.split(' ');
+                pre[currency] = { currency, amount: +amount };
+                return pre;
+            }, {});
+            list.push({ ...(divid['HKD'] || divid['USD'] || divid['GBP']), annc, ex, paid, announcement_URL });
+        }
+        return formatFullNc(nc, 'HK', ttm('ex', list), []);
+    }
+    // 香港交易所主板股票
+    async loadPrices() {
+        try {
+            const token = await this.__loadHkexToken();
+            const qid = Date.now();
+            const callback = `jsonp_${qid}`;
+            const params = {
+                lang: 'chi',
+                token,
+                sort: 5,
+                order: 0,
+                all: 1,
+                subcat: 1,
+                market: 'MAIN',
+                qid,
+                callback,
+            };
+            const resp = await super.fetch('https://www1.hkex.com.hk/hkexwidget/data/getequityfilter', params);
+            const strJson = resp.substring(callback.length + 1, resp.length - 1);
+            const body = JSON.parse(strJson);
+            const { stocklist } = body.data;
+            return stocklist.map(item => {
+                const { sym, nm: n, ls } = item;
+                return { nc: sym.padStart(5, '0'), n, c: +ls };
+            });
+        }
+        catch (err) {
+            throw new Error(`failed to load hkex ${err.message}`);
+        }
+    }
+    async loadHolidays() {
+        const resp = await fetch('https://www.hkex.com.hk/News/HKEX-Calendar/Subscribe-Calendar?sc_lang=en');
+        const text = (await resp.text()).replace(/\r\n/g, '\n').replace(/\n\n/g, '\n'); // handle line folding
+        return text.split('\nEND:VEVENT\nBEGIN:VEVENT\n').reduce((pre, blk) => {
+            const ev = new Map(blk.split('\n').map(line => line.split(':', 2)));
+            if (!['香港市場休市', 'Hong Kong Market is closed'].includes(ev.get('DESCRIPTION') || ''))
+                return pre;
+            const start = parseUTCDate(ev.get('DTSTART;VALUE=DATE') || '');
+            let end = parseUTCDate(ev.get('DTEND;VALUE=DATE') || '');
+            if (start === end) {
+                end += A_DAY_S;
+            }
+            const lastOne = pre[pre.length - 1];
+            if (lastOne && start === lastOne.end) {
+                lastOne.end = end;
+            }
+            else {
+                pre.push({ market: 'HK', title: simpleTitle(ev.get('SUMMARY')), start, end });
+            }
+            return pre;
+        }, []);
+    }
+    // HSI
+    async loadHistory(nc, int = EnInt.yr_1) {
+        const token = await this.__loadHkexToken();
+        const qid = Date.now();
+        const callback = `jsonp_${qid}`;
+        const params = {
+            token, qid, callback,
+            hchart: 1,
+            span: EnSpan.day,
+            int,
+            ric: '.' === nc[0] ? nc : `${nc.padStart(5, '0').substring(1)}.HK`,
+        };
+        const resp = await super.fetch('https://www1.hkex.com.hk/hkexwidget/data/getchartdata2', params);
+        const strJson = resp.substring(callback.length + 1, resp.length - 1);
+        const body = JSON.parse(strJson);
+        const datalist = body.data.datalist.slice(1, -1);
+        return datalist.map(item => {
+            const [timestamp, o, h, l, c, v] = item;
+            return {
+                market: EnMarket.HKEX,
+                timestamp: ~~(new Date(`${new Date(timestamp).toJSON().substring(0, 10)}T08:10:00Z`).getTime() / 1000),
+                st: { nc, n: '', o, h, l, c, v }
+            };
+        });
+    }
+}

package/index.js

@@ -1,74 +1,116 @@
-import { A_DAY_S } from './close-time.js';
-import { DividendLoader } from './dividend-loader.js';
-import { generateUSHolidays } from './us-holiday.js';
+import { BaiduLoader } from './baidu.js';
+import { EastmoneyLoader } from './eastmoney.js';
+import { EnMarket } from './stock.js';
+import WebRequest from './web-request.js';
+import { splitFullNc, ttm } from './helper.js';
+import { HKEXLoader } from './hkex.js';
+import { SGXLoader } from './sgx.js';
+import { generateUSHolidays } from './usa-holiday.js';
 export * from './close-time.js';
 export * from './stock.js';
 export * from './log.js';
 export * from './helper.js';
-function parseUTCDate(str) {
-    return ~~(Date.UTC(+str.slice(0, 4), +str.slice(4, 6) - 1, +str.slice(6, 8)) / 1000);
-}
-const HKDict = Object.entries({
-    'The first day of January': 'New Year\'s Day',
-    'Lunar New Year’s Day': 'Chinese New Year',
-    'Hong Kong Special Administrative Region': 'HK SAR',
-    '香港公眾假期 -': '',
-    'Hong Kong Public Holidays -': '',
-    'The day following': ''
-});
-function simpleTitle(title = '') {
-    return HKDict.reduce((str, [k, v]) => str.replace(k, v), title).trim();
+async function __load(Gen, fn) {
+    const ins = await Gen.getInstance();
+    let result = undefined;
+    let err = undefined;
+    try {
+        result = await fn(ins);
+    }
+    catch (_err) {
+        err = _err;
+    }
+    ins.destroy();
+    return err ? Promise.reject(err) : result;
 }
-export class StockLoader extends DividendLoader {
-    async loadHolidaysSG(year) {
-        const resp = await fetch(`https://www.mom.gov.sg/-/media/mom/documents/employment-practices/public-holidays/public-holidays-sg-${year}.ics`);
-        const text = (await resp.text()).replace(/\r\n/g, '\n').replace(/\n\n/g, '\n'); // handle line folding
-        return text.split('\nEND:VEVENT\nBEGIN:VEVENT\n').reduce((pre, blk) => {
-            const ev = new Map(blk.split('\n').map(line => line.split(':', 2)));
-            let start = parseUTCDate(ev.get('DTSTART;VALUE=DATE') || '');
-            let end = parseUTCDate(ev.get('DTEND;VALUE=DATE') || '');
-            if (start === end) {
-                end += A_DAY_S;
-            }
-            // recording to SG calendar, we will move it to next day(Monday, 1) if holiday is Sunday(0)
-            if (!new Date(start * 1000).getUTCDay()) {
-                end += A_DAY_S;
-            }
-            const firstOne = pre[0];
-            const title = ev.get('SUMMARY') || '';
-            (firstOne && end === firstOne.start) ? Object.assign(firstOne, { title, start }) : pre.unshift({ market: 'SG', title, start, end });
-            return pre;
-        }, []);
+export class StockLoader {
+    get isDebug() {
+        return WebRequest.isDebug;
     }
-    async loadHolidaysHK() {
-        const resp = await fetch('https://www.hkex.com.hk/News/HKEX-Calendar/Subscribe-Calendar?sc_lang=en');
-        const text = (await resp.text()).replace(/\r\n/g, '\n').replace(/\n\n/g, '\n'); // handle line folding
-        return text.split('\nEND:VEVENT\nBEGIN:VEVENT\n').reduce((pre, blk) => {
-            const ev = new Map(blk.split('\n').map(line => line.split(':', 2)));
-            if (!['香港市場休市', 'Hong Kong Market is closed'].includes(ev.get('DESCRIPTION') || ''))
-                return pre;
-            const start = parseUTCDate(ev.get('DTSTART;VALUE=DATE') || '');
-            let end = parseUTCDate(ev.get('DTEND;VALUE=DATE') || '');
-            if (start === end) {
-                end += A_DAY_S;
-            }
-            const lastOne = pre[pre.length - 1];
-            if (lastOne && start === lastOne.end) {
-                lastOne.end = end;
-            }
-            else {
-                pre.push({ market: 'HK', title: simpleTitle(ev.get('SUMMARY')), start, end });
-            }
-            return pre;
-        }, []);
+    static async init(isDebug = false) {
+        return WebRequest.init(isDebug);
+    }
+    async loadFxHistory() {
+        return __load(BaiduLoader, ins => ins.loadFxHistory());
+    }
+    async loadFx() {
+        return __load(BaiduLoader, ins => ins.loadFx());
+    }
+    async loadPrices(market) {
+        switch (market) {
+            case EnMarket.SGX:
+                return new SGXLoader().loadPrices();
+            case EnMarket.HKEX:
+                return __load(HKEXLoader, ins => ins.loadPrices());
+            case EnMarket.USA:
+                return __load(BaiduLoader, ins => ins.loadPrices());
+            default:
+        }
+        throw new Error(`Market ${market} not supported`);
     }
     async loadHolidays() {
-        const yyyy = new Date().getUTCFullYear();
         const [holidaysSG, holidaysHK, holidaysUS] = await Promise.all([
-            this.loadHolidaysSG(yyyy),
-            this.loadHolidaysHK(),
-            generateUSHolidays(yyyy)
+            new SGXLoader().loadHolidays().catch(() => []),
+            __load(HKEXLoader, ins => ins.loadHolidays()),
+            generateUSHolidays()
         ]);
         return holidaysSG.concat(holidaysHK).concat(holidaysUS);
     }
+    async loadHistory(fullNc) {
+        const { nc, market } = splitFullNc(fullNc);
+        switch (market) {
+            case EnMarket.SGX:
+                return new SGXLoader().loadHistory(nc);
+            case EnMarket.HKEX:
+                return __load(HKEXLoader, ins => ins.loadHistory(nc));
+            case EnMarket.USA:
+                return __load(EastmoneyLoader, ins => ins.loadHistory(nc));
+            default:
+        }
+        throw new Error(`Market ${market} not supported`);
+    }
+    _splitByMarket(ncs) {
+        const foo = {
+            [EnMarket.SGX]: [],
+            [EnMarket.HKEX]: [],
+            [EnMarket.USA]: [],
+        };
+        for (const fullNc of ncs) {
+            const { nc, market } = splitFullNc(fullNc);
+            if (!market)
+                continue;
+            foo[market].push(nc);
+        }
+        return foo;
+    }
+    async loadDividends(ncs) {
+        const { [EnMarket.SGX]: SG, [EnMarket.HKEX]: HK, [EnMarket.USA]: US } = this._splitByMarket(ncs);
+        let sgDivs = Promise.resolve([]);
+        let hkDivs = Promise.resolve([]);
+        let usDivs = Promise.resolve([]);
+        if (SG.length) {
+            const sgxLoader = new SGXLoader();
+            sgDivs = Promise.all(SG.map(async (nc) => sgxLoader.loadDividend(nc)));
+        }
+        if (HK.length) {
+            hkDivs = __load(HKEXLoader, ins => Promise.all(HK.map(nc => ins.loadDividend(nc))));
+        }
+        if (US.length) {
+            usDivs = __load(EastmoneyLoader, ins => Promise.all(US.map(nc => ins.loadDividend(nc))));
+        }
+        const divs = (await Promise.all([sgDivs, hkDivs, usDivs])).flat();
+        const ign = [];
+        let points = [];
+        const divPool = {};
+        for (const { fullNc, nc, dps, bps } of divs) {
+            if (!dps.length && !bps.length) {
+                ign.push(fullNc);
+            }
+            else {
+                points = points.concat(dps, bps);
+            }
+            divPool[nc] = ttm('ex', dps);
+        }
+        return { ign, points, divPool };
+    }
 }

package/log.js

@@ -24,7 +24,11 @@ export class Log {
     log(lev, msg) {
         if (lev > this.level)
             return Promise.resolve();
-        return appendFile(`${this._logDir}/${EnLogLevel[lev].toLowerCase()}.log`, `[${new Date().toISOString()}] ${msg}\n`);
+        const out = EnLogLevel[lev].toLowerCase();
+        msg = `[${new Date().toISOString()}] ${msg}\n`;
+        if (this.level & EnLogLevel.DEBUG)
+            console[out](msg);
+        return appendFile(`${this._logDir}/${out}.log`, msg);
     }
     debug(msg) {
         return this.log(EnLogLevel.DEBUG, msg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@watsonserve/stock-base",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "",
   "type": "module",
   "main": "index.js",
@@ -9,7 +9,7 @@
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "playwright": "^1.58.2"
+    "playwright": "^1.65.0"
   },
   "publishConfig": {
     "access": "public"