@profplum700/etsy-v3-api-client 2.4.0 → 2.4.2

package/dist/index.umd.js

@@ -1,1180 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('crypto')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'crypto'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EtsyV3ApiClient = {}, global.crypto));
-})(this, (function (exports, crypto) { 'use strict';
-
-    const ETSY_WHEN_MADE_VALUES = [
-        '1990s',
-        '1980s',
-        '1970s',
-        '1960s',
-        '1950s',
-        '1940s',
-        '1930s',
-        '1920s',
-        '1910s',
-        '1900s',
-        '1800s',
-        '1700s',
-        'before_1700'
-    ];
-    class EtsyApiError extends Error {
-        constructor(message, statusCode, response) {
-            super(message);
-            this.statusCode = statusCode;
-            this.response = response;
-            this.name = 'EtsyApiError';
-        }
-    }
-    class EtsyAuthError extends Error {
-        constructor(message, code) {
-            super(message);
-            this.code = code;
-            this.name = 'EtsyAuthError';
-        }
-    }
-    class EtsyRateLimitError extends Error {
-        constructor(message, retryAfter) {
-            super(message);
-            this.retryAfter = retryAfter;
-            this.name = 'EtsyRateLimitError';
-        }
-    }
-
-    class MemoryTokenStorage {
-        constructor() {
-            this.tokens = null;
-        }
-        async save(tokens) {
-            this.tokens = { ...tokens };
-        }
-        async load() {
-            return this.tokens ? { ...this.tokens } : null;
-        }
-        async clear() {
-            this.tokens = null;
-        }
-    }
-    class TokenManager {
-        constructor(config, storage) {
-            this.currentTokens = null;
-            this.keystring = config.keystring;
-            this.refreshCallback = config.refreshSave;
-            this.storage = storage;
-            this.currentTokens = {
-                access_token: config.accessToken,
-                refresh_token: config.refreshToken,
-                expires_at: config.expiresAt,
-                token_type: 'Bearer',
-                scope: ''
-            };
-        }
-        async getAccessToken() {
-            if (!this.currentTokens) {
-                if (this.storage) {
-                    this.currentTokens = await this.storage.load();
-                }
-                if (!this.currentTokens) {
-                    throw new EtsyAuthError('No tokens available', 'NO_TOKENS');
-                }
-            }
-            const now = new Date();
-            const expiresAt = new Date(this.currentTokens.expires_at);
-            const bufferTime = 60 * 1000;
-            if (now.getTime() >= (expiresAt.getTime() - bufferTime)) {
-                await this.refreshToken();
-            }
-            return this.currentTokens.access_token;
-        }
-        async refreshToken() {
-            if (this.refreshPromise) {
-                return this.refreshPromise;
-            }
-            if (!this.currentTokens) {
-                throw new EtsyAuthError('No tokens available to refresh', 'NO_REFRESH_TOKEN');
-            }
-            this.refreshPromise = this.performTokenRefresh();
-            try {
-                const newTokens = await this.refreshPromise;
-                this.currentTokens = newTokens;
-                if (this.storage) {
-                    await this.storage.save(newTokens);
-                }
-                if (this.refreshCallback) {
-                    this.refreshCallback(newTokens.access_token, newTokens.refresh_token, newTokens.expires_at);
-                }
-                return newTokens;
-            }
-            finally {
-                this.refreshPromise = undefined;
-            }
-        }
-        async performTokenRefresh() {
-            if (!this.currentTokens) {
-                throw new EtsyAuthError('No tokens available', 'NO_TOKENS');
-            }
-            const body = new URLSearchParams({
-                grant_type: 'refresh_token',
-                client_id: this.keystring,
-                refresh_token: this.currentTokens.refresh_token
-            });
-            try {
-                const response = await this.fetch('https://api.etsy.com/v3/public/oauth/token', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded',
-                        'Accept': 'application/json'
-                    },
-                    body: body.toString()
-                });
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    throw new EtsyAuthError(`Token refresh failed: ${response.status} ${response.statusText} - ${errorText}`, 'TOKEN_REFRESH_FAILED');
-                }
-                const tokenResponse = await response.json();
-                return {
-                    access_token: tokenResponse.access_token,
-                    refresh_token: tokenResponse.refresh_token,
-                    expires_at: new Date(Date.now() + (tokenResponse.expires_in * 1000)),
-                    token_type: tokenResponse.token_type,
-                    scope: tokenResponse.scope
-                };
-            }
-            catch (error) {
-                if (error instanceof EtsyAuthError) {
-                    throw error;
-                }
-                throw new EtsyAuthError(`Token refresh failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'TOKEN_REFRESH_ERROR');
-            }
-        }
-        getCurrentTokens() {
-            return this.currentTokens ? { ...this.currentTokens } : null;
-        }
-        updateTokens(tokens) {
-            this.currentTokens = { ...tokens };
-        }
-        isTokenExpired() {
-            if (!this.currentTokens) {
-                return true;
-            }
-            const now = new Date();
-            const expiresAt = new Date(this.currentTokens.expires_at);
-            return now.getTime() >= expiresAt.getTime();
-        }
-        willTokenExpireSoon(minutes = 5) {
-            if (!this.currentTokens) {
-                return true;
-            }
-            const now = new Date();
-            const expiresAt = new Date(this.currentTokens.expires_at);
-            const bufferTime = minutes * 60 * 1000;
-            return now.getTime() >= (expiresAt.getTime() - bufferTime);
-        }
-        async clearTokens() {
-            this.currentTokens = null;
-            if (this.storage) {
-                await this.storage.clear();
-            }
-        }
-        getTimeUntilExpiration() {
-            if (!this.currentTokens) {
-                return null;
-            }
-            const now = new Date();
-            const expiresAt = new Date(this.currentTokens.expires_at);
-            return expiresAt.getTime() - now.getTime();
-        }
-        async fetch(url, options) {
-            if (typeof globalThis.fetch !== 'undefined') {
-                return globalThis.fetch(url, options);
-            }
-            try {
-                const { default: fetch } = await import('node-fetch');
-                return fetch(url, options);
-            }
-            catch (error) {
-                throw new EtsyAuthError('Fetch is not available. Please provide a fetch implementation or use Node.js 18+ or a modern browser.', 'FETCH_NOT_AVAILABLE');
-            }
-        }
-    }
-    class FileTokenStorage {
-        constructor(filePath) {
-            this.filePath = filePath;
-        }
-        async save(tokens) {
-            const fs = await import('fs/promises');
-            const data = JSON.stringify(tokens, null, 2);
-            await fs.writeFile(this.filePath, data, 'utf8');
-        }
-        async load() {
-            try {
-                const fs = await import('fs/promises');
-                const data = await fs.readFile(this.filePath, 'utf8');
-                const tokens = JSON.parse(data);
-                if (tokens.expires_at) {
-                    tokens.expires_at = new Date(tokens.expires_at);
-                }
-                return tokens;
-            }
-            catch (error) {
-                return null;
-            }
-        }
-        async clear() {
-            try {
-                const fs = await import('fs/promises');
-                await fs.unlink(this.filePath);
-            }
-            catch (error) {
-            }
-        }
-    }
-
-    class EtsyRateLimiter {
-        constructor(config) {
-            this.requestCount = 0;
-            this.dailyReset = new Date();
-            this.lastRequestTime = 0;
-            this.config = {
-                maxRequestsPerDay: 10000,
-                maxRequestsPerSecond: 10,
-                minRequestInterval: 100,
-                ...config
-            };
-            this.dailyReset.setUTCHours(24, 0, 0, 0);
-        }
-        async waitForRateLimit() {
-            const now = Date.now();
-            if (now > this.dailyReset.getTime()) {
-                this.requestCount = 0;
-                this.dailyReset = new Date(now);
-                this.dailyReset.setUTCHours(24, 0, 0, 0);
-            }
-            if (this.requestCount >= this.config.maxRequestsPerDay) {
-                const timeUntilReset = this.dailyReset.getTime() - now;
-                throw new EtsyRateLimitError(`Daily rate limit of ${this.config.maxRequestsPerDay} requests exceeded. Reset in ${Math.ceil(timeUntilReset / 1000 / 60)} minutes.`, timeUntilReset);
-            }
-            const timeSinceLastRequest = now - this.lastRequestTime;
-            if (timeSinceLastRequest < this.config.minRequestInterval) {
-                const waitTime = this.config.minRequestInterval - timeSinceLastRequest;
-                await new Promise(resolve => setTimeout(resolve, waitTime));
-            }
-            this.requestCount++;
-            this.lastRequestTime = Date.now();
-        }
-        getRateLimitStatus() {
-            const now = Date.now();
-            this.dailyReset.getTime() - now;
-            return {
-                remainingRequests: Math.max(0, this.config.maxRequestsPerDay - this.requestCount),
-                resetTime: this.dailyReset,
-                canMakeRequest: this.requestCount < this.config.maxRequestsPerDay &&
-                    (now - this.lastRequestTime) >= this.config.minRequestInterval
-            };
-        }
-        getRemainingRequests() {
-            return Math.max(0, this.config.maxRequestsPerDay - this.requestCount);
-        }
-        reset() {
-            this.requestCount = 0;
-            this.lastRequestTime = 0;
-            this.dailyReset = new Date();
-            this.dailyReset.setUTCHours(24, 0, 0, 0);
-        }
-        canMakeRequest() {
-            const now = Date.now();
-            if (this.requestCount >= this.config.maxRequestsPerDay) {
-                return false;
-            }
-            return (now - this.lastRequestTime) >= this.config.minRequestInterval;
-        }
-        getTimeUntilNextRequest() {
-            const now = Date.now();
-            const timeSinceLastRequest = now - this.lastRequestTime;
-            if (timeSinceLastRequest >= this.config.minRequestInterval) {
-                return 0;
-            }
-            return this.config.minRequestInterval - timeSinceLastRequest;
-        }
-        getConfig() {
-            return { ...this.config };
-        }
-    }
-    const defaultRateLimiter = new EtsyRateLimiter();
-
-    class DefaultLogger {
-        debug(message, ...args) {
-            if (process.env.NODE_ENV === 'development') {
-                console.log(`[DEBUG] ${message}`, ...args);
-            }
-        }
-        info(message, ...args) {
-            console.log(`[INFO] ${message}`, ...args);
-        }
-        warn(message, ...args) {
-            console.warn(`[WARN] ${message}`, ...args);
-        }
-        error(message, ...args) {
-            console.error(`[ERROR] ${message}`, ...args);
-        }
-    }
-    class MemoryCache {
-        constructor() {
-            this.cache = new Map();
-        }
-        async get(key) {
-            const entry = this.cache.get(key);
-            if (!entry)
-                return null;
-            if (Date.now() > entry.expires) {
-                this.cache.delete(key);
-                return null;
-            }
-            return entry.value;
-        }
-        async set(key, value, ttl = 3600) {
-            const expires = Date.now() + (ttl * 1000);
-            this.cache.set(key, { value, expires });
-        }
-        async delete(key) {
-            this.cache.delete(key);
-        }
-        async clear() {
-            this.cache.clear();
-        }
-    }
-    class EtsyClient {
-        constructor(config) {
-            this.tokenManager = new TokenManager(config);
-            this.baseUrl = config.baseUrl || 'https://api.etsy.com/v3/application';
-            this.logger = new DefaultLogger();
-            this.keystring = config.keystring;
-            this.rateLimiter = new EtsyRateLimiter(config.rateLimiting?.enabled !== false ? {
-                maxRequestsPerDay: config.rateLimiting?.maxRequestsPerDay || 10000,
-                maxRequestsPerSecond: config.rateLimiting?.maxRequestsPerSecond || 10,
-                minRequestInterval: 100
-            } : undefined);
-            if (config.caching?.enabled !== false) {
-                this.cache = config.caching?.storage || new MemoryCache();
-                this.cacheTtl = config.caching?.ttl || 3600;
-            }
-        }
-        async makeRequest(endpoint, options = {}, useCache = true) {
-            const url = `${this.baseUrl}${endpoint}`;
-            const cacheKey = `${url}:${JSON.stringify(options)}`;
-            if (useCache && this.cache && options.method === 'GET') {
-                const cached = await this.cache.get(cacheKey);
-                if (cached) {
-                    return JSON.parse(cached);
-                }
-            }
-            await this.rateLimiter.waitForRateLimit();
-            const accessToken = await this.tokenManager.getAccessToken();
-            const headers = {
-                'Authorization': `Bearer ${accessToken}`,
-                'x-api-key': this.getApiKey(),
-                'Content-Type': 'application/json',
-                'Accept': 'application/json',
-                ...options.headers
-            };
-            try {
-                const response = await this.fetch(url, {
-                    ...options,
-                    headers
-                });
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    throw new EtsyApiError(`Etsy API error: ${response.status} ${response.statusText}`, response.status, errorText);
-                }
-                const data = await response.json();
-                if (useCache && this.cache && options.method === 'GET') {
-                    await this.cache.set(cacheKey, JSON.stringify(data), this.cacheTtl);
-                }
-                return data;
-            }
-            catch (error) {
-                if (error instanceof EtsyApiError) {
-                    throw error;
-                }
-                throw new EtsyApiError(`Request failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 0, error);
-            }
-        }
-        getApiKey() {
-            return this.keystring;
-        }
-        async getUser() {
-            return this.makeRequest('/users/me');
-        }
-        async getShop(shopId) {
-            if (shopId) {
-                return this.makeRequest(`/shops/${shopId}`);
-            }
-            const user = await this.getUser();
-            if (!user.shop_id) {
-                throw new EtsyApiError('User does not have a shop', 404);
-            }
-            return this.makeRequest(`/shops/${user.shop_id}`);
-        }
-        async getShopByOwnerUserId(userId) {
-            return this.makeRequest(`/users/${userId}/shops`);
-        }
-        async getShopSections(shopId) {
-            let targetShopId = shopId;
-            if (!targetShopId) {
-                const user = await this.getUser();
-                if (!user.shop_id) {
-                    throw new EtsyApiError('User does not have a shop', 404);
-                }
-                targetShopId = user.shop_id.toString();
-            }
-            const response = await this.makeRequest(`/shops/${targetShopId}/sections`);
-            this.logger.info(`Found ${response.results.length} shop sections`);
-            return response.results;
-        }
-        async getShopSection(shopId, sectionId) {
-            return this.makeRequest(`/shops/${shopId}/sections/${sectionId}`);
-        }
-        async getListingsByShop(shopId, params = {}) {
-            let targetShopId = shopId;
-            if (!targetShopId) {
-                const user = await this.getUser();
-                if (!user.shop_id) {
-                    throw new EtsyApiError('User does not have a shop', 404);
-                }
-                targetShopId = user.shop_id.toString();
-            }
-            const searchParams = new URLSearchParams();
-            searchParams.set('state', params.state || 'active');
-            if (params.limit)
-                searchParams.set('limit', params.limit.toString());
-            if (params.offset)
-                searchParams.set('offset', params.offset.toString());
-            if (params.sort_on)
-                searchParams.set('sort_on', params.sort_on);
-            if (params.sort_order)
-                searchParams.set('sort_order', params.sort_order);
-            if (params.includes)
-                searchParams.set('includes', params.includes.join(','));
-            const response = await this.makeRequest(`/shops/${targetShopId}/listings?${searchParams.toString()}`);
-            return response.results;
-        }
-        async getListing(listingId, includes) {
-            const params = includes ? `?includes=${includes.join(',')}` : '';
-            return this.makeRequest(`/listings/${listingId}${params}`);
-        }
-        async findAllListingsActive(params = {}) {
-            const searchParams = new URLSearchParams();
-            if (params.keywords)
-                searchParams.set('keywords', params.keywords);
-            if (params.category)
-                searchParams.set('category', params.category);
-            if (params.limit)
-                searchParams.set('limit', params.limit.toString());
-            if (params.offset)
-                searchParams.set('offset', params.offset.toString());
-            if (params.sort_on)
-                searchParams.set('sort_on', params.sort_on);
-            if (params.sort_order)
-                searchParams.set('sort_order', params.sort_order);
-            if (params.min_price)
-                searchParams.set('min_price', params.min_price.toString());
-            if (params.max_price)
-                searchParams.set('max_price', params.max_price.toString());
-            if (params.tags)
-                searchParams.set('tags', params.tags.join(','));
-            if (params.location)
-                searchParams.set('location', params.location);
-            if (params.shop_location)
-                searchParams.set('shop_location', params.shop_location);
-            const response = await this.makeRequest(`/listings/active?${searchParams.toString()}`);
-            return response.results;
-        }
-        async getListingImages(listingId) {
-            const response = await this.makeRequest(`/listings/${listingId}/images`);
-            return response.results;
-        }
-        async getListingInventory(listingId) {
-            return this.makeRequest(`/listings/${listingId}/inventory`);
-        }
-        convertToEtsyProduct(listing) {
-            return {
-                listing_id: listing.listing_id.toString(),
-                title: listing.title,
-                description: listing.description,
-                price: listing.price.amount / listing.price.divisor,
-                url: listing.url,
-                images: listing.images?.map(img => img.url_570xN) || [],
-                when_made: listing.when_made,
-                shop_section_id: listing.shop_section_id?.toString(),
-                tags: listing.tags,
-                materials: listing.materials,
-                style: listing.style,
-                item_length: listing.item_length,
-                item_width: listing.item_width,
-                item_height: listing.item_height,
-                item_dimensions_unit: listing.item_dimensions_unit
-            };
-        }
-        async searchProducts(params) {
-            const listings = await this.findAllListingsActive(params);
-            return listings.map(listing => this.convertToEtsyProduct(listing));
-        }
-        getRemainingRequests() {
-            return this.rateLimiter.getRemainingRequests();
-        }
-        getRateLimitStatus() {
-            return this.rateLimiter.getRateLimitStatus();
-        }
-        async clearCache() {
-            if (this.cache) {
-                await this.cache.clear();
-            }
-        }
-        getCurrentTokens() {
-            return this.tokenManager.getCurrentTokens();
-        }
-        isTokenExpired() {
-            return this.tokenManager.isTokenExpired();
-        }
-        async refreshToken() {
-            return this.tokenManager.refreshToken();
-        }
-        async fetch(url, options) {
-            if (typeof globalThis.fetch !== 'undefined') {
-                return globalThis.fetch(url, options);
-            }
-            try {
-                const { default: fetch } = await import('node-fetch');
-                return fetch(url, options);
-            }
-            catch (error) {
-                throw new EtsyAuthError('Fetch is not available. Please provide a fetch implementation or use Node.js 18+ or a modern browser.', 'FETCH_NOT_AVAILABLE');
-            }
-        }
-    }
-
-    class AuthHelper {
-        constructor(config) {
-            this.keystring = config.keystring;
-            this.redirectUri = config.redirectUri;
-            this.scopes = config.scopes;
-            this.codeVerifier = config.codeVerifier || this.generateCodeVerifier();
-            this.state = config.state || this.generateState();
-        }
-        generateCodeVerifier() {
-            return crypto.randomBytes(32).toString('base64url');
-        }
-        generateState() {
-            return crypto.randomBytes(32).toString('base64url');
-        }
-        createCodeChallenge(codeVerifier) {
-            return crypto.createHash('sha256')
-                .update(codeVerifier)
-                .digest('base64url');
-        }
-        getAuthUrl() {
-            const codeChallenge = this.createCodeChallenge(this.codeVerifier);
-            const params = new URLSearchParams({
-                response_type: 'code',
-                client_id: this.keystring,
-                redirect_uri: this.redirectUri,
-                scope: this.scopes.join(' '),
-                state: this.state,
-                code_challenge: codeChallenge,
-                code_challenge_method: 'S256'
-            });
-            return `https://www.etsy.com/oauth/connect?${params.toString()}`;
-        }
-        setAuthorizationCode(code, state) {
-            if (state !== this.state) {
-                throw new EtsyAuthError('State parameter mismatch', 'INVALID_STATE');
-            }
-            this.authorizationCode = code;
-            this.receivedState = state;
-        }
-        async getAccessToken() {
-            if (!this.authorizationCode) {
-                throw new EtsyAuthError('Authorization code not set. Call setAuthorizationCode() first.', 'NO_AUTH_CODE');
-            }
-            const body = new URLSearchParams({
-                grant_type: 'authorization_code',
-                client_id: this.keystring,
-                redirect_uri: this.redirectUri,
-                code: this.authorizationCode,
-                code_verifier: this.codeVerifier
-            });
-            try {
-                const response = await this.fetch('https://api.etsy.com/v3/public/oauth/token', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded',
-                        'Accept': 'application/json'
-                    },
-                    body: body.toString()
-                });
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    throw new EtsyAuthError(`Token exchange failed: ${response.status} ${response.statusText} - ${errorText}`, 'TOKEN_EXCHANGE_FAILED');
-                }
-                const tokenResponse = await response.json();
-                return {
-                    access_token: tokenResponse.access_token,
-                    refresh_token: tokenResponse.refresh_token,
-                    expires_at: new Date(Date.now() + (tokenResponse.expires_in * 1000)),
-                    token_type: tokenResponse.token_type,
-                    scope: tokenResponse.scope
-                };
-            }
-            catch (error) {
-                if (error instanceof EtsyAuthError) {
-                    throw error;
-                }
-                throw new EtsyAuthError(`Token exchange failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'TOKEN_EXCHANGE_ERROR');
-            }
-        }
-        getState() {
-            return this.state;
-        }
-        getCodeVerifier() {
-            return this.codeVerifier;
-        }
-        getScopes() {
-            return [...this.scopes];
-        }
-        getRedirectUri() {
-            return this.redirectUri;
-        }
-        async fetch(url, options) {
-            if (typeof globalThis.fetch !== 'undefined') {
-                return globalThis.fetch(url, options);
-            }
-            try {
-                const { default: fetch } = await import('node-fetch');
-                return fetch(url, options);
-            }
-            catch (error) {
-                throw new EtsyAuthError('Fetch is not available. Please provide a fetch implementation or use Node.js 18+ or a modern browser.', 'FETCH_NOT_AVAILABLE');
-            }
-        }
-    }
-    const ETSY_SCOPES = {
-        LISTINGS_READ: 'listings_r',
-        SHOPS_READ: 'shops_r',
-        PROFILE_READ: 'profile_r',
-        FAVORITES_READ: 'favorites_r',
-        FEEDBACK_READ: 'feedback_r',
-        TREASURY_READ: 'treasury_r',
-        LISTINGS_WRITE: 'listings_w',
-        SHOPS_WRITE: 'shops_w',
-        PROFILE_WRITE: 'profile_w',
-        FAVORITES_WRITE: 'favorites_w',
-        FEEDBACK_WRITE: 'feedback_w',
-        TREASURY_WRITE: 'treasury_w',
-        LISTINGS_DELETE: 'listings_d',
-        SHOPS_DELETE: 'shops_d',
-        PROFILE_DELETE: 'profile_d',
-        FAVORITES_DELETE: 'favorites_d',
-        FEEDBACK_DELETE: 'feedback_d',
-        TREASURY_DELETE: 'treasury_d',
-        TRANSACTIONS_READ: 'transactions_r',
-        TRANSACTIONS_WRITE: 'transactions_w',
-        BILLING_READ: 'billing_r',
-        CART_READ: 'cart_r',
-        CART_WRITE: 'cart_w',
-        RECOMMEND_READ: 'recommend_r',
-        RECOMMEND_WRITE: 'recommend_w',
-        ADDRESS_READ: 'address_r',
-        ADDRESS_WRITE: 'address_w',
-        EMAIL_READ: 'email_r'
-    };
-    const COMMON_SCOPE_COMBINATIONS = {
-        SHOP_READ_ONLY: [
-            ETSY_SCOPES.SHOPS_READ,
-            ETSY_SCOPES.LISTINGS_READ,
-            ETSY_SCOPES.PROFILE_READ
-        ],
-        SHOP_MANAGEMENT: [
-            ETSY_SCOPES.SHOPS_READ,
-            ETSY_SCOPES.SHOPS_WRITE,
-            ETSY_SCOPES.LISTINGS_READ,
-            ETSY_SCOPES.LISTINGS_WRITE,
-            ETSY_SCOPES.LISTINGS_DELETE,
-            ETSY_SCOPES.PROFILE_READ,
-            ETSY_SCOPES.TRANSACTIONS_READ
-        ],
-        BASIC_ACCESS: [
-            ETSY_SCOPES.SHOPS_READ,
-            ETSY_SCOPES.LISTINGS_READ
-        ]
-    };
-
-    function calculateItemAge(whenMade) {
-        if (!whenMade)
-            return null;
-        const currentYear = new Date().getFullYear();
-        const whenMadeArray = Array.isArray(whenMade) ? whenMade : [whenMade];
-        let latestYear = null;
-        for (const period of whenMadeArray) {
-            const year = extractYearFromPeriod(period);
-            if (year && (!latestYear || year > latestYear)) {
-                latestYear = year;
-            }
-        }
-        return latestYear ? currentYear - latestYear : null;
-    }
-    function extractYearFromPeriod(period) {
-        const periodMappings = {
-            'before_1700': 1650,
-            '1700s': 1750,
-            '1800s': 1850,
-            '1900s': 1905,
-            '1910s': 1915,
-            '1920s': 1925,
-            '1930s': 1935,
-            '1940s': 1945,
-            '1950s': 1955,
-            '1960s': 1965,
-            '1970s': 1975,
-            '1980s': 1985,
-            '1990s': 1995,
-            '2000s': 2005,
-            '2010s': 2015,
-            '2020s': 2025
-        };
-        if (periodMappings[period]) {
-            return periodMappings[period];
-        }
-        const yearMatch = period.match(/(\d{4})/);
-        if (yearMatch) {
-            return parseInt(yearMatch[1], 10);
-        }
-        return null;
-    }
-    function classifyVintageOrAntique(whenMade) {
-        const age = calculateItemAge(whenMade);
-        if (!age)
-            return null;
-        if (age >= 100) {
-            return 'antique-prints';
-        }
-        else if (age >= 20) {
-            return 'vintage-prints';
-        }
-        return null;
-    }
-    function mapToEraSlug(whenMade) {
-        if (!whenMade)
-            return null;
-        const whenMadeArray = Array.isArray(whenMade) ? whenMade : [whenMade];
-        const eraMappings = {
-            'before_1700': 'pre-18th-century',
-            '1700s': '18th-century',
-            '1800s': '19th-century',
-            '1900s': 'early-20th-century',
-            '1910s': 'early-20th-century',
-            '1920s': 'early-20th-century',
-            '1930s': 'mid-20th-century',
-            '1940s': 'mid-20th-century',
-            '1950s': 'mid-20th-century',
-            '1960s': 'mid-20th-century',
-            '1970s': 'late-20th-century',
-            '1980s': 'late-20th-century',
-            '1990s': 'late-20th-century'
-        };
-        for (const period of [...whenMadeArray].reverse()) {
-            if (eraMappings[period]) {
-                return eraMappings[period];
-            }
-        }
-        return null;
-    }
-    function determineOrientation(product) {
-        const searchText = [
-            product.title,
-            product.description || '',
-            ...(product.tags || [])
-        ].join(' ').toLowerCase();
-        if (searchText.includes('portrait') || searchText.includes('vertical')) {
-            return 'portrait';
-        }
-        if (searchText.includes('landscape') || searchText.includes('horizontal')) {
-            return 'landscape';
-        }
-        return 'portrait';
-    }
-    function extractSize(product) {
-        if (product.item_length && product.item_width && product.item_dimensions_unit) {
-            const length = product.item_length;
-            const width = product.item_width;
-            const unit = product.item_dimensions_unit;
-            if (product.item_height && product.item_height > 0) {
-                return `${length} x ${width} x ${product.item_height} ${unit}`;
-            }
-            else {
-                return `${length} x ${width} ${unit}`;
-            }
-        }
-        const searchText = [product.title, product.description || ''].join(' ');
-        const sizePatterns = [
-            /(\d+\.?\d*\s*x\s*\d+\.?\d*\s*(?:in|inch|inches|cm|mm))/i,
-            /(A[0-9])/i,
-            /(letter|legal|tabloid)/i,
-            /(\d+\.?\d*"\s*x\s*\d+\.?\d*")/i
-        ];
-        for (const pattern of sizePatterns) {
-            const match = searchText.match(pattern);
-            if (match) {
-                return match[1].trim();
-            }
-        }
-        return null;
-    }
-    function classifyProduct(etsyProduct) {
-        const vintageAntique = classifyVintageOrAntique(etsyProduct.when_made);
-        if (!vintageAntique) {
-            return null;
-        }
-        const eraSlug = mapToEraSlug(etsyProduct.when_made);
-        const size = extractSize(etsyProduct);
-        return {
-            etsy_listing_id: etsyProduct.listing_id,
-            title: etsyProduct.title,
-            description: etsyProduct.description,
-            price: etsyProduct.price,
-            etsy_listing_url: etsyProduct.url,
-            size,
-            category_keyword: vintageAntique,
-            era_slug: eraSlug,
-            section_id: etsyProduct.shop_section_id,
-            orientation: null,
-            tags: etsyProduct.tags || [],
-            materials: etsyProduct.materials || [],
-            when_made: Array.isArray(etsyProduct.when_made)
-                ? etsyProduct.when_made.join(', ')
-                : etsyProduct.when_made,
-            classification_date: new Date().toISOString()
-        };
-    }
-    function classifyProducts(etsyProducts) {
-        return etsyProducts
-            .map(classifyProduct)
-            .filter((product) => product !== null);
-    }
-    function recalculateClassifications(products) {
-        return products.map(product => {
-            const newClassification = classifyVintageOrAntique(product.when_made);
-            const currentIsVintageAntique = ['vintage-prints', 'antique-prints'].includes(product.current_category);
-            const ageChanged = currentIsVintageAntique &&
-                newClassification &&
-                newClassification !== product.current_category;
-            return {
-                etsy_listing_id: product.etsy_listing_id,
-                new_category: newClassification,
-                age_changed: ageChanged
-            };
-        });
-    }
-    function validateClassification(product) {
-        const errors = [];
-        if (product.category_keyword === 'vintage-prints') {
-            const age = calculateItemAge(product.when_made);
-            if (age && age >= 100) {
-                errors.push('Product classified as vintage but is old enough to be antique');
-            }
-        }
-        if (product.category_keyword === 'antique-prints') {
-            const age = calculateItemAge(product.when_made);
-            if (age && age < 100) {
-                errors.push('Product classified as antique but is too recent');
-            }
-        }
-        if (!product.etsy_listing_id) {
-            errors.push('Missing required etsy_listing_id');
-        }
-        if (!product.title) {
-            errors.push('Missing required title');
-        }
-        if (product.price <= 0) {
-            errors.push('Price must be greater than 0');
-        }
-        return errors;
-    }
-    function getClassificationStats(products) {
-        const classified = classifyProducts(products);
-        const vintage = classified.filter(p => p.category_keyword === 'vintage-prints').length;
-        const antique = classified.filter(p => p.category_keyword === 'antique-prints').length;
-        const ages = products
-            .map(p => calculateItemAge(p.when_made))
-            .filter((age) => age !== null);
-        const averageAge = ages.length > 0
-            ? ages.reduce((sum, age) => sum + age, 0) / ages.length
-            : null;
-        return {
-            total: products.length,
-            classified: classified.length,
-            vintage,
-            antique,
-            unclassified: products.length - classified.length,
-            averageAge
-        };
-    }
-
-    const DEFAULT_ERA_MAPPINGS = [
-        {
-            id: 'pre-18th-century',
-            slug: 'pre-18th-century',
-            name: 'Pre-18th Century',
-            etsy_when_made: ['before_1700'],
-            start_year: 1000,
-            end_year: 1699,
-            description: 'Items from before 1700'
-        },
-        {
-            id: '18th-century',
-            slug: '18th-century',
-            name: '18th Century',
-            etsy_when_made: ['1700s'],
-            start_year: 1700,
-            end_year: 1799,
-            description: 'Items from the 1700s'
-        },
-        {
-            id: '19th-century',
-            slug: '19th-century',
-            name: '19th Century',
-            etsy_when_made: ['1800s'],
-            start_year: 1800,
-            end_year: 1899,
-            description: 'Items from the 1800s'
-        },
-        {
-            id: 'early-20th-century',
-            slug: 'early-20th-century',
-            name: 'Early 20th Century',
-            etsy_when_made: ['1900s', '1910s', '1920s'],
-            start_year: 1900,
-            end_year: 1929,
-            description: 'Items from 1900-1929'
-        },
-        {
-            id: 'mid-20th-century',
-            slug: 'mid-20th-century',
-            name: 'Mid 20th Century',
-            etsy_when_made: ['1930s', '1940s', '1950s', '1960s'],
-            start_year: 1930,
-            end_year: 1969,
-            description: 'Items from 1930-1969'
-        },
-        {
-            id: 'late-20th-century',
-            slug: 'late-20th-century',
-            name: 'Late 20th Century',
-            etsy_when_made: ['1970s', '1980s', '1990s'],
-            start_year: 1970,
-            end_year: 1999,
-            description: 'Items from 1970-1999'
-        }
-    ];
-    class EraMapper {
-        constructor(customMappings) {
-            this.mappings = customMappings || DEFAULT_ERA_MAPPINGS;
-        }
-        getEraIdFromEtsyWhenMade(etsyWhenMade) {
-            for (const mapping of this.mappings) {
-                if (mapping.etsy_when_made.includes(etsyWhenMade)) {
-                    return mapping.id;
-                }
-            }
-            return null;
-        }
-        getEraSlugFromEtsyWhenMade(etsyWhenMade) {
-            for (const mapping of this.mappings) {
-                if (mapping.etsy_when_made.includes(etsyWhenMade)) {
-                    return mapping.slug;
-                }
-            }
-            return null;
-        }
-        getEraNameFromEtsyWhenMade(etsyWhenMade) {
-            for (const mapping of this.mappings) {
-                if (mapping.etsy_when_made.includes(etsyWhenMade)) {
-                    return mapping.name;
-                }
-            }
-            return null;
-        }
-        getEraById(id) {
-            return this.mappings.find(mapping => mapping.id === id) || null;
-        }
-        getEraBySlug(slug) {
-            return this.mappings.find(mapping => mapping.slug === slug) || null;
-        }
-        getAllEras() {
-            return [...this.mappings];
-        }
-        getErasFromMultipleEtsyWhenMade(etsyWhenMadeValues) {
-            const matchingEras = new Set();
-            for (const etsyWhenMade of etsyWhenMadeValues) {
-                for (const mapping of this.mappings) {
-                    if (mapping.etsy_when_made.includes(etsyWhenMade)) {
-                        matchingEras.add(mapping);
-                    }
-                }
-            }
-            return Array.from(matchingEras);
-        }
-        getMostSpecificEra(etsyWhenMadeValues) {
-            const matchingEras = this.getErasFromMultipleEtsyWhenMade(etsyWhenMadeValues);
-            if (matchingEras.length === 0) {
-                return null;
-            }
-            matchingEras.sort((a, b) => (b.start_year || 0) - (a.start_year || 0));
-            return matchingEras[0];
-        }
-        addEraMapping(mapping) {
-            this.mappings.push(mapping);
-        }
-        updateEraMapping(id, updates) {
-            const index = this.mappings.findIndex(mapping => mapping.id === id);
-            if (index === -1) {
-                return false;
-            }
-            this.mappings[index] = { ...this.mappings[index], ...updates };
-            return true;
-        }
-        removeEraMapping(id) {
-            const index = this.mappings.findIndex(mapping => mapping.id === id);
-            if (index === -1) {
-                return false;
-            }
-            this.mappings.splice(index, 1);
-            return true;
-        }
-        validateEraMapping(mapping) {
-            const errors = [];
-            if (!mapping.id) {
-                errors.push('Era mapping must have an ID');
-            }
-            if (!mapping.slug) {
-                errors.push('Era mapping must have a slug');
-            }
-            if (!mapping.name) {
-                errors.push('Era mapping must have a name');
-            }
-            if (!mapping.etsy_when_made || mapping.etsy_when_made.length === 0) {
-                errors.push('Era mapping must have at least one Etsy when_made value');
-            }
-            for (const etsyWhenMade of mapping.etsy_when_made) {
-                if (!ETSY_WHEN_MADE_VALUES.includes(etsyWhenMade)) {
-                    errors.push(`Invalid Etsy when_made value: ${etsyWhenMade}`);
-                }
-            }
-            if (mapping.start_year && mapping.end_year && mapping.start_year > mapping.end_year) {
-                errors.push('Start year cannot be greater than end year');
-            }
-            return errors;
-        }
-        getEraStatistics() {
-            const coveredEtsyValues = new Set();
-            let erasWithYears = 0;
-            for (const mapping of this.mappings) {
-                if (mapping.start_year && mapping.end_year) {
-                    erasWithYears++;
-                }
-                for (const etsyWhenMade of mapping.etsy_when_made) {
-                    coveredEtsyValues.add(etsyWhenMade);
-                }
-            }
-            const uncoveredEtsyValues = ETSY_WHEN_MADE_VALUES.filter(value => !coveredEtsyValues.has(value));
-            return {
-                total_eras: this.mappings.length,
-                eras_with_years: erasWithYears,
-                covered_etsy_values: coveredEtsyValues.size,
-                uncovered_etsy_values: uncoveredEtsyValues
-            };
-        }
-    }
-    const defaultEraMapper = new EraMapper();
-    function getEraIdFromEtsyWhenMade(etsyWhenMade) {
-        return defaultEraMapper.getEraIdFromEtsyWhenMade(etsyWhenMade);
-    }
-    function getEraSlugFromEtsyWhenMade(etsyWhenMade) {
-        return defaultEraMapper.getEraSlugFromEtsyWhenMade(etsyWhenMade);
-    }
-    function getAllErasWithEtsyMapping() {
-        return defaultEraMapper.getAllEras();
-    }
-
-    function createEtsyClient(config) {
-        return new EtsyClient(config);
-    }
-    function createAuthHelper(config) {
-        return new AuthHelper(config);
-    }
-    function createTokenManager(config, storage) {
-        return new TokenManager(config, storage);
-    }
-    function createRateLimiter(config) {
-        return new EtsyRateLimiter(config);
-    }
-    function createEraMapper(customMappings) {
-        return new EraMapper(customMappings);
-    }
-    const VERSION = '1.0.0';
-    const LIBRARY_NAME = 'etsy-v3-api-client';
-    function getLibraryInfo() {
-        return {
-            name: LIBRARY_NAME,
-            version: VERSION,
-            description: 'JavaScript/TypeScript client for the Etsy Open API v3 with OAuth 2.0 authentication and product classification utilities',
-            author: 'Henry',
-            license: 'MIT',
-            homepage: 'https://github.com/ForestHillArtsHouse/etsy-v3-api-client#readme'
-        };
-    }
-
-    exports.AuthHelper = AuthHelper;
-    exports.COMMON_SCOPE_COMBINATIONS = COMMON_SCOPE_COMBINATIONS;
-    exports.DEFAULT_ERA_MAPPINGS = DEFAULT_ERA_MAPPINGS;
-    exports.ETSY_SCOPES = ETSY_SCOPES;
-    exports.ETSY_WHEN_MADE_VALUES = ETSY_WHEN_MADE_VALUES;
-    exports.EraMapper = EraMapper;
-    exports.EtsyApiError = EtsyApiError;
-    exports.EtsyAuthError = EtsyAuthError;
-    exports.EtsyClient = EtsyClient;
-    exports.EtsyRateLimitError = EtsyRateLimitError;
-    exports.EtsyRateLimiter = EtsyRateLimiter;
-    exports.FileTokenStorage = FileTokenStorage;
-    exports.LIBRARY_NAME = LIBRARY_NAME;
-    exports.MemoryTokenStorage = MemoryTokenStorage;
-    exports.TokenManager = TokenManager;
-    exports.VERSION = VERSION;
-    exports.calculateItemAge = calculateItemAge;
-    exports.classifyProduct = classifyProduct;
-    exports.classifyProducts = classifyProducts;
-    exports.classifyVintageOrAntique = classifyVintageOrAntique;
-    exports.createAuthHelper = createAuthHelper;
-    exports.createEraMapper = createEraMapper;
-    exports.createEtsyClient = createEtsyClient;
-    exports.createRateLimiter = createRateLimiter;
-    exports.createTokenManager = createTokenManager;
-    exports.default = EtsyClient;
-    exports.defaultEraMapper = defaultEraMapper;
-    exports.defaultRateLimiter = defaultRateLimiter;
-    exports.determineOrientation = determineOrientation;
-    exports.extractSize = extractSize;
-    exports.extractYearFromPeriod = extractYearFromPeriod;
-    exports.getAllErasWithEtsyMapping = getAllErasWithEtsyMapping;
-    exports.getClassificationStats = getClassificationStats;
-    exports.getEraIdFromEtsyWhenMade = getEraIdFromEtsyWhenMade;
-    exports.getEraSlugFromEtsyWhenMade = getEraSlugFromEtsyWhenMade;
-    exports.getLibraryInfo = getLibraryInfo;
-    exports.mapToEraSlug = mapToEraSlug;
-    exports.recalculateClassifications = recalculateClassifications;
-    exports.validateClassification = validateClassification;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=index.umd.js.map