borsajs 0.1.0

package/src/providers/dovizcom.ts

@@ -0,0 +1,98 @@
+/**
+ * doviz.com provider for forex and commodity data.
+ */
+import { BaseProvider, ProviderOptions } from './base.js';
+import { TTL } from '../cache.js';
+import { APIError, DataNotAvailableError } from '../exceptions.js';
+
+export interface FXCurrentData { symbol: string; last: number; open: number; high: number; low: number; updateTime?: Date; }
+export interface FXHistoryData { date: Date; open: number; high: number; low: number; close: number; }
+export interface HistoryOptions { period?: string; start?: Date; end?: Date; }
+interface ArchiveItem { update_date?: number; open?: number; highest?: number; lowest?: number; close?: number; }
+interface DovizApiResponse { data?: { archive?: ArchiveItem[]; }; }
+
+export class DovizcomProvider extends BaseProvider {
+    private static readonly BASE_URL = 'https://api.doviz.com/api/v12';
+    private static readonly FALLBACK_TOKEN = '3e75d7fabf1c50c8b962626dd0e5ea22d8000815e1b0920d0a26afd77fcd6609';
+    private static readonly PERIOD_DAYS: Record<string, number> = { '1d': 1, '5d': 5, '1mo': 30, '3mo': 90, '6mo': 180, '1y': 365 };
+    private static readonly SUPPORTED_ASSETS = new Set(['USD', 'EUR', 'GBP', 'JPY', 'CHF', 'CAD', 'AUD', 'gram-altin', 'gumus', 'ons', 'XAG-USD', 'XPT-USD', 'XPD-USD', 'BRENT', 'WTI', 'diesel', 'gasoline', 'lpg']);
+    private static readonly FUEL_ASSETS = new Set(['gasoline', 'diesel', 'lpg']);
+    private token: string | null = null; private tokenExpiry: number = 0;
+
+    constructor(options?: ProviderOptions) { super(options); }
+
+    private async getToken(): Promise<string> {
+        if (this.token && Date.now() < this.tokenExpiry) return this.token;
+        try {
+            const response = await this.get<string>('https://www.doviz.com/', { responseType: 'text' as const });
+            const match = response.data.match(/token["']?\s*:\s*["']([a-f0-9]{64})["']/i) || response.data.match(/Bearer\s+([a-f0-9]{64})/i);
+            if (match) { this.token = match[1]; this.tokenExpiry = Date.now() + 3600000; return this.token; }
+        } catch { /* fallback */ }
+        return DovizcomProvider.FALLBACK_TOKEN;
+    }
+
+    private getOrigin(asset: string): string { return ['gram-altin', 'gumus', 'ons'].includes(asset) ? 'https://altin.doviz.com' : 'https://www.doviz.com'; }
+
+    async getCurrent(asset: string): Promise<FXCurrentData> {
+        const normalizedAsset = DovizcomProvider.SUPPORTED_ASSETS.has(asset.toUpperCase()) ? asset.toUpperCase() : asset;
+        if (!DovizcomProvider.SUPPORTED_ASSETS.has(normalizedAsset)) throw new DataNotAvailableError(`Unsupported asset: ${asset}`);
+
+        const cacheKey = `dovizcom:current:${normalizedAsset}`;
+        const cached = this.cacheGet<FXCurrentData>(cacheKey);
+        if (cached) return cached;
+
+        try {
+            const data = DovizcomProvider.FUEL_ASSETS.has(normalizedAsset) ? await this.getFromArchive(normalizedAsset, 7) : await this.getFromDaily(normalizedAsset);
+            if (!data) throw new DataNotAvailableError(`No data for ${asset}`);
+            const result: FXCurrentData = { symbol: normalizedAsset, last: Number(data.close) || 0, open: Number(data.open) || 0, high: Number(data.highest) || 0, low: Number(data.lowest) || 0, updateTime: data.update_date ? new Date(data.update_date * 1000) : undefined };
+            this.cacheSet(cacheKey, result, TTL.FX_RATES);
+            return result;
+        } catch (error) {
+            if (error instanceof DataNotAvailableError) throw error;
+            throw new APIError(`Failed to fetch current for ${asset}: ${error}`);
+        }
+    }
+
+    async getHistory(asset: string, options: HistoryOptions = {}): Promise<FXHistoryData[]> {
+        const { period = '1mo', start, end } = options;
+        const normalizedAsset = DovizcomProvider.SUPPORTED_ASSETS.has(asset.toUpperCase()) ? asset.toUpperCase() : asset;
+        if (!DovizcomProvider.SUPPORTED_ASSETS.has(normalizedAsset)) throw new DataNotAvailableError(`Unsupported asset: ${asset}`);
+
+        const endDt = end ?? new Date();
+        const startDt = start ?? new Date(endDt.getTime() - (DovizcomProvider.PERIOD_DAYS[period] ?? 30) * 24 * 60 * 60 * 1000);
+        const cacheKey = `dovizcom:history:${normalizedAsset}:${startDt.toISOString()}:${endDt.toISOString()}`;
+        const cached = this.cacheGet<FXHistoryData[]>(cacheKey);
+        if (cached) return cached;
+
+        try {
+            const token = await this.getToken();
+            const origin = this.getOrigin(normalizedAsset);
+            const response = await this.get<DovizApiResponse>(`${DovizcomProvider.BASE_URL}/assets/${normalizedAsset}/archive`, {
+                params: { start: Math.floor(startDt.getTime() / 1000), end: Math.floor(endDt.getTime() / 1000) },
+                headers: { 'Authorization': `Bearer ${token}`, 'Origin': origin, 'Referer': `${origin}/` },
+            });
+            const records: FXHistoryData[] = (response.data?.data?.archive ?? []).map(item => ({
+                date: new Date((item.update_date ?? 0) * 1000), open: Number(item.open) || 0, high: Number(item.highest) || 0, low: Number(item.lowest) || 0, close: Number(item.close) || 0,
+            }));
+            records.sort((a, b) => a.date.getTime() - b.date.getTime());
+            this.cacheSet(cacheKey, records, TTL.OHLCV_HISTORY);
+            return records;
+        } catch (error) { if (error instanceof DataNotAvailableError) throw error; throw new APIError(`Failed to fetch history for ${asset}: ${error}`); }
+    }
+
+    private async getFromDaily(asset: string): Promise<ArchiveItem | null> {
+        const token = await this.getToken(); const origin = this.getOrigin(asset);
+        const response = await this.get<DovizApiResponse>(`${DovizcomProvider.BASE_URL}/assets/${asset}/daily`, { params: { limit: 1 }, headers: { 'Authorization': `Bearer ${token}`, 'Origin': origin, 'Referer': `${origin}/` } });
+        const archive = response.data?.data?.archive ?? []; return archive.length > 0 ? archive[0] : null;
+    }
+
+    private async getFromArchive(asset: string, days: number): Promise<ArchiveItem | null> {
+        const token = await this.getToken(); const origin = this.getOrigin(asset);
+        const endTime = Math.floor(Date.now() / 1000); const startTime = endTime - (days * 86400);
+        const response = await this.get<DovizApiResponse>(`${DovizcomProvider.BASE_URL}/assets/${asset}/archive`, { params: { start: startTime, end: endTime }, headers: { 'Authorization': `Bearer ${token}`, 'Origin': origin, 'Referer': `${origin}/` } });
+        const archive = response.data?.data?.archive ?? []; return archive.length > 0 ? archive[archive.length - 1] : null;
+    }
+}
+
+let provider: DovizcomProvider | null = null;
+export function getDovizcomProvider(): DovizcomProvider { if (!provider) provider = new DovizcomProvider(); return provider; }

package/src/providers/kap.ts

@@ -0,0 +1,98 @@
+/**
+ * KAP provider for company data and VIOP provider.
+ */
+import * as cheerio from 'cheerio';
+import { BaseProvider, ProviderOptions } from './base.js';
+import { TTL } from '../cache.js';
+import { APIError } from '../exceptions.js';
+
+export interface Company { ticker: string; name: string; city: string; }
+export interface Disclosure { id: string; date: Date; title: string; type: string; url: string; }
+
+export class KapProvider extends BaseProvider {
+    private static readonly BASE_URL = 'https://www.kap.org.tr';
+    constructor(options?: ProviderOptions) { super(options); }
+
+    async getCompanies(): Promise<Company[]> {
+        const cacheKey = 'kap:companies';
+        const cached = this.cacheGet<Company[]>(cacheKey);
+        if (cached) return cached;
+        try {
+            const response = await this.get<string>(`${KapProvider.BASE_URL}/tr/bist-sirketleri`, { responseType: 'text' as const });
+            const $ = cheerio.load(response.data);
+            const companies: Company[] = [];
+            $('table.dataTable tbody tr').each((_, row) => {
+                const cells = $(row).find('td');
+                if (cells.length >= 3) companies.push({ ticker: $(cells[0]).text().trim(), name: $(cells[1]).text().trim(), city: $(cells[2]).text().trim() });
+            });
+            this.cacheSet(cacheKey, companies, TTL.COMPANY_LIST);
+            return companies;
+        } catch (error) { throw new APIError(`Failed to fetch companies: ${error}`); }
+    }
+
+    async search(query: string): Promise<Company[]> {
+        const companies = await this.getCompanies();
+        const q = query.toLowerCase();
+        return companies.filter(c => c.ticker.toLowerCase().includes(q) || c.name.toLowerCase().includes(q));
+    }
+}
+
+export interface ContractData { code: string; contract: string; price: number; change: number; volumeTl: number; volumeQty: number; category: string; }
+
+export class ViopProvider extends BaseProvider {
+    private static readonly BASE_URL = 'https://www.isyatirim.com.tr/tr-tr/analiz/Sayfalar/viop-akis.aspx';
+    constructor(options?: ProviderOptions) { super(options); }
+
+    async getFutures(category: 'all' | 'stock' | 'index' | 'currency' | 'commodity' = 'all'): Promise<ContractData[]> {
+        const cacheKey = `viop:futures:${category}`;
+        const cached = this.cacheGet<ContractData[]>(cacheKey);
+        if (cached) return cached;
+        try {
+            const response = await this.get<string>(ViopProvider.BASE_URL, { responseType: 'text' as const });
+            const $ = cheerio.load(response.data);
+            const contracts: ContractData[] = [];
+            $('table.dataTable tbody tr').each((_, row) => {
+                const cells = $(row).find('td');
+                if (cells.length < 6) return;
+                const code = $(cells[0]).text().trim();
+                let cat = 'stock';
+                if (code.includes('XU') || code.includes('XLBNK')) cat = 'index';
+                else if (code.includes('USD') || code.includes('EUR')) cat = 'currency';
+                else if (code.includes('GAU') || code.includes('XAU')) cat = 'commodity';
+                if (category !== 'all' && cat !== category) return;
+                const parseNum = (t: string) => parseFloat(t.replace(/\./g, '').replace(',', '.').replace(/[^\d.-]/g, '')) || 0;
+                contracts.push({ code, contract: $(cells[1]).text().trim(), price: parseNum($(cells[2]).text()), change: parseNum($(cells[3]).text()), volumeTl: parseNum($(cells[4]).text()), volumeQty: parseNum($(cells[5]).text()), category: cat });
+            });
+            this.cacheSet(cacheKey, contracts, TTL.VIOP);
+            return contracts;
+        } catch (error) { throw new APIError(`Failed to fetch futures: ${error}`); }
+    }
+
+    async getOptions(category: 'all' | 'stock' | 'index' = 'all'): Promise<ContractData[]> {
+        const cacheKey = `viop:options:${category}`;
+        const cached = this.cacheGet<ContractData[]>(cacheKey);
+        if (cached) return cached;
+        try {
+            const response = await this.get<string>(ViopProvider.BASE_URL, { responseType: 'text' as const });
+            const $ = cheerio.load(response.data);
+            const contracts: ContractData[] = [];
+            $('table.optionsTable tbody tr').each((_, row) => {
+                const cells = $(row).find('td');
+                if (cells.length < 6) return;
+                const code = $(cells[0]).text().trim();
+                let cat = 'stock';
+                if (code.includes('XU') || code.includes('XLBNK')) cat = 'index';
+                if (category !== 'all' && cat !== category) return;
+                const parseNum = (t: string) => parseFloat(t.replace(/\./g, '').replace(',', '.').replace(/[^\d.-]/g, '')) || 0;
+                contracts.push({ code, contract: $(cells[1]).text().trim(), price: parseNum($(cells[2]).text()), change: parseNum($(cells[3]).text()), volumeTl: parseNum($(cells[4]).text()), volumeQty: parseNum($(cells[5]).text()), category: cat });
+            });
+            this.cacheSet(cacheKey, contracts, TTL.VIOP);
+            return contracts;
+        } catch (error) { throw new APIError(`Failed to fetch options: ${error}`); }
+    }
+}
+
+let kapProvider: KapProvider | null = null;
+export function getKapProvider(): KapProvider { if (!kapProvider) kapProvider = new KapProvider(); return kapProvider; }
+let viopProvider: ViopProvider | null = null;
+export function getViopProvider(): ViopProvider { if (!viopProvider) viopProvider = new ViopProvider(); return viopProvider; }

package/src/providers/paratic.ts

@@ -0,0 +1,95 @@
+/**
+ * Paratic provider for historical OHLCV data.
+ */
+import { BaseProvider, ProviderOptions } from './base.js';
+import { TTL } from '../cache.js';
+import { APIError, DataNotAvailableError, TickerNotFoundError } from '../exceptions.js';
+
+export interface QuoteData {
+    symbol: string; last: number; open: number; high: number; low: number; close: number;
+    volume: number; change: number; changePercent: number; updateTime: Date;
+}
+
+export interface OHLCVData { date: Date; open: number; high: number; low: number; close: number; volume: number; }
+export interface HistoryOptions { period?: string; interval?: string; start?: Date; end?: Date; }
+interface ParaticDataItem { d: number; o: number; h: number; l: number; c: number; v: number; }
+
+export class ParaticProvider extends BaseProvider {
+    private static readonly BASE_URL = 'https://piyasa.paratic.com/API/g.php';
+    private static readonly PERIOD_MAP: Record<string, number> = { '1d': 1, '5d': 5, '1mo': 30, '3mo': 90, '6mo': 180, '1y': 365, '2y': 730, '5y': 1825, '10y': 3650, 'max': 3650 };
+    private static readonly INTERVAL_MAP: Record<string, number> = { '1m': 1, '3m': 3, '5m': 5, '15m': 15, '30m': 30, '45m': 45, '1h': 60, '1d': 1440, '1wk': 10080, '1mo': 43200 };
+
+    constructor(options?: ProviderOptions) { super(options); }
+
+    private formatDate(date: Date): string {
+        const y = date.getFullYear(), m = String(date.getMonth() + 1).padStart(2, '0'), d = String(date.getDate()).padStart(2, '0');
+        const h = String(date.getHours()).padStart(2, '0'), mi = String(date.getMinutes()).padStart(2, '0'), s = String(date.getSeconds()).padStart(2, '0');
+        return `${y}${m}${d}${h}${mi}${s}`;
+    }
+
+    async getQuote(symbol: string): Promise<QuoteData> {
+        symbol = symbol.toUpperCase().replace('.IS', '').replace('.E', '');
+        const cacheKey = `paratic:quote:${symbol}`;
+        const cached = this.cacheGet<QuoteData>(cacheKey);
+        if (cached) return cached;
+
+        const params = { a: 'd', c: symbol, p: 1440, from: '', at: this.formatDate(new Date()), group: 'f' };
+        try {
+            const response = await this.get<ParaticDataItem[]>(ParaticProvider.BASE_URL, { params });
+            const data = response.data;
+            if (!data || data.length === 0) throw new TickerNotFoundError(symbol);
+
+            const latest = data[data.length - 1];
+            const prev = data.length > 1 ? data[data.length - 2] : null;
+            const prevClose = prev ? Number(prev.c) || 0 : 0;
+            const last = Number(latest.c) || 0;
+            const change = prevClose ? last - prevClose : 0;
+            const changePct = prevClose ? (change / prevClose) * 100 : 0;
+
+            const result: QuoteData = {
+                symbol, last, open: Number(latest.o) || 0, high: Number(latest.h) || 0, low: Number(latest.l) || 0,
+                close: prevClose, volume: Number(latest.v) || 0, change: Math.round(change * 100) / 100,
+                changePercent: Math.round(changePct * 100) / 100, updateTime: new Date(latest.d),
+            };
+            this.cacheSet(cacheKey, result, TTL.REALTIME_PRICE);
+            return result;
+        } catch (error) {
+            if (error instanceof TickerNotFoundError) throw error;
+            throw new APIError(`Failed to fetch quote for ${symbol}: ${error}`);
+        }
+    }
+
+    async getHistory(symbol: string, options: HistoryOptions = {}): Promise<OHLCVData[]> {
+        symbol = symbol.toUpperCase().replace('.IS', '').replace('.E', '');
+        const { period = '1mo', interval = '1d', start, end } = options;
+        const endDt = end ?? new Date();
+        const startDt = start ?? new Date(endDt.getTime() - (ParaticProvider.PERIOD_MAP[period] ?? 30) * 24 * 60 * 60 * 1000);
+
+        let cacheKey = `paratic:history:${symbol}:${period}:${interval}`;
+        if (start) cacheKey += `:${start.toISOString()}`;
+        if (end) cacheKey += `:${end.toISOString()}`;
+        const cached = this.cacheGet<OHLCVData[]>(cacheKey);
+        if (cached) return cached;
+
+        const intervalMinutes = ParaticProvider.INTERVAL_MAP[interval] ?? 1440;
+        const params = { a: 'd', c: symbol, p: intervalMinutes, from: '', at: this.formatDate(endDt), group: 'f' };
+
+        try {
+            const response = await this.get<ParaticDataItem[]>(ParaticProvider.BASE_URL, { params });
+            const data = response.data;
+            if (!data || data.length === 0) throw new DataNotAvailableError(`No data available for ${symbol}`);
+
+            const records: OHLCVData[] = data.filter(item => item.d && new Date(item.d) >= startDt && new Date(item.d) <= endDt)
+                .map(item => ({ date: new Date(item.d), open: Number(item.o) || 0, high: Number(item.h) || 0, low: Number(item.l) || 0, close: Number(item.c) || 0, volume: Number(item.v) || 0 }));
+            records.sort((a, b) => a.date.getTime() - b.date.getTime());
+            this.cacheSet(cacheKey, records, TTL.OHLCV_HISTORY);
+            return records;
+        } catch (error) {
+            if (error instanceof DataNotAvailableError) throw error;
+            throw new APIError(`Failed to fetch data for ${symbol}: ${error}`);
+        }
+    }
+}
+
+let provider: ParaticProvider | null = null;
+export function getParaticProvider(): ParaticProvider { if (!provider) provider = new ParaticProvider(); return provider; }

package/src/providers/tcmb.ts

@@ -0,0 +1,96 @@
+/**
+ * TCMB provider for Turkish inflation data.
+ */
+import * as cheerio from 'cheerio';
+import { BaseProvider, ProviderOptions } from './base.js';
+import { TTL } from '../cache.js';
+import { APIError, DataNotAvailableError } from '../exceptions.js';
+
+export interface InflationLatest { date: string; yearMonth: string; yearlyInflation: number; monthlyInflation: number; type: string; }
+export interface InflationData { date: Date; yearMonth: string; yearlyInflation: number; monthlyInflation: number; }
+export interface InflationCalculation { startDate: string; endDate: string; initialValue: number; finalValue: number; totalYears: number; totalMonths: number; totalChange: number; avgYearlyInflation: number; startCpi: number; endCpi: number; }
+export interface InflationDataOptions { start?: string; end?: string; limit?: number; }
+
+interface CalcApiResponse { yeniSepetDeger?: string; toplamYil?: number; toplamAy?: number; toplamDegisim?: string; ortalamaYillikEnflasyon?: string; ilkYilTufe?: string; sonYilTufe?: string; }
+
+export class TcmbProvider extends BaseProvider {
+    private static readonly BASE_URL = 'https://www.tcmb.gov.tr';
+    private static readonly CALC_API_URL = 'https://appg.tcmb.gov.tr/KIMENFH/enflasyon/hesapla';
+    private static readonly INFLATION_PATHS: Record<string, string> = { tufe: '/wps/wcm/connect/tr/tcmb+tr/main+menu/istatistikler/enflasyon+verileri', ufe: '/wps/wcm/connect/TR/TCMB+TR/Main+Menu/Istatistikler/Enflasyon+Verileri/Uretici+Fiyatlari' };
+
+    constructor(options?: ProviderOptions) { super(options); }
+
+    async getLatest(inflationType: string = 'tufe'): Promise<InflationLatest> {
+        const data = await this.getData(inflationType, { limit: 1 });
+        if (data.length === 0) throw new DataNotAvailableError('No inflation data available');
+        const latest = data[0];
+        return { date: latest.date.toISOString().split('T')[0], yearMonth: latest.yearMonth, yearlyInflation: latest.yearlyInflation, monthlyInflation: latest.monthlyInflation, type: inflationType.toUpperCase() };
+    }
+
+    async getData(inflationType: string, options: InflationDataOptions = {}): Promise<InflationData[]> {
+        const { start, end, limit } = options;
+        const type = inflationType.toLowerCase();
+        if (!TcmbProvider.INFLATION_PATHS[type]) throw new Error(`Invalid type: ${type}. Use 'tufe' or 'ufe'`);
+
+        const cacheKey = `tcmb:data:${type}`;
+        let cached = this.cacheGet<InflationData[]>(cacheKey);
+
+        if (!cached) {
+            try {
+                const response = await this.get<string>(TcmbProvider.BASE_URL + TcmbProvider.INFLATION_PATHS[type], { responseType: 'text' as const, headers: { 'Accept': 'text/html', 'Accept-Language': 'tr-TR,tr;q=0.9' } });
+                cached = this.parseInflationTable(response.data);
+                this.cacheSet(cacheKey, cached, TTL.FX_RATES);
+            } catch (error) { throw new APIError(`Failed to fetch inflation data: ${error}`); }
+        }
+        if (!cached?.length) throw new DataNotAvailableError(`No data available for ${type}`);
+        let result = [...cached];
+        if (start) result = result.filter(d => d.date >= new Date(start));
+        if (end) result = result.filter(d => d.date <= new Date(end));
+        if (limit && limit > 0) result = result.slice(0, limit);
+        return result;
+    }
+
+    async calculateInflation(options: { startYear: number; startMonth: number; endYear: number; endMonth: number; basketValue: number; }): Promise<InflationCalculation> {
+        const { startYear, startMonth, endYear, endMonth, basketValue } = options;
+        const cacheKey = `tcmb:calc:${startYear}-${startMonth}:${endYear}-${endMonth}:${basketValue}`;
+        const cached = this.cacheGet<InflationCalculation>(cacheKey);
+        if (cached) return cached;
+
+        try {
+            const response = await this.post<CalcApiResponse>(TcmbProvider.CALC_API_URL, { baslangicYil: String(startYear), baslangicAy: String(startMonth), bitisYil: String(endYear), bitisAy: String(endMonth), malSepeti: String(basketValue) }, { headers: { 'Accept': '*/*', 'Content-Type': 'application/json', 'Origin': 'https://herkesicin.tcmb.gov.tr', 'Referer': 'https://herkesicin.tcmb.gov.tr/' } });
+            const data = response.data;
+            const parseFloat = (v: string) => { const c = String(v || '').replace(/,/g, ''); const n = Number.parseFloat(c); return isNaN(n) ? 0 : n; };
+            const result: InflationCalculation = { startDate: `${startYear}-${String(startMonth).padStart(2, '0')}`, endDate: `${endYear}-${String(endMonth).padStart(2, '0')}`, initialValue: basketValue, finalValue: parseFloat(data?.yeniSepetDeger ?? ''), totalYears: data?.toplamYil ?? 0, totalMonths: data?.toplamAy ?? 0, totalChange: parseFloat(data?.toplamDegisim ?? ''), avgYearlyInflation: parseFloat(data?.ortalamaYillikEnflasyon ?? ''), startCpi: parseFloat(data?.ilkYilTufe ?? ''), endCpi: parseFloat(data?.sonYilTufe ?? '') };
+            this.cacheSet(cacheKey, result, TTL.INFLATION_DATA);
+            return result;
+        } catch (error) { throw new APIError(`Failed to calculate inflation: ${error}`); }
+    }
+
+    private parseInflationTable(html: string): InflationData[] {
+        const $ = cheerio.load(html);
+        const inflationData: InflationData[] = [];
+        const tables = $('table').toArray();
+        for (const table of tables) {
+            const headerText = $(table).find('tr').first().text().toLowerCase();
+            if (!headerText.includes('tüfe') && !headerText.includes('üfe') && !headerText.includes('enflasyon') && !headerText.includes('yıllık')) continue;
+            $(table).find('tr').slice(1).each((_, row) => {
+                const cells = $(row).find('td, th').map((_, c) => $(c).text().trim()).get();
+                if (cells.length < 3 || !cells[0]) return;
+                const [dateStr, yearlyStr, monthlyStr] = cells.length >= 5 ? [cells[0], cells[2], cells[4] || ''] : [cells[0], cells[1], cells[2]];
+                const match = dateStr.replace(/[.,]/g, '').match(/(\d{1,2})-(\d{4})/);
+                if (!match) return;
+                const [, month, year] = match;
+                const date = new Date(parseInt(year), parseInt(month) - 1, 1);
+                const yearly = parseFloat(yearlyStr.replace('%', '').replace(',', '.').replace(/[^\d.-]/g, ''));
+                const monthly = parseFloat(monthlyStr.replace('%', '').replace(',', '.').replace(/[^\d.-]/g, '')) || 0;
+                if (!isNaN(yearly)) inflationData.push({ date, yearMonth: dateStr, yearlyInflation: yearly, monthlyInflation: monthly });
+            });
+            if (inflationData.length > 0) break;
+        }
+        inflationData.sort((a, b) => b.date.getTime() - a.date.getTime());
+        return inflationData;
+    }
+}
+
+let provider: TcmbProvider | null = null;
+export function getTcmbProvider(): TcmbProvider { if (!provider) provider = new TcmbProvider(); return provider; }

package/src/providers/tefas.ts

@@ -0,0 +1,85 @@
+/**
+ * TEFAS provider for mutual fund data.
+ */
+import axios, { AxiosInstance } from 'axios';
+import https from 'https';
+import { BaseProvider, ProviderOptions } from './base.js';
+import { TTL } from '../cache.js';
+import { APIError, DataNotAvailableError } from '../exceptions.js';
+
+export interface FundInfo { fundCode: string; name: string; date: string; price: number; fundSize: number; investorCount: number; founder?: string; manager?: string; fundType?: string; category?: string; riskValue?: number; dailyReturn?: number; return1m?: number; return3m?: number; return6m?: number; returnYtd?: number; return1y?: number; return3y?: number; return5y?: number; }
+export interface FundHistoryData { date: Date; price: number; fundSize: number; investors: number; }
+export interface HistoryOptions { period?: string; start?: Date; end?: Date; }
+export interface SearchResult { fundCode: string; name: string; fundType?: string; return1y?: number; }
+
+interface FundApiResponse { fundInfo?: Array<{ FONUNVAN?: string; TARIH?: string; SONFIYAT?: number; PORTBUYUKLUK?: number; YATIRIMCISAYI?: number; KURUCU?: string; YONETICI?: string; FONTUR?: string; FONKATEGORI?: string; RISKDEGERI?: number; GUNLUKGETIRI?: number; }>; fundReturn?: Array<{ GETIRI1A?: number; GETIRI3A?: number; GETIRI6A?: number; GETIRIYB?: number; GETIRI1Y?: number; GETIRI3Y?: number; GETIRI5Y?: number; }>; }
+interface HistoryApiResponse { data?: Array<{ TARIH?: number; FIYAT?: number; PORTFOYBUYUKLUK?: number; KISISAYISI?: number; }>; }
+interface ComparisonApiResponse { data?: Array<{ FONKODU?: string; FONUNVAN?: string; FONTURACIKLAMA?: string; GETIRI1Y?: number; }>; }
+
+export class TefasProvider extends BaseProvider {
+    private static readonly BASE_URL = 'https://www.tefas.gov.tr/api/DB';
+    private static readonly PERIOD_DAYS: Record<string, number> = { '1d': 1, '5d': 5, '1mo': 30, '3mo': 90, '6mo': 180, '1y': 365 };
+    private unsafeClient: AxiosInstance;
+
+    constructor(options?: ProviderOptions) {
+        super(options);
+        this.unsafeClient = axios.create({ timeout: 30000, httpsAgent: new https.Agent({ rejectUnauthorized: false }), headers: { 'User-Agent': 'Mozilla/5.0' } });
+    }
+
+    private formatDate(date: Date): string { return `${String(date.getDate()).padStart(2, '0')}.${String(date.getMonth() + 1).padStart(2, '0')}.${date.getFullYear()}`; }
+
+    async getFundDetail(fundCode: string): Promise<FundInfo> {
+        fundCode = fundCode.toUpperCase();
+        const cacheKey = `tefas:detail:${fundCode}`;
+        const cached = this.cacheGet<FundInfo>(cacheKey);
+        if (cached) return cached;
+
+        try {
+            const response = await this.unsafeClient.post<FundApiResponse>(`${TefasProvider.BASE_URL}/GetAllFundAnalyzeData`, new URLSearchParams({ dil: 'TR', fonkod: fundCode }).toString(), { headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8' } });
+            const data = response.data;
+            if (!data?.fundInfo?.length) throw new DataNotAvailableError(`No data for fund: ${fundCode}`);
+            const fi = data.fundInfo[0]; const fr = data.fundReturn?.[0] ?? {};
+            const result: FundInfo = { fundCode, name: fi.FONUNVAN ?? '', date: fi.TARIH ?? '', price: Number(fi.SONFIYAT) || 0, fundSize: Number(fi.PORTBUYUKLUK) || 0, investorCount: Number(fi.YATIRIMCISAYI) || 0, founder: fi.KURUCU, manager: fi.YONETICI, fundType: fi.FONTUR, category: fi.FONKATEGORI, riskValue: fi.RISKDEGERI, dailyReturn: fi.GUNLUKGETIRI, return1m: fr.GETIRI1A, return3m: fr.GETIRI3A, return6m: fr.GETIRI6A, returnYtd: fr.GETIRIYB, return1y: fr.GETIRI1Y, return3y: fr.GETIRI3Y, return5y: fr.GETIRI5Y };
+            this.cacheSet(cacheKey, result, TTL.FUND_DATA);
+            return result;
+        } catch (error) { if (error instanceof DataNotAvailableError) throw error; throw new APIError(`Failed to fetch fund detail for ${fundCode}: ${error}`); }
+    }
+
+    async getHistory(fundCode: string, options: HistoryOptions = {}): Promise<FundHistoryData[]> {
+        fundCode = fundCode.toUpperCase();
+        const { period = '1mo', start, end } = options;
+        const endDt = end ?? new Date();
+        const startDt = start ?? new Date(endDt.getTime() - (TefasProvider.PERIOD_DAYS[period] ?? 30) * 24 * 60 * 60 * 1000);
+        const cacheKey = `tefas:history:${fundCode}:${startDt.toISOString()}:${endDt.toISOString()}`;
+        const cached = this.cacheGet<FundHistoryData[]>(cacheKey);
+        if (cached) return cached;
+
+        try {
+            const formData = new URLSearchParams({ fontip: 'YAT', sfontur: '', fonkod: fundCode, fongrup: '', bastarih: this.formatDate(startDt), bittarih: this.formatDate(endDt), fonturkod: '', fonunvantip: '', kurucukod: '' });
+            const response = await this.unsafeClient.post<HistoryApiResponse>(`${TefasProvider.BASE_URL}/BindHistoryInfo`, formData.toString(), { headers: { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'Origin': 'https://www.tefas.gov.tr', 'X-Requested-With': 'XMLHttpRequest' } });
+            const data = response.data?.data;
+            if (!data?.length) throw new DataNotAvailableError(`No history for fund: ${fundCode}`);
+            const records: FundHistoryData[] = data.filter(i => i.TARIH && i.TARIH > 0).map(i => ({ date: new Date(i.TARIH!), price: Number(i.FIYAT) || 0, fundSize: Number(i.PORTFOYBUYUKLUK) || 0, investors: Number(i.KISISAYISI) || 0 }));
+            records.sort((a, b) => a.date.getTime() - b.date.getTime());
+            this.cacheSet(cacheKey, records, TTL.FUND_DATA);
+            return records;
+        } catch (error) { if (error instanceof DataNotAvailableError) throw error; throw new APIError(`Failed to fetch history for ${fundCode}: ${error}`); }
+    }
+
+    async search(query: string, limit: number = 20): Promise<SearchResult[]> {
+        const cacheKey = `tefas:search:${query}:${limit}`;
+        const cached = this.cacheGet<SearchResult[]>(cacheKey);
+        if (cached) return cached;
+        try {
+            const formData = new URLSearchParams({ calismatipi: '2', fontip: 'YAT', sfontur: 'Tümü', kurucukod: '', fongrup: '', bastarih: 'Başlangıç', bittarih: 'Bitiş', fonturkod: '', fonunvantip: '', strperiod: '1,1,1,1,1,1,1', islemdurum: '1' });
+            const response = await this.unsafeClient.post<ComparisonApiResponse>(`${TefasProvider.BASE_URL}/BindComparisonFundReturns`, formData.toString(), { headers: { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'X-Requested-With': 'XMLHttpRequest' } });
+            const allFunds = response.data?.data ?? []; const queryLower = query.toLowerCase();
+            const matching: SearchResult[] = allFunds.filter(f => (f.FONKODU ?? '').toLowerCase().includes(queryLower) || (f.FONUNVAN ?? '').toLowerCase().includes(queryLower)).slice(0, limit).map(f => ({ fundCode: f.FONKODU ?? '', name: f.FONUNVAN ?? '', fundType: f.FONTURACIKLAMA, return1y: f.GETIRI1Y }));
+            this.cacheSet(cacheKey, matching, TTL.FUND_DATA);
+            return matching;
+        } catch { return []; }
+    }
+}
+
+let provider: TefasProvider | null = null;
+export function getTefasProvider(): TefasProvider { if (!provider) provider = new TefasProvider(); return provider; }

package/src/ticker.ts

@@ -0,0 +1,30 @@
+/**
+ * Ticker class for stock data.
+ */
+import { getParaticProvider, QuoteData, OHLCVData, HistoryOptions } from './providers/paratic.js';
+
+export interface TickerInfo extends QuoteData { type: 'stock'; }
+
+export class Ticker {
+    private readonly _symbol: string;
+    private _infoCache: TickerInfo | null = null;
+
+    constructor(symbol: string) { this._symbol = symbol.toUpperCase().replace('.IS', '').replace('.E', ''); }
+    get symbol(): string { return this._symbol; }
+
+    async getInfo(): Promise<TickerInfo> {
+        if (!this._infoCache) {
+            const quote = await getParaticProvider().getQuote(this._symbol);
+            this._infoCache = { ...quote, type: 'stock' };
+        }
+        return this._infoCache;
+    }
+
+    async getFastInfo(): Promise<TickerInfo> { return this.getInfo(); }
+
+    async getHistory(options: HistoryOptions = {}): Promise<OHLCVData[]> {
+        return getParaticProvider().getHistory(this._symbol, options);
+    }
+
+    toString(): string { return `Ticker('${this._symbol}')`; }
+}

package/src/viop.ts

@@ -0,0 +1,35 @@
+/**
+ * VIOP class for Turkish derivatives market data.
+ */
+import { getViopProvider, ContractData } from './providers/kap.js';
+
+export class VIOP {
+    private _futuresCache: ContractData[] | null = null;
+    private _optionsCache: ContractData[] | null = null;
+
+    async getFutures(): Promise<ContractData[]> {
+        if (!this._futuresCache) this._futuresCache = await getViopProvider().getFutures('all');
+        return this._futuresCache;
+    }
+
+    async getStockFutures(): Promise<ContractData[]> { return getViopProvider().getFutures('stock'); }
+    async getIndexFutures(): Promise<ContractData[]> { return getViopProvider().getFutures('index'); }
+    async getCurrencyFutures(): Promise<ContractData[]> { return getViopProvider().getFutures('currency'); }
+    async getCommodityFutures(): Promise<ContractData[]> { return getViopProvider().getFutures('commodity'); }
+
+    async getOptions(): Promise<ContractData[]> {
+        if (!this._optionsCache) this._optionsCache = await getViopProvider().getOptions('all');
+        return this._optionsCache;
+    }
+
+    async getStockOptions(): Promise<ContractData[]> { return getViopProvider().getOptions('stock'); }
+    async getIndexOptions(): Promise<ContractData[]> { return getViopProvider().getOptions('index'); }
+
+    async getBySymbol(symbol: string): Promise<ContractData[]> {
+        symbol = symbol.toUpperCase();
+        const [futures, options] = await Promise.all([this.getFutures(), this.getOptions()]);
+        return [...futures, ...options].filter(i => i.contract.toUpperCase().includes(symbol) || i.code.toUpperCase().includes(symbol));
+    }
+
+    toString(): string { return 'VIOP()'; }
+}

package/test/demo.ts

@@ -0,0 +1,99 @@
+/**
+ * Test script for borsajs APIs
+ * Run with: npx tsx test/demo.ts
+ */
+import { Crypto, cryptoPairs } from '../src/crypto.js';
+import { FX } from '../src/fx.js';
+import { Ticker } from '../src/ticker.js';
+import { Index, indices } from '../src/index-class.js';
+import { Fund, searchFunds } from '../src/fund.js';
+import { Inflation } from '../src/inflation.js';
+
+async function testCrypto() {
+    console.log('\n🪙 Testing Crypto (BtcTurk)...');
+    console.log('─'.repeat(50));
+    try {
+        const btc = new Crypto('BTCTRY');
+        const current = await btc.getCurrent();
+        console.log('BTC/TRY Current:', JSON.stringify(current, null, 2));
+        const pairs = await cryptoPairs('TRY');
+        console.log(`\nAvailable TRY pairs: ${pairs.slice(0, 10).join(', ')}...`);
+    } catch (error) { console.error('Crypto Error:', error); }
+}
+
+async function testFX() {
+    console.log('\n💱 Testing FX (doviz.com)...');
+    console.log('─'.repeat(50));
+    try {
+        const usd = new FX('USD');
+        const current = await usd.getCurrent();
+        console.log('USD/TRY Current:', JSON.stringify(current, null, 2));
+        const gold = new FX('gram-altin');
+        const goldCurrent = await gold.getCurrent();
+        console.log('\nGold (gram) Current:', JSON.stringify(goldCurrent, null, 2));
+    } catch (error) { console.error('FX Error:', error); }
+}
+
+async function testTicker() {
+    console.log('\n📈 Testing Ticker (Paratic)...');
+    console.log('─'.repeat(50));
+    try {
+        const stock = new Ticker('THYAO');
+        const info = await stock.getInfo();
+        console.log('THYAO Info:', JSON.stringify(info, null, 2));
+    } catch (error) { console.error('Ticker Error:', error); }
+}
+
+async function testIndex() {
+    console.log('\n📊 Testing Index (Paratic)...');
+    console.log('─'.repeat(50));
+    try {
+        console.log('Available indices:', indices().slice(0, 10).join(', '));
+        const xu100 = new Index('XU100');
+        const info = await xu100.getInfo();
+        console.log('\nXU100 Info:', JSON.stringify(info, null, 2));
+    } catch (error) { console.error('Index Error:', error); }
+}
+
+async function testFund() {
+    console.log('\n🏦 Testing Fund (TEFAS)...');
+    console.log('─'.repeat(50));
+    try {
+        const results = await searchFunds('ak', 5);
+        console.log('Search "ak":', JSON.stringify(results, null, 2));
+        if (results.length > 0) {
+            const fund = new Fund(results[0].fundCode);
+            const info = await fund.getInfo();
+            console.log(`\n${results[0].fundCode} Info:`, JSON.stringify(info, null, 2));
+        }
+    } catch (error) { console.error('Fund Error:', error); }
+}
+
+async function testInflation() {
+    console.log('\n📉 Testing Inflation (TCMB)...');
+    console.log('─'.repeat(50));
+    try {
+        const inflation = new Inflation();
+        const latest = await inflation.getLatest();
+        console.log('Latest CPI:', JSON.stringify(latest, null, 2));
+        const cpi = await inflation.getTufe({ limit: 3 });
+        console.log('\nCPI last 3 months:', JSON.stringify(cpi, null, 2));
+        const calculation = await inflation.calculate(100000, '2020-01', '2024-01');
+        console.log('\n100,000 TL (2020-01 → 2024-01):', JSON.stringify(calculation, null, 2));
+    } catch (error) { console.error('Inflation Error:', error); }
+}
+
+async function main() {
+    console.log('🚀 borsajs API Test');
+    console.log('═'.repeat(50));
+    await testCrypto();
+    await testFX();
+    await testTicker();
+    await testIndex();
+    await testFund();
+    await testInflation();
+    console.log('\n' + '═'.repeat(50));
+    console.log('✅ All tests completed!');
+}
+
+main().catch(console.error);