@watsonserve/stock-base 0.1.5 → 0.1.7

package/sgx.js

@@ -0,0 +1,111 @@
+import { A_DAY_S } from './close-time.js';
+import { formatFullNc, parseUTCDate, ttm } from './helper.js';
+import { EnMarket } from './stock.js';
+export class SGXLoader {
+    async __fetch(url, params) {
+        const uri = new URL(url);
+        const urlParams = Object.fromEntries(uri.searchParams);
+        uri.search = new URLSearchParams(Object.assign(urlParams, params)).toString();
+        const resp = await fetch(uri.toString(), {
+            method: 'GET',
+            credentials: 'include'
+        });
+        if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+        const ct = resp.headers.get('Content-Type')?.split(';')[0] || '';
+        if ('application/json' === ct)
+            return resp.json();
+        if (ct.startsWith('text/'))
+            return resp.text();
+        return resp.arrayBuffer();
+    }
+    async __laodIbmCode(nc) {
+        const resp = await this.__fetch(`https://api.sgx.com/marketmetadata/v2`, { 'stock-code': nc });
+        return resp.data?.[0]?.ibmCode || '';
+    }
+    async loadDividend(nc) {
+        const ibmcode = await this.__laodIbmCode(nc);
+        const params = {
+            pagesize: 15,
+            pagestart: 0,
+            ibmcode,
+            params: 'id,anncType,dateAnnc,exDate,name,particulars,recDate,datePaid',
+            order: 'desc',
+            orderBy: 'dateAnnc'
+        };
+        const { data } = await this.__fetch('https://api.sgx.com/corporateactions/v1.0', params);
+        const bonus = [];
+        const dividend = [];
+        for (const item of data) {
+            const { anncType, particulars, dateAnnc, exDate, recDate, datePaid } = item;
+            const annc = new Date(dateAnnc);
+            const ex = new Date(exDate);
+            const rec = new Date(recDate); // 登记日
+            const paid = new Date(datePaid);
+            if ('DIVIDEND' === anncType) {
+                const amount = +particulars.match(/SGD (\d+\.\d+)/)?.[1] || 0;
+                const lstIdx = dividend.length - 1;
+                if (dividend[lstIdx]?.ex.getTime() === ex.getTime() && amount) {
+                    dividend[lstIdx].amount += amount;
+                }
+                else {
+                    dividend.push({ currency: 'SGD', amount, annc, ex, rec, paid });
+                }
+                continue;
+            }
+            if ('BONUS' === anncType) { // particulars: 'Ratio: 10:1'
+                const ratio = particulars.match(/Ratio: (\d+:\d+)/);
+                const [foo, bar] = ratio[1].split(':');
+                bonus.push({ currency: 'SGD', ratio: 1 + (+bar) / (+foo), annc, ex, rec, paid });
+                continue;
+            }
+        }
+        return formatFullNc(nc, 'SG', ttm('ex', dividend), bonus);
+    }
+    async loadHistory(nc, int = '5y') {
+        const rsp = await this.__fetch(`https://api.sgx.com/securities/v1.1/charts/historic/stocks/code/${nc}/5y`, { params: 'trading_time,vl,lt' });
+        const { historic } = rsp.data;
+        return historic.map(st => {
+            const { trading_time, vl: v, lt: c } = st;
+            const fullYear = trading_time.substring(0, 4);
+            const month = trading_time.substring(4, 6);
+            const date = trading_time.substring(6, 8);
+            const timestamp = ~~(new Date(`${fullYear}-${month}-${date}T09:16:00Z`).getTime() / 1000);
+            return { market: EnMarket.SGX, timestamp, st: { nc, n: '', o: 0, c, h: 0, l: 0, v } };
+        });
+    }
+    // 新加坡交易所全量股票
+    async loadPrices() {
+        try {
+            const body = await this.__fetch('https://api.sgx.com/securities/v1.1/stocks', { params: 'nc,lt,ptd,n,o,h,l,vl,trading_time' });
+            const stockList = body.data.prices;
+            return stockList.map(({ trading_time: t, nc, lt: c, n, o, h, l, vl: v }) => ({ t, nc, n, o, c, h, l, v }));
+        }
+        catch (err) {
+            throw new Error(`failed to load sgx ${err.message}`);
+        }
+    }
+    async loadHolidays(year = 0) {
+        if (!year) {
+            year = new Date().getUTCFullYear();
+        }
+        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;
+        }, []);
+    }
+}

package/types/baidu.d.ts

@@ -0,0 +1,20 @@
+import { IFx, IStock } from './stock.js';
+import WebRequest from './web-request.js';
+export interface IFXs {
+    result: IFx[];
+    remain: IFx[];
+}
+export declare class BaiduLoader extends WebRequest {
+    private static __instance;
+    private __fetch;
+    private __loadFx;
+    private __sp500;
+    private static factory;
+    static getInstance(): Promise<BaiduLoader>;
+    private constructor();
+    protected _mount(): Promise<void>;
+    destroy(): Promise<void>;
+    loadFxHistory(): Promise<IFXs>;
+    loadFx(): Promise<IFx>;
+    loadPrices(): Promise<IStock[]>;
+}

package/types/eastmoney.d.ts

@@ -0,0 +1,14 @@
+import { IStockPoint, IDivBonInfo } from './stock.js';
+import WebRequest from './web-request.js';
+export declare class EastmoneyLoader extends WebRequest {
+    private static __instance;
+    private static factory;
+    static getInstance(): Promise<EastmoneyLoader>;
+    destroy(): Promise<void>;
+    private constructor();
+    loadDividend(nc: string): Promise<IDivBonInfo>;
+    /**
+     * @warning This method requires the Eastmoney page to be loaded and may not work if the page structure changes.
+     */
+    loadHistory(nc: string): Promise<IStockPoint[]>;
+}

package/types/helper.d.ts

@@ -1,4 +1,4 @@
-import { EnMarket } from './stock.js';
+import { EnMarket, IDiv, IDivBonInfo, IDividend } from './stock.js';
 export declare function sleep(t?: number): Promise<unknown>;
 export declare function splitFullNc(fullNc: string): {
     nc: string;
@@ -6,3 +6,6 @@ export declare function splitFullNc(fullNc: string): {
 };
 export declare function groupBy<T extends Record<string, any>>(key: string, list: T[], delKey?: boolean): Record<string, T[]>;
 export declare function ttm<T>(by: string, list: any[]): T[];
+export declare function toDivPoint(fullNc: string, div: IDividend): IDiv;
+export declare function parseUTCDate(str: string): number;
+export declare function formatFullNc(nc: string, market: 'SG' | 'HK' | 'US', div: IDividend[], bonus: IDividend[]): IDivBonInfo;

package/types/hkex.d.ts

@@ -0,0 +1,47 @@
+import WebRequest from './web-request.js';
+import { EnMarket, IDivBonInfo, IHoliday, IStock } from './stock.js';
+export declare enum EnInt {
+    day_1 = 0,
+    mo_1 = 2,
+    mo_3 = 3,
+    mo_6 = 4,
+    yr_1 = 5,
+    yrs_2 = 6,
+    yrs_5 = 7,
+    yrs_10 = 8,
+    ytd = 9
+}
+export declare enum EnSpan {
+    min = 0,
+    day = 6,
+    week = 7,
+    month = 8,
+    quarter = 9
+}
+export declare class HKEXLoader extends WebRequest {
+    private static HKEX_TOKEN;
+    private static tokenPromise;
+    private static __instance;
+    private __fetchHkexToken;
+    private __loadHkexToken;
+    private static factory;
+    static getInstance(): Promise<HKEXLoader>;
+    private constructor();
+    destroy(): Promise<void>;
+    loadDividend(nc: string): Promise<IDivBonInfo>;
+    loadPrices(): Promise<IStock[]>;
+    loadHolidays(): Promise<IHoliday[]>;
+    loadHistory(nc: string, int?: EnInt): Promise<{
+        market: EnMarket;
+        timestamp: number;
+        st: {
+            nc: string;
+            n: string;
+            o: number;
+            h: number;
+            l: number;
+            c: number;
+            v: number;
+        };
+    }[]>;
+}

package/types/index.d.ts

@@ -1,11 +1,21 @@
-import { DividendLoader } from './dividend-loader.js';
-import { IHoliday } from './stock.js';
+import { IFXs } from './baidu.js';
+import { EnMarket, IDiv, IFx, IHoliday, IStock, IStockPoint } from './stock.js';
 export * from './close-time.js';
 export * from './stock.js';
 export * from './log.js';
 export * from './helper.js';
-export declare class StockLoader extends DividendLoader {
-    loadHolidaysSG(year: number): Promise<IHoliday[]>;
-    loadHolidaysHK(): Promise<IHoliday[]>;
+export declare class StockLoader {
+    get isDebug(): boolean;
+    static init(isDebug?: boolean): Promise<void>;
+    loadFxHistory(): Promise<IFXs>;
+    loadFx(): Promise<IFx>;
+    loadPrices(market: EnMarket): Promise<IStock[]>;
     loadHolidays(): Promise<IHoliday[]>;
+    loadHistory(fullNc: string): Promise<IStockPoint[]>;
+    private _splitByMarket;
+    loadDividends(ncs: string[]): Promise<{
+        ign: string[];
+        points: IDiv[];
+        divPool: Record<string, IDiv[]>;
+    }>;
 }

package/types/sgx.d.ts

@@ -0,0 +1,9 @@
+import { IHoliday, IStock, IStockPoint } from './stock.js';
+export declare class SGXLoader {
+    private __fetch;
+    private __laodIbmCode;
+    loadDividend(nc: string): Promise<import("./stock.js").IDivBonInfo>;
+    loadHistory(nc: string, int?: string): Promise<IStockPoint[]>;
+    loadPrices(): Promise<IStock[]>;
+    loadHolidays(year?: number): Promise<IHoliday[]>;
+}

package/types/stock.d.ts

@@ -52,6 +52,12 @@ export interface IDividend {
     paid: Date;
     announcement_URL?: string;
 }
+export interface IDivBonInfo {
+    fullNc: string;
+    nc: string;
+    dps: IDiv[];
+    bps: IDiv[];
+}
 export interface IDiv {
     nc: string;
     annc: number;

package/types/{us-holiday.d.ts → usa-holiday.d.ts}

@@ -1,6 +1,7 @@
+import { IHoliday } from './stock.js';
 /**
  * 生成美股休市 & 提前收盘日历（ICS格式）
  * @param year 年份 如 2025
  * @returns ics 文本，可直接保存为 .ics 文件
  */
-export declare function generateUSHolidays(year: number): any[];
+export declare function generateUSHolidays(year?: number): IHoliday[];

package/types/web-request.d.ts

@@ -1,22 +1,21 @@
 import { type Page } from 'playwright';
 export default class WebRequest {
-    private static HKEX_TOKEN;
     private static browser?;
     private static context?;
-    private static pageCnt;
+    private static __idles;
     private static __promise?;
-    protected static isDebug: boolean;
+    private static __isDebug;
     protected page?: Page;
     private static __getInstance;
-    get isDebug(): boolean;
+    static get isDebug(): boolean;
     static init(isDebug?: boolean): Promise<void>;
     constructor();
-    mount(): Promise<void>;
+    protected _mount(addr?: string): Promise<void>;
     private static destroy;
     destroy(): Promise<void>;
+    protected fetch(url: string): Promise<any>;
+    protected fetch(url: string, params?: Record<string, any>, headers?: Record<string, any>): Promise<any>;
     protected fetch(url: string, method?: string, params?: Record<string, any>, headers?: Record<string, any>): Promise<any>;
-    protected get(url: string, params?: Record<string, any>, headers?: Record<string, any>): Promise<any>;
     protected goto(pageUrl: string): Promise<import("playwright").Response | null>;
     protected read<T>(key: string): Promise<T>;
-    protected _loadHkexToken(): Promise<string>;
 }

package/types/yahoo-finance-loader.d.ts

@@ -0,0 +1,17 @@
+import { type IDiv, type IFx, type IStockPoint } from './stock.js';
+export default class YahooFinanceLoader {
+    private getJson;
+    private getChart;
+    loadHistory(fullNc: string): Promise<IStockPoint[]>;
+    loadFxHistory(): Promise<{
+        result: IFx[];
+        remain: IFx[];
+    }>;
+    loadFx(): Promise<IFx>;
+    loadUSDividend(fullNc: string): Promise<{
+        fullNc: string;
+        nc: string;
+        dps: IDiv[];
+        bps: IDiv[];
+    }>;
+}

package/{us-holiday.js → usa-holiday.js}

@@ -1,11 +1,4 @@
-import { A_DAY_S } from "./close-time.js";
-// ==================== 工具函数 ====================
-function formatDate(d) {
-    const y = d.getFullYear();
-    const m = String(d.getMonth() + 1).padStart(2, '0');
-    const day = String(d.getDate()).padStart(2, '0');
-    return `${y}${m}${day}`;
-}
+import { A_DAY_S } from './close-time.js';
 // 获取第N个周X
 function getNthWeekday(y, m, n, weekday) {
     const first = new Date(y, m - 1, 1);
@@ -42,17 +35,6 @@ function getGoodFriday(y) {
     goodFriday.setDate(easter.getDate() - 2);
     return goodFriday;
 }
-function createEvent(uid, dateStr, summary, description) {
-    return `BEGIN:VEVENT
-UID:${uid}-${dateStr}@usstockmarket
-DTSTART;VALUE=DATE:${dateStr}
-DTEND;VALUE=DATE:${dateStr}
-SUMMARY:${summary}
-DESCRIPTION:${description}
-STATUS:CONFIRMED
-END:VEVENT
-`;
-}
 function toUTCs(d) {
     return ~~(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()) / 1000);
 }
@@ -61,8 +43,11 @@ function toUTCs(d) {
  * @param year 年份 如 2025
  * @returns ics 文本，可直接保存为 .ics 文件
  */
-export function generateUSHolidays(year) {
+export function generateUSHolidays(year = 0) {
     const events = [];
+    if (!year) {
+        year = new Date().getUTCFullYear();
+    }
     // 1. 元旦（周六不补，周日补周一）
     const newYear = new Date(year, 0, 1);
     if (6 !== newYear.getDay()) {

package/web-request.js

@@ -1,20 +1,18 @@
 import { chromium } from 'playwright';
-import { A_DAY_MS } from './close-time.js';
 export default class WebRequest {
-    static HKEX_TOKEN = { token: '', t: 0 };
     static browser;
     static context;
-    static pageCnt = 0;
+    static __idles = [];
     static __promise;
-    static isDebug = false;
+    static __isDebug = false;
     page;
-    static async __getInstance(debug = false) {
+    static async __getInstance() {
         if (WebRequest.context)
             return;
         // 1. 启动 Chromium，禁用 web security（解除 CORS）
         WebRequest.browser = await chromium.launch({
             executablePath: '/opt/microsoft/msedge/msedge',
-            headless: !debug,
+            headless: !WebRequest.isDebug,
             channel: 'msedge',
             args: [
                 '--disable-web-security',
@@ -24,31 +22,44 @@ export default class WebRequest {
             ]
         });
         WebRequest.context = await WebRequest.browser.newContext({});
+        const [foo, ...list] = WebRequest.context.pages();
+        list.length && list.forEach(page => page.close());
+        await foo.goto('about:blank');
+        WebRequest.__idles = [foo];
     }
-    get isDebug() {
-        return WebRequest.isDebug;
+    static get isDebug() {
+        return WebRequest.__isDebug;
     }
     static async init(isDebug = false) {
-        WebRequest.isDebug = isDebug;
+        WebRequest.__isDebug = isDebug;
         if (!WebRequest.__promise)
-            WebRequest.__promise = WebRequest.__getInstance(isDebug);
+            WebRequest.__promise = WebRequest.__getInstance();
     }
     constructor() { }
-    async mount() {
-        await WebRequest.__promise;
+    async _mount(addr = 'about:blank') {
+        if (!WebRequest.__promise)
+            WebRequest.__promise = WebRequest.__getInstance();
+        try {
+            await WebRequest.__promise;
+        }
+        catch (err) {
+            WebRequest.__promise = undefined;
+            throw err;
+        }
+        if (WebRequest.__idles.length) {
+            this.page = WebRequest.__idles.pop();
+            return;
+        }
         this.page = await WebRequest.context.newPage();
-        WebRequest.pageCnt++;
-        await this.page.goto('about:blank');
+        await this.page.goto(addr);
     }
     static async destroy() {
-        WebRequest.pageCnt--;
-        if (0 < WebRequest.pageCnt)
+        if (WebRequest.context?.pages().length)
             return;
         await WebRequest.context?.close();
         await WebRequest.browser?.close();
         WebRequest.context = undefined;
         WebRequest.browser = undefined;
-        WebRequest.pageCnt = 0;
         WebRequest.__promise = undefined;
     }
     async destroy() {
@@ -58,7 +69,12 @@ export default class WebRequest {
         this.page = undefined;
         return WebRequest.destroy();
     }
-    fetch(url, method = 'GET', params, headers) {
+    fetch(url, ...args) {
+        let method, params, headers;
+        [method, params, headers] = args;
+        if ('string' !== typeof method) {
+            [method, params, headers] = ['GET', method, params];
+        }
         method = method.toUpperCase();
         let data = '';
         if (params) {
@@ -96,25 +112,13 @@ export default class WebRequest {
             return resp.arrayBuffer();
         }, { method, url, headers, data });
     }
-    get(url, params, headers) {
-        return this.fetch(url, 'GET', params, headers);
-    }
     goto(pageUrl) {
-        return this.page.goto(pageUrl);
+        // 'load' 事件在行情页因持续的网络请求常常无法触发，导致超时
+        return this.page.goto(pageUrl, { waitUntil: 'domcontentloaded' });
     }
     read(key) {
         return this.page.evaluate(async (conf) => {
             return window[conf.key];
         }, { key });
     }
-    async _loadHkexToken() {
-        const expiry = Date.now() - A_DAY_MS;
-        if (WebRequest.HKEX_TOKEN?.t > expiry)
-            return WebRequest.HKEX_TOKEN.token;
-        const doc = await this.get('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);
-        WebRequest.HKEX_TOKEN = { token: decodedToken, t: Date.now() };
-        return decodedToken;
-    }
 }

package/yahoo-finance-loader.js

@@ -0,0 +1,154 @@
+import { getMarketCloseTime } from './close-time.js';
+import { splitFullNc, toDivPoint, ttm } from './helper.js';
+import { EnCurrency, EnMarket } from './stock.js';
+function toYahooSymbol(nc, market) {
+    switch (market) {
+        case EnMarket.USA:
+            return nc.replace(/\./g, '-');
+        case EnMarket.HKEX:
+            return `${nc.padStart(4, '0')}.HK`;
+        case EnMarket.SGX:
+            return `${nc}.SI`;
+        default:
+    }
+    throw new Error(`unsupported market ${market}`);
+}
+function getMarketFromCode(code) {
+    return {
+        US: EnMarket.USA,
+        HK: EnMarket.HKEX,
+        SG: EnMarket.SGX,
+    }[code];
+}
+export default class YahooFinanceLoader {
+    async getJson(url, params) {
+        const uri = new URL(url);
+        if (params) {
+            const sp = uri.searchParams;
+            Object.entries(params).forEach(([k, v]) => sp.append(k, v.toString()));
+            uri.search = sp.toString();
+        }
+        const resp = await fetch(uri.toString());
+        if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+        const { chart, quoteResponse } = await resp.json();
+        return { chart, quote: quoteResponse?.result };
+    }
+    async getChart(symbol, params) {
+        const resp = await this.getJson(`https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(symbol)}`, params);
+        const { result, error } = resp.chart || {};
+        if (error?.description)
+            throw new Error(error.description);
+        const data = result?.[0];
+        if (!data)
+            throw new Error(`empty chart data for ${symbol}`);
+        return data;
+    }
+    async loadHistory(fullNc) {
+        const { nc, market } = splitFullNc(fullNc);
+        if (!market)
+            throw new Error(`unsupported market in ${fullNc}`);
+        const symbol = toYahooSymbol(nc, market);
+        const chart = await this.getChart(symbol, { range: 'max', interval: '1d', events: 'history' });
+        const timestamps = chart.timestamp || [];
+        const quote = chart.indicators?.quote?.[0];
+        if (!quote)
+            return [];
+        return timestamps.reduce((pre, ts, idx) => {
+            const c = quote.close?.[idx];
+            if ('number' !== typeof c)
+                return pre;
+            pre.push({
+                market,
+                timestamp: getMarketCloseTime(market, ts * 1000),
+                st: {
+                    nc,
+                    n: '',
+                    o: quote.open?.[idx] || 0,
+                    c,
+                    h: quote.high?.[idx] || c,
+                    l: quote.low?.[idx] || c,
+                    v: quote.volume?.[idx] || 0,
+                },
+            });
+            return pre;
+        }, []);
+    }
+    async loadFxHistory() {
+        const symbols = [
+            { symbol: 'USDHKD=X', currency: EnCurrency.HKD },
+            { symbol: 'USDSGD=X', currency: EnCurrency.SGD },
+            { symbol: 'USDCNY=X', currency: EnCurrency.CNY },
+        ];
+        const historyList = await Promise.all(symbols.map(async ({ symbol, currency }) => {
+            const chart = await this.getChart(symbol, { range: 'max', interval: '1d', events: 'history' });
+            const timestamps = chart.timestamp || [];
+            const quote = chart.indicators?.quote?.[0];
+            const close = quote?.close || [];
+            return { currency, lines: timestamps.map((ts, idx) => ({ ts, c: close[idx] })) };
+        }));
+        const base = new Map();
+        historyList.forEach(({ currency, lines }) => {
+            lines.forEach(({ ts, c }) => {
+                if ('number' !== typeof c)
+                    return;
+                const stamp = getMarketCloseTime(EnMarket.FX, ts * 1000);
+                const fx = base.get(stamp) || {};
+                fx[currency] = c;
+                base.set(stamp, fx);
+            });
+        });
+        const result = [];
+        const remain = [];
+        [...base.entries()].forEach(([stamp, fx]) => {
+            const data = { stamp, ...fx };
+            if (!fx.HKD || !fx.SGD || !fx.CNY) {
+                remain.push(data);
+            }
+            else {
+                result.push(data);
+            }
+        });
+        return { result, remain };
+    }
+    async loadFx() {
+        const { quote: rows = [] } = await this.getJson('https://query1.finance.yahoo.com/v7/finance/quote', { symbols: 'USDHKD=X,USDSGD=X,USDCNY=X' });
+        const values = rows.reduce((pre, item) => {
+            const { symbol: sym = '', regularMarketPrice } = item;
+            if (regularMarketPrice)
+                pre[sym.slice(3, 6)] = regularMarketPrice;
+            return pre;
+        }, {});
+        return {
+            stamp: getMarketCloseTime(EnMarket.FX),
+            HKD: values.HKD || 0,
+            SGD: values.SGD || 0,
+            CNY: values.CNY || 0,
+        };
+    }
+    async loadUSDividend(fullNc) {
+        const marketCode = fullNc.substring(fullNc.length - 2);
+        if ('US' !== marketCode)
+            throw new Error(`unsupported market in ${fullNc}`);
+        const nc = fullNc.substring(0, fullNc.length - 3);
+        const market = getMarketFromCode(marketCode);
+        const symbol = toYahooSymbol(nc, market);
+        const chart = await this.getChart(symbol, { range: 'max', interval: '1d', events: 'div' });
+        const dividendMap = chart.events?.dividends || {};
+        const dividends = Object.values(dividendMap)
+            .sort((a, b) => (b.date || 0) - (a.date || 0))
+            .map(item => {
+            const ts = (item.date || 0) * 1000;
+            const date = new Date(ts);
+            return {
+                currency: EnCurrency.USD,
+                amount: item.amount || 0,
+                annc: date,
+                ex: date,
+                paid: date,
+            };
+        });
+        const dps = ttm('ex', dividends).map(item => toDivPoint(fullNc, item));
+        return { fullNc, nc, dps, bps: [] };
+    }
+}