@pydantic/genai-prices 0.0.19 → 0.0.21

package/dist/dataLoader.d.ts

@@ -1,18 +0,0 @@
-import { Provider, PriceDataStorage } from './types.js';
-export declare function setStorageBackend(storage: PriceDataStorage): void;
-export declare function fetchRemoteData(): Promise<Provider[]>;
-export declare function getProvidersAsync(): Promise<Provider[]>;
-export declare function enableAutoUpdate(options?: {
-    url?: string;
-    ttlMs?: number;
-    storage?: PriceDataStorage;
-}): void;
-export declare function isLocalDataOutdated(): Promise<boolean>;
-export declare function prefetchAsync(): void;
-export declare function getProvidersSync(): Provider[];
-export declare function getEnvironmentInfo(): {
-    environment: "node" | "browser" | "cloudflare" | "deno" | "unknown";
-    hasFetch: boolean;
-    hasProcess: boolean;
-    hasWindow: boolean;
-};

package/dist/dataLoader.js

@@ -1,146 +0,0 @@
-import { data as embeddedData } from './data.js';
-const DEFAULT_URL = 'https://raw.githubusercontent.com/pydantic/genai-prices/main/prices/data.json';
-const DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour
-const OUTDATED_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 1 day
-const BACKGROUND_REFRESH_MS = 30 * 60 * 1000; // 30 minutes
-// environment detection
-function detectEnvironment() {
-    if (typeof globalThis !== 'undefined' && 'caches' in globalThis && 'default' in globalThis.caches) {
-        return 'cloudflare';
-    }
-    if (typeof globalThis.Deno !== 'undefined') {
-        return 'deno';
-    }
-    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
-        return 'node';
-    }
-    if (typeof window !== 'undefined' && typeof document !== 'undefined') {
-        return 'browser';
-    }
-    return 'unknown';
-}
-async function universalFetch(url, options = {}) {
-    const env = detectEnvironment();
-    if (env === 'node') {
-        const { default: nodeFetch } = await import('node-fetch');
-        return nodeFetch(url, options);
-    }
-    if (typeof fetch !== 'undefined') {
-        return fetch(url, options);
-    }
-    throw new Error(`Fetch not available in environment: ${env}`);
-}
-// storage implementation
-let inMemoryData = null;
-let inMemoryLastModified = null;
-const universalStorage = {
-    get: async () => inMemoryData,
-    set: async (data) => {
-        inMemoryData = data;
-        inMemoryLastModified = Date.now();
-    },
-    get_last_modified: async () => inMemoryLastModified,
-};
-let storageBackend = universalStorage;
-let asyncProviders = null;
-let asyncLastLoaded = 0;
-let asyncFetchPromise = null;
-let autoUpdate = false;
-let remoteUrl = DEFAULT_URL;
-let ttlMs = DEFAULT_TTL_MS;
-export function setStorageBackend(storage) {
-    storageBackend = storage;
-}
-async function loadDataAsync() {
-    const raw = await storageBackend.get();
-    if (!raw)
-        throw new Error('No data found in storage backend');
-    const data = JSON.parse(raw);
-    return Array.isArray(data) ? data : [];
-}
-async function saveDataAsync(data) {
-    await storageBackend.set(data);
-}
-export async function fetchRemoteData() {
-    const res = await universalFetch(remoteUrl, { cache: 'no-store' });
-    if (!res.ok)
-        throw new Error(`Failed to fetch data: ${res.statusText}`);
-    const data = await res.text();
-    await saveDataAsync(data);
-    const parsed = JSON.parse(data);
-    return Array.isArray(parsed) ? parsed : [];
-}
-export async function getProvidersAsync() {
-    const now = Date.now();
-    if (asyncProviders && now - asyncLastLoaded < ttlMs) {
-        if (now - asyncLastLoaded > BACKGROUND_REFRESH_MS && !asyncFetchPromise) {
-            asyncFetchPromise = (async () => {
-                try {
-                    asyncProviders = await fetchRemoteData();
-                    asyncLastLoaded = Date.now();
-                    return asyncProviders;
-                }
-                catch (e) {
-                    return asyncProviders;
-                }
-                finally {
-                    asyncFetchPromise = null;
-                }
-            })();
-        }
-        return asyncProviders;
-    }
-    if (asyncFetchPromise) {
-        return asyncFetchPromise;
-    }
-    asyncFetchPromise = (async () => {
-        try {
-            asyncProviders = await fetchRemoteData();
-            asyncLastLoaded = Date.now();
-            return asyncProviders;
-        }
-        catch (e) {
-            asyncProviders = await loadDataAsync();
-            asyncLastLoaded = Date.now();
-            return asyncProviders;
-        }
-        finally {
-            asyncFetchPromise = null;
-        }
-    })();
-    return asyncFetchPromise;
-}
-export function enableAutoUpdate(options) {
-    autoUpdate = true;
-    if (options?.url)
-        remoteUrl = options.url;
-    if (options?.ttlMs)
-        ttlMs = options.ttlMs;
-    if (options?.storage)
-        setStorageBackend(options.storage);
-}
-export async function isLocalDataOutdated() {
-    if (!storageBackend.get_last_modified)
-        return false;
-    const ts = await storageBackend.get_last_modified();
-    if (!ts)
-        return true;
-    return Date.now() - ts > OUTDATED_THRESHOLD_MS;
-}
-export function prefetchAsync() {
-    if (!asyncFetchPromise) {
-        asyncFetchPromise = getProvidersAsync();
-    }
-}
-// sync function that works everywhere
-export function getProvidersSync() {
-    return embeddedData;
-}
-export function getEnvironmentInfo() {
-    return {
-        environment: detectEnvironment(),
-        hasFetch: typeof fetch !== 'undefined',
-        hasProcess: typeof process !== 'undefined',
-        hasWindow: typeof window !== 'undefined',
-    };
-}