@fin.cx/opendata 1.5.3 → 1.6.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@fin.cx/opendata',
-    version: '1.5.3',
-    description: 'A comprehensive TypeScript library that manages open business data for German companies by integrating MongoDB, processing JSONL bulk data, and automating browser interactions for Handelsregister data retrieval.'
+    version: '1.6.0',
+    description: 'A comprehensive TypeScript library for accessing business data and real-time financial information. Features include German company data management with MongoDB integration, JSONL bulk processing, automated Handelsregister interactions, and real-time stock market data from multiple providers.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFOQUFxTjtDQUNuTyxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHVTQUF1UztDQUNyVCxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -1 +1,2 @@
 export * from './classes.main.opendata.js';
+export * from './stocks/index.js';

package/dist_ts/index.js

@@ -1,2 +1,3 @@
 export * from './classes.main.opendata.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDIn0=
+export * from './stocks/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsbUJBQW1CLENBQUMifQ==

package/dist_ts/plugins.d.ts

@@ -8,12 +8,13 @@ import * as smartbrowser from '@push.rocks/smartbrowser';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfile from '@push.rocks/smartfile';
+import * as smartlog from '@push.rocks/smartlog';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartstream from '@push.rocks/smartstream';
 import * as smartunique from '@push.rocks/smartunique';
 import * as smartxml from '@push.rocks/smartxml';
-export { lik, qenv, smartarchive, smartarray, smartbrowser, smartdata, smartdelay, smartfile, smartpath, smartpromise, smartrequest, smartstream, smartunique, smartxml, };
+export { lik, qenv, smartarchive, smartarray, smartbrowser, smartdata, smartdelay, smartfile, smartlog, smartpath, smartpromise, smartrequest, smartstream, smartunique, smartxml, };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass, };

package/dist_ts/plugins.js

@@ -10,14 +10,15 @@ import * as smartbrowser from '@push.rocks/smartbrowser';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfile from '@push.rocks/smartfile';
+import * as smartlog from '@push.rocks/smartlog';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartstream from '@push.rocks/smartstream';
 import * as smartunique from '@push.rocks/smartunique';
 import * as smartxml from '@push.rocks/smartxml';
-export { lik, qenv, smartarchive, smartarray, smartbrowser, smartdata, smartdelay, smartfile, smartpath, smartpromise, smartrequest, smartstream, smartunique, smartxml, };
+export { lik, qenv, smartarchive, smartarray, smartbrowser, smartdata, smartdelay, smartfile, smartlog, smartpath, smartpromise, smartrequest, smartstream, smartunique, smartxml, };
 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxJQUFJLEdBQ0wsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxJQUFJLE1BQU0sa0JBQWtCLENBQUM7QUFDekMsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFFakQsT0FBTyxFQUNMLEdBQUcsRUFDSCxJQUFJLEVBQ0osWUFBWSxFQUNaLFVBQVUsRUFDVixZQUFZLEVBQ1osU0FBUyxFQUNULFVBQVUsRUFDVixTQUFTLEVBQ1QsU0FBUyxFQUNULFlBQVksRUFDWixZQUFZLEVBQ1osV0FBVyxFQUNYLFdBQVcsRUFDWCxRQUFRLEdBQ1QsQ0FBQTtBQUVELGlCQUFpQjtBQUNqQixPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBRTVDLE9BQU8sRUFDTCxPQUFPLEdBQ1IsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxJQUFJLEdBQ0wsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxJQUFJLE1BQU0sa0JBQWtCLENBQUM7QUFDekMsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUVqRCxPQUFPLEVBQ0wsR0FBRyxFQUNILElBQUksRUFDSixZQUFZLEVBQ1osVUFBVSxFQUNWLFlBQVksRUFDWixTQUFTLEVBQ1QsVUFBVSxFQUNWLFNBQVMsRUFDVCxRQUFRLEVBQ1IsU0FBUyxFQUNULFlBQVksRUFDWixZQUFZLEVBQ1osV0FBVyxFQUNYLFdBQVcsRUFDWCxRQUFRLEdBQ1QsQ0FBQTtBQUVELGlCQUFpQjtBQUNqQixPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBRTVDLE9BQU8sRUFDTCxPQUFPLEdBQ1IsQ0FBQSJ9

package/dist_ts/stocks/classes.stockservice.d.ts

@@ -0,0 +1,32 @@
+import type { IStockProvider, IProviderConfig, IProviderRegistry } from './interfaces/provider.js';
+import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest } from './interfaces/stockprice.js';
+export declare class StockPriceService implements IProviderRegistry {
+    private providers;
+    private cache;
+    private logger;
+    private cacheConfig;
+    constructor(cacheConfig?: {
+        ttl?: number;
+        maxEntries?: number;
+    });
+    register(provider: IStockProvider, config?: IProviderConfig): void;
+    unregister(providerName: string): void;
+    getProvider(name: string): IStockProvider | undefined;
+    getAllProviders(): IStockProvider[];
+    getEnabledProviders(): IStockProvider[];
+    getPrice(request: IStockQuoteRequest): Promise<IStockPrice>;
+    getPrices(request: IStockBatchQuoteRequest): Promise<IStockPrice[]>;
+    checkProvidersHealth(): Promise<Map<string, boolean>>;
+    getProviderStats(): Map<string, {
+        successCount: number;
+        errorCount: number;
+        lastError?: string;
+        lastErrorTime?: Date;
+    }>;
+    clearCache(): void;
+    setCacheTTL(ttl: number): void;
+    private fetchWithRetry;
+    private getCacheKey;
+    private getFromCache;
+    private addToCache;
+}

package/dist_ts/stocks/classes.stockservice.js

@@ -0,0 +1,221 @@
+import * as plugins from '../plugins.js';
+export class StockPriceService {
+    constructor(cacheConfig) {
+        this.providers = new Map();
+        this.cache = new Map();
+        this.logger = console;
+        this.cacheConfig = {
+            ttl: 60000, // 60 seconds default
+            maxEntries: 1000
+        };
+        if (cacheConfig) {
+            this.cacheConfig = { ...this.cacheConfig, ...cacheConfig };
+        }
+    }
+    register(provider, config) {
+        const defaultConfig = {
+            enabled: true,
+            priority: provider.priority,
+            timeout: 10000,
+            retryAttempts: 2,
+            retryDelay: 1000
+        };
+        const mergedConfig = { ...defaultConfig, ...config };
+        this.providers.set(provider.name, {
+            provider,
+            config: mergedConfig,
+            successCount: 0,
+            errorCount: 0
+        });
+        console.log(`Registered provider: ${provider.name}`);
+    }
+    unregister(providerName) {
+        this.providers.delete(providerName);
+        console.log(`Unregistered provider: ${providerName}`);
+    }
+    getProvider(name) {
+        return this.providers.get(name)?.provider;
+    }
+    getAllProviders() {
+        return Array.from(this.providers.values()).map(entry => entry.provider);
+    }
+    getEnabledProviders() {
+        return Array.from(this.providers.values())
+            .filter(entry => entry.config.enabled)
+            .sort((a, b) => (b.config.priority || 0) - (a.config.priority || 0))
+            .map(entry => entry.provider);
+    }
+    async getPrice(request) {
+        const cacheKey = this.getCacheKey(request);
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            console.log(`Cache hit for ${request.ticker}`);
+            return cached;
+        }
+        const providers = this.getEnabledProviders();
+        if (providers.length === 0) {
+            throw new Error('No stock price providers available');
+        }
+        let lastError;
+        for (const provider of providers) {
+            const entry = this.providers.get(provider.name);
+            try {
+                const price = await this.fetchWithRetry(() => provider.fetchPrice(request), entry.config);
+                entry.successCount++;
+                this.addToCache(cacheKey, price);
+                console.log(`Successfully fetched ${request.ticker} from ${provider.name}`);
+                return price;
+            }
+            catch (error) {
+                entry.errorCount++;
+                entry.lastError = error;
+                entry.lastErrorTime = new Date();
+                lastError = error;
+                console.warn(`Provider ${provider.name} failed for ${request.ticker}: ${error.message}`);
+            }
+        }
+        throw new Error(`Failed to fetch price for ${request.ticker} from all providers. Last error: ${lastError?.message}`);
+    }
+    async getPrices(request) {
+        const cachedPrices = [];
+        const tickersToFetch = [];
+        // Check cache for each ticker
+        for (const ticker of request.tickers) {
+            const cacheKey = this.getCacheKey({ ticker, includeExtendedHours: request.includeExtendedHours });
+            const cached = this.getFromCache(cacheKey);
+            if (cached) {
+                cachedPrices.push(cached);
+            }
+            else {
+                tickersToFetch.push(ticker);
+            }
+        }
+        if (tickersToFetch.length === 0) {
+            console.log(`All ${request.tickers.length} tickers served from cache`);
+            return cachedPrices;
+        }
+        const providers = this.getEnabledProviders();
+        if (providers.length === 0) {
+            throw new Error('No stock price providers available');
+        }
+        let lastError;
+        let fetchedPrices = [];
+        for (const provider of providers) {
+            const entry = this.providers.get(provider.name);
+            try {
+                fetchedPrices = await this.fetchWithRetry(() => provider.fetchPrices({
+                    tickers: tickersToFetch,
+                    includeExtendedHours: request.includeExtendedHours
+                }), entry.config);
+                entry.successCount++;
+                // Cache the fetched prices
+                for (const price of fetchedPrices) {
+                    const cacheKey = this.getCacheKey({
+                        ticker: price.ticker,
+                        includeExtendedHours: request.includeExtendedHours
+                    });
+                    this.addToCache(cacheKey, price);
+                }
+                console.log(`Successfully fetched ${fetchedPrices.length} prices from ${provider.name}`);
+                break;
+            }
+            catch (error) {
+                entry.errorCount++;
+                entry.lastError = error;
+                entry.lastErrorTime = new Date();
+                lastError = error;
+                console.warn(`Provider ${provider.name} failed for batch request: ${error.message}`);
+            }
+        }
+        if (fetchedPrices.length === 0 && lastError) {
+            throw new Error(`Failed to fetch prices from all providers. Last error: ${lastError.message}`);
+        }
+        return [...cachedPrices, ...fetchedPrices];
+    }
+    async checkProvidersHealth() {
+        const health = new Map();
+        for (const [name, entry] of this.providers) {
+            if (!entry.config.enabled) {
+                health.set(name, false);
+                continue;
+            }
+            try {
+                const isAvailable = await entry.provider.isAvailable();
+                health.set(name, isAvailable);
+            }
+            catch (error) {
+                health.set(name, false);
+                console.error(`Health check failed for ${name}:`, error);
+            }
+        }
+        return health;
+    }
+    getProviderStats() {
+        const stats = new Map();
+        for (const [name, entry] of this.providers) {
+            stats.set(name, {
+                successCount: entry.successCount,
+                errorCount: entry.errorCount,
+                lastError: entry.lastError?.message,
+                lastErrorTime: entry.lastErrorTime
+            });
+        }
+        return stats;
+    }
+    clearCache() {
+        this.cache.clear();
+        console.log('Cache cleared');
+    }
+    setCacheTTL(ttl) {
+        this.cacheConfig.ttl = ttl;
+        console.log(`Cache TTL set to ${ttl}ms`);
+    }
+    async fetchWithRetry(fetchFn, config) {
+        const maxAttempts = config.retryAttempts || 1;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await fetchFn();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts) {
+                    const delay = (config.retryDelay || 1000) * attempt;
+                    console.log(`Retry attempt ${attempt} after ${delay}ms`);
+                    await plugins.smartdelay.delayFor(delay);
+                }
+            }
+        }
+        throw lastError || new Error('Unknown error during fetch');
+    }
+    getCacheKey(request) {
+        return `${request.ticker}:${request.includeExtendedHours || false}`;
+    }
+    getFromCache(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        const age = Date.now() - entry.timestamp.getTime();
+        if (age > this.cacheConfig.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.price;
+    }
+    addToCache(key, price) {
+        // Enforce max entries limit
+        if (this.cache.size >= this.cacheConfig.maxEntries) {
+            // Remove oldest entry
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+            }
+        }
+        this.cache.set(key, {
+            price,
+            timestamp: new Date()
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stockservice.js","sourceRoot":"","sources":["../../ts/stocks/classes.stockservice.ts"],"names":[],"mappings":"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"}

package/dist_ts/stocks/index.d.ts

@@ -0,0 +1,4 @@
+export * from './interfaces/stockprice.js';
+export * from './interfaces/provider.js';
+export * from './classes.stockservice.js';
+export * from './providers/provider.yahoo.js';

package/dist_ts/stocks/index.js

@@ -0,0 +1,8 @@
+// Export all interfaces
+export * from './interfaces/stockprice.js';
+export * from './interfaces/provider.js';
+// Export main service
+export * from './classes.stockservice.js';
+// Export providers
+export * from './providers/provider.yahoo.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9zdG9ja3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywwQkFBMEIsQ0FBQztBQUV6QyxzQkFBc0I7QUFDdEIsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyxtQkFBbUI7QUFDbkIsY0FBYywrQkFBK0IsQ0FBQyJ9

package/dist_ts/stocks/interfaces/provider.d.ts

@@ -0,0 +1,30 @@
+import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest } from './stockprice.js';
+export interface IStockProvider {
+    name: string;
+    priority: number;
+    fetchPrice(request: IStockQuoteRequest): Promise<IStockPrice>;
+    fetchPrices(request: IStockBatchQuoteRequest): Promise<IStockPrice[]>;
+    isAvailable(): Promise<boolean>;
+    supportsMarket?(market: string): boolean;
+    supportsTicker?(ticker: string): boolean;
+    readonly requiresAuth: boolean;
+    readonly rateLimit?: {
+        requestsPerMinute: number;
+        requestsPerDay?: number;
+    };
+}
+export interface IProviderConfig {
+    enabled: boolean;
+    priority?: number;
+    apiKey?: string;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+export interface IProviderRegistry {
+    register(provider: IStockProvider, config?: IProviderConfig): void;
+    unregister(providerName: string): void;
+    getProvider(name: string): IStockProvider | undefined;
+    getAllProviders(): IStockProvider[];
+    getEnabledProviders(): IStockProvider[];
+}

package/dist_ts/stocks/interfaces/provider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zdG9ja3MvaW50ZXJmYWNlcy9wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist_ts/stocks/interfaces/stockprice.d.ts

@@ -0,0 +1,27 @@
+export interface IStockPrice {
+    ticker: string;
+    price: number;
+    currency: string;
+    change: number;
+    changePercent: number;
+    previousClose: number;
+    timestamp: Date;
+    provider: string;
+    marketState: 'PRE' | 'REGULAR' | 'POST' | 'CLOSED';
+    exchange?: string;
+    exchangeName?: string;
+}
+export interface IStockPriceError {
+    ticker: string;
+    error: string;
+    provider: string;
+    timestamp: Date;
+}
+export interface IStockQuoteRequest {
+    ticker: string;
+    includeExtendedHours?: boolean;
+}
+export interface IStockBatchQuoteRequest {
+    tickers: string[];
+    includeExtendedHours?: boolean;
+}

package/dist_ts/stocks/interfaces/stockprice.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvY2twcmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3N0b2Nrcy9pbnRlcmZhY2VzL3N0b2NrcHJpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/stocks/providers/provider.yahoo.d.ts

@@ -0,0 +1,22 @@
+import type { IStockProvider, IProviderConfig } from '../interfaces/provider.js';
+import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest } from '../interfaces/stockprice.js';
+export declare class YahooFinanceProvider implements IStockProvider {
+    private config?;
+    name: string;
+    priority: number;
+    readonly requiresAuth = false;
+    readonly rateLimit: {
+        requestsPerMinute: number;
+        requestsPerDay: any;
+    };
+    private logger;
+    private baseUrl;
+    private userAgent;
+    constructor(config?: IProviderConfig);
+    fetchPrice(request: IStockQuoteRequest): Promise<IStockPrice>;
+    fetchPrices(request: IStockBatchQuoteRequest): Promise<IStockPrice[]>;
+    isAvailable(): Promise<boolean>;
+    supportsMarket(market: string): boolean;
+    supportsTicker(ticker: string): boolean;
+    private determineMarketState;
+}

package/dist_ts/stocks/providers/provider.yahoo.js

@@ -0,0 +1,139 @@
+import * as plugins from '../../plugins.js';
+export class YahooFinanceProvider {
+    constructor(config) {
+        this.config = config;
+        this.name = 'Yahoo Finance';
+        this.priority = 100;
+        this.requiresAuth = false;
+        this.rateLimit = {
+            requestsPerMinute: 100, // Conservative estimate
+            requestsPerDay: undefined
+        };
+        this.logger = console;
+        this.baseUrl = 'https://query1.finance.yahoo.com';
+        this.userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+    }
+    async fetchPrice(request) {
+        try {
+            const url = `${this.baseUrl}/v8/finance/chart/${request.ticker}`;
+            const response = await plugins.smartrequest.getJson(url, {
+                headers: {
+                    'User-Agent': this.userAgent
+                },
+                timeout: this.config?.timeout || 10000
+            });
+            const responseData = response.body;
+            if (!responseData?.chart?.result?.[0]) {
+                throw new Error(`No data found for ticker ${request.ticker}`);
+            }
+            const data = responseData.chart.result[0];
+            const meta = data.meta;
+            if (!meta.regularMarketPrice) {
+                throw new Error(`No price data available for ${request.ticker}`);
+            }
+            const stockPrice = {
+                ticker: request.ticker.toUpperCase(),
+                price: meta.regularMarketPrice,
+                currency: meta.currency || 'USD',
+                change: meta.regularMarketPrice - meta.previousClose,
+                changePercent: ((meta.regularMarketPrice - meta.previousClose) / meta.previousClose) * 100,
+                previousClose: meta.previousClose,
+                timestamp: new Date(meta.regularMarketTime * 1000),
+                provider: this.name,
+                marketState: this.determineMarketState(meta),
+                exchange: meta.exchange,
+                exchangeName: meta.exchangeName
+            };
+            return stockPrice;
+        }
+        catch (error) {
+            console.error(`Failed to fetch price for ${request.ticker}:`, error);
+            throw new Error(`Yahoo Finance: Failed to fetch price for ${request.ticker}: ${error.message}`);
+        }
+    }
+    async fetchPrices(request) {
+        try {
+            const symbols = request.tickers.join(',');
+            const url = `${this.baseUrl}/v8/finance/spark?symbols=${symbols}&range=1d&interval=5m`;
+            const response = await plugins.smartrequest.getJson(url, {
+                headers: {
+                    'User-Agent': this.userAgent
+                },
+                timeout: this.config?.timeout || 15000
+            });
+            const responseData = response.body;
+            const prices = [];
+            for (const [ticker, data] of Object.entries(responseData)) {
+                if (!data || typeof data !== 'object')
+                    continue;
+                const sparkData = data;
+                if (!sparkData.previousClose || !sparkData.close?.length) {
+                    console.warn(`Incomplete data for ${ticker}, skipping`);
+                    continue;
+                }
+                const currentPrice = sparkData.close[sparkData.close.length - 1];
+                const timestamp = sparkData.timestamp?.[sparkData.timestamp.length - 1];
+                prices.push({
+                    ticker: ticker.toUpperCase(),
+                    price: currentPrice,
+                    currency: sparkData.currency || 'USD',
+                    change: currentPrice - sparkData.previousClose,
+                    changePercent: ((currentPrice - sparkData.previousClose) / sparkData.previousClose) * 100,
+                    previousClose: sparkData.previousClose,
+                    timestamp: timestamp ? new Date(timestamp * 1000) : new Date(),
+                    provider: this.name,
+                    marketState: sparkData.marketState || 'REGULAR',
+                    exchange: sparkData.exchange,
+                    exchangeName: sparkData.exchangeName
+                });
+            }
+            if (prices.length === 0) {
+                throw new Error('No valid price data received from batch request');
+            }
+            return prices;
+        }
+        catch (error) {
+            console.error(`Failed to fetch batch prices:`, error);
+            throw new Error(`Yahoo Finance: Failed to fetch batch prices: ${error.message}`);
+        }
+    }
+    async isAvailable() {
+        try {
+            // Test with a well-known ticker
+            await this.fetchPrice({ ticker: 'AAPL' });
+            return true;
+        }
+        catch (error) {
+            console.warn('Yahoo Finance provider is not available:', error);
+            return false;
+        }
+    }
+    supportsMarket(market) {
+        // Yahoo Finance supports most major markets
+        const supportedMarkets = ['US', 'UK', 'DE', 'FR', 'JP', 'CN', 'HK', 'AU', 'CA'];
+        return supportedMarkets.includes(market.toUpperCase());
+    }
+    supportsTicker(ticker) {
+        // Basic validation - Yahoo supports most tickers
+        return /^[A-Z0-9\.\-]{1,10}$/.test(ticker.toUpperCase());
+    }
+    determineMarketState(meta) {
+        const marketState = meta.marketState?.toUpperCase();
+        switch (marketState) {
+            case 'PRE':
+                return 'PRE';
+            case 'POST':
+                return 'POST';
+            case 'REGULAR':
+                return 'REGULAR';
+            default:
+                // Check if market is currently open based on timestamps
+                const now = Date.now() / 1000;
+                const regularMarketTime = meta.regularMarketTime;
+                const timeDiff = now - regularMarketTime;
+                // If last update was more than 1 hour ago, market is likely closed
+                return timeDiff > 3600 ? 'CLOSED' : 'REGULAR';
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "@fin.cx/opendata",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "private": false,
-  "description": "A comprehensive TypeScript library that manages open business data for German companies by integrating MongoDB, processing JSONL bulk data, and automating browser interactions for Handelsregister data retrieval.",
+  "description": "A comprehensive TypeScript library for accessing business data and real-time financial information. Features include German company data management with MongoDB integration, JSONL bulk processing, automated Handelsregister interactions, and real-time stock market data from multiple providers.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.3.2",
-    "@git.zone/tsbundle": "^2.2.5",
+    "@git.zone/tsbuild": "^2.6.4",
+    "@git.zone/tsbundle": "^2.5.1",
     "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.96",
-    "@push.rocks/tapbundle": "^5.6.2",
+    "@git.zone/tstest": "^2.3.1",
     "@types/node": "^22.14.0"
   },
   "dependencies": {
-    "@push.rocks/lik": "^6.1.0",
+    "@push.rocks/lik": "^6.2.2",
     "@push.rocks/qenv": "^6.1.0",
     "@push.rocks/smartarchive": "^4.0.39",
     "@push.rocks/smartarray": "^1.1.0",
     "@push.rocks/smartbrowser": "^2.0.8",
-    "@push.rocks/smartdata": "^5.2.12",
+    "@push.rocks/smartdata": "^5.15.1",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartfile": "^11.2.0",
+    "@push.rocks/smartfile": "^11.2.5",
+    "@push.rocks/smartlog": "^3.1.8",
     "@push.rocks/smartpath": "^5.0.18",
     "@push.rocks/smartpromise": "^4.2.3",
     "@push.rocks/smartrequest": "^2.1.0",
     "@push.rocks/smartstream": "^3.2.5",
     "@push.rocks/smartunique": "^3.0.9",
     "@push.rocks/smartxml": "^1.1.1",
-    "@tsclass/tsclass": "^8.2.0"
+    "@tsclass/tsclass": "^9.2.0"
   },
   "repository": {
     "type": "git",
@@ -74,7 +74,7 @@
     "data retrieval"
   ],
   "scripts": {
-    "test": "(tstest test/ --web)",
+    "test": "(tstest test/ --verbose)",
     "build": "(tsbuild --web --allowimplicitany)",
     "buildDocs": "(tsdoc)"
   }