@kupola/kupola 1.2.0

package/js/http.js

@@ -0,0 +1,419 @@
+class KupolaHttp {
+  constructor(options = {}) {
+    this.baseURL = options.baseURL || '';
+    this.timeout = options.timeout || 30000;
+    this.headers = options.headers || {};
+    this.cache = new Map();
+    this.cacheTTL = options.cacheTTL || 60000;
+    this.maxRetries = options.maxRetries || 0;
+    this.retryDelay = options.retryDelay || 1000;
+    this.activeRequests = new Map();
+    this.withCredentials = options.withCredentials || false;
+
+    this._useAxios = typeof axios !== 'undefined';
+    if (this._useAxios) {
+      this._initAxios(options);
+    }
+    
+    if (options.interceptors) {
+      this.interceptors = options.interceptors;
+    }
+  }
+
+  _initAxios(options) {
+    this.axios = axios.create({
+      baseURL: this.baseURL,
+      timeout: this.timeout,
+      headers: this.headers
+    });
+    
+    this.axios.defaults.withCredentials = options.withCredentials || false;
+  }
+
+  _generateCacheKey(config) {
+    const { url, method = 'GET', params = {}, data = null } = config;
+    const query = params ? new URLSearchParams(params).toString() : '';
+    const dataKey = data ? JSON.stringify(data) : '';
+    return `${method}:${url}:${query}:${dataKey}`;
+  }
+
+  _getCache(key) {
+    const cached = this.cache.get(key);
+    if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
+      return cached.data;
+    }
+    this.cache.delete(key);
+    return null;
+  }
+
+  _setCache(key, data) {
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+
+  async _requestWithRetry(config, retryCount = 0) {
+    try {
+      return await this._request(config);
+    } catch (error) {
+      if (retryCount < this.maxRetries) {
+        await new Promise(resolve => setTimeout(resolve, this.retryDelay * Math.pow(2, retryCount)));
+        return this._requestWithRetry(config, retryCount + 1);
+      }
+      throw error;
+    }
+  }
+
+  async _request(config) {
+    const { 
+      url, 
+      method = 'GET', 
+      headers = {}, 
+      params = {}, 
+      data = null, 
+      timeout = this.timeout,
+      cache = false
+    } = config;
+
+    const cacheKey = this._generateCacheKey({ url, method, params, data });
+    
+    if (cache && method === 'GET') {
+      const cached = this._getCache(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+
+    const controller = new AbortController();
+    this.activeRequests.set(cacheKey, controller);
+
+    const requestHeaders = { ...this.headers, ...headers };
+    
+    if (!requestHeaders['Content-Type'] && data && !(data instanceof FormData)) {
+      requestHeaders['Content-Type'] = 'application/json';
+    }
+
+    let requestConfig = {
+      url: this.baseURL ? new URL(url, this.baseURL).toString() : url,
+      method,
+      headers: requestHeaders,
+      signal: controller.signal,
+      credentials: this.withCredentials ? 'include' : 'same-origin'
+    };
+
+    if (Object.keys(params).length > 0) {
+      const urlObj = new URL(requestConfig.url);
+      Object.keys(params).forEach(key => {
+        urlObj.searchParams.append(key, params[key]);
+      });
+      requestConfig.url = urlObj.toString();
+    }
+
+    if (data !== null) {
+      requestConfig.body = data instanceof FormData ? data : JSON.stringify(data);
+    }
+
+    if (this.interceptors && this.interceptors.request) {
+      try {
+        const intercepted = await this.interceptors.request(requestConfig);
+        if (intercepted) requestConfig = intercepted;
+      } catch (error) {
+        this.activeRequests.delete(cacheKey);
+        if (this.interceptors.requestError) {
+          return this.interceptors.requestError(error);
+        }
+        throw error;
+      }
+    }
+
+    try {
+      let response;
+      if (this._useAxios) {
+        const axiosConfig = {
+          url: requestConfig.url.replace(this.baseURL, ''),
+          method: requestConfig.method,
+          headers: requestConfig.headers,
+          signal: requestConfig.signal,
+          timeout
+        };
+        if (data !== null) axiosConfig.data = data;
+        if (params && Object.keys(params).length > 0) axiosConfig.params = params;
+        
+        response = await this.axios(axiosConfig);
+      } else {
+        response = await this._fetchWithTimeout(requestConfig, timeout);
+        
+        if (!response.ok) {
+          const error = new Error(`HTTP error! status: ${response.status}`);
+          error.status = response.status;
+          error.statusText = response.statusText;
+          throw error;
+        }
+      }
+      
+      const result = {
+        data: this._useAxios ? response.data : await this._parseResponse(response),
+        status: this._useAxios ? response.status : response.status,
+        statusText: this._useAxios ? response.statusText : response.statusText,
+        headers: this._useAxios ? response.headers : this._parseHeaders(response.headers),
+        config: requestConfig
+      };
+      
+      if (this.interceptors && this.interceptors.response) {
+        return this.interceptors.response(result);
+      }
+      
+      if (cache && method === 'GET') {
+        this._setCache(cacheKey, result);
+      }
+      
+      return result;
+    } catch (error) {
+      if (error.name === 'AbortError' || (this._useAxios && error.code === 'ERR_CANCELED')) {
+        return null;
+      }
+      if (this.interceptors && this.interceptors.responseError) {
+        return this.interceptors.responseError(error);
+      }
+      throw error;
+    } finally {
+      this.activeRequests.delete(cacheKey);
+    }
+  }
+
+  async _fetchWithTimeout(config, timeout) {
+    const controller = new AbortController();
+    const signal = controller.signal;
+    
+    const timeoutPromise = new Promise((_, reject) => {
+      const timerId = setTimeout(() => {
+        controller.abort();
+        reject(new Error('Request timeout'));
+      }, timeout);
+      
+      signal.addEventListener('abort', () => {
+        clearTimeout(timerId);
+      });
+    });
+    
+    const fetchPromise = fetch({ ...config, signal });
+    
+    return Promise.race([fetchPromise, timeoutPromise]);
+  }
+
+  async _parseResponse(response) {
+    const contentType = response.headers.get('content-type');
+    if (contentType && contentType.includes('application/json')) {
+      return response.json();
+    }
+    return response.text();
+  }
+
+  _parseHeaders(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+
+  cancelRequest(url, params = {}, method = 'GET', data = null) {
+    const cacheKey = this._generateCacheKey({ url, method, params, data });
+    if (this.activeRequests.has(cacheKey)) {
+      this.activeRequests.get(cacheKey).abort();
+      this.activeRequests.delete(cacheKey);
+      return true;
+    }
+    return false;
+  }
+
+  cancelAllRequests() {
+    this.activeRequests.forEach((controller) => {
+      controller.abort();
+    });
+    this.activeRequests.clear();
+  }
+
+  clearCache() {
+    this.cache.clear();
+  }
+
+  clearCacheByUrl(url) {
+    this.cache.forEach((_, key) => {
+      if (key.startsWith(`GET:${url}`)) {
+        this.cache.delete(key);
+      }
+    });
+  }
+
+  get(url, config = {}) {
+    const useCache = config.cache ?? true;
+    const useRetry = config.retry ?? this.maxRetries > 0;
+    
+    const requestConfig = { ...config, url, method: 'GET', cache: useCache };
+    
+    if (useRetry) {
+      return this._requestWithRetry(requestConfig);
+    }
+    return this._request(requestConfig);
+  }
+
+  post(url, data = null, config = {}) {
+    const useRetry = config.retry ?? this.maxRetries > 0;
+    const requestConfig = { ...config, url, method: 'POST', data, cache: false };
+    
+    if (useRetry) {
+      return this._requestWithRetry(requestConfig);
+    }
+    return this._request(requestConfig);
+  }
+
+  async uploadFile(url, file, options = {}) {
+    const {
+      chunkSize = 2 * 1024 * 1024,
+      onProgress,
+      headers = {},
+      parallel = false
+    } = options;
+
+    const totalChunks = Math.ceil(file.size / chunkSize);
+    let uploadedChunks = 0;
+    let progress = 0;
+
+    const fileId = this._generateFileId(file);
+
+    if (parallel) {
+      const promises = [];
+      for (let i = 0; i < totalChunks; i++) {
+        const promise = this._uploadChunk(url, file, i, totalChunks, chunkSize, fileId, headers)
+          .then(() => {
+            uploadedChunks++;
+            progress = Math.round((uploadedChunks / totalChunks) * 100);
+            
+            if (onProgress) {
+              onProgress({
+                progress,
+                uploaded: uploadedChunks * chunkSize,
+                total: file.size,
+                currentChunk: uploadedChunks,
+                totalChunks
+              });
+            }
+          });
+        promises.push(promise);
+      }
+      await Promise.all(promises);
+      return this._completeUpload(url, fileId, totalChunks, file.name);
+    }
+
+    for (let i = 0; i < totalChunks; i++) {
+      await this._uploadChunk(url, file, i, totalChunks, chunkSize, fileId, headers);
+      
+      uploadedChunks++;
+      progress = Math.round((uploadedChunks / totalChunks) * 100);
+      
+      if (onProgress) {
+        onProgress({
+          progress,
+          uploaded: uploadedChunks * chunkSize,
+          total: file.size,
+          currentChunk: i + 1,
+          totalChunks
+        });
+      }
+    }
+
+    return this._completeUpload(url, fileId, totalChunks, file.name);
+  }
+
+  async _uploadChunk(url, file, chunkIndex, totalChunks, chunkSize, fileId, headers) {
+    const start = chunkIndex * chunkSize;
+    const end = Math.min(start + chunkSize, file.size);
+    const chunk = file.slice(start, end);
+
+    const formData = new FormData();
+    formData.append('chunk', chunk);
+    formData.append('chunkIndex', chunkIndex);
+    formData.append('totalChunks', totalChunks);
+    formData.append('fileId', fileId);
+    formData.append('fileName', file.name);
+    formData.append('fileSize', file.size);
+
+    return this.post(`${url}/chunk`, formData, { headers });
+  }
+
+  async _completeUpload(url, fileId, totalChunks, fileName) {
+    return this.post(`${url}/complete`, { fileId, totalChunks, fileName });
+  }
+
+  _generateFileId(file) {
+    const hash = `${file.name}-${file.size}-${file.lastModified}`;
+    let result = 0;
+    for (let i = 0; i < hash.length; i++) {
+      result = ((result << 5) - result) + hash.charCodeAt(i);
+      result |= 0;
+    }
+    return Math.abs(result).toString(36) + Date.now().toString(36);
+  }
+
+  put(url, data = null, config = {}) {
+    const useRetry = config.retry ?? this.maxRetries > 0;
+    const requestConfig = { ...config, url, method: 'PUT', data, cache: false };
+    
+    if (useRetry) {
+      return this._requestWithRetry(requestConfig);
+    }
+    return this._request(requestConfig);
+  }
+
+  delete(url, config = {}) {
+    const useRetry = config.retry ?? this.maxRetries > 0;
+    const requestConfig = { ...config, url, method: 'DELETE', cache: false };
+    
+    if (useRetry) {
+      return this._requestWithRetry(requestConfig);
+    }
+    return this._request(requestConfig);
+  }
+
+  patch(url, data = null, config = {}) {
+    const useRetry = config.retry ?? this.maxRetries > 0;
+    const requestConfig = { ...config, url, method: 'PATCH', data, cache: false };
+    
+    if (useRetry) {
+      return this._requestWithRetry(requestConfig);
+    }
+    return this._request(requestConfig);
+  }
+
+  setHeader(name, value) {
+    this.headers[name] = value;
+    if (this.axios) {
+      this.axios.defaults.headers.common[name] = value;
+    }
+  }
+
+  setToken(token, type = 'Bearer') {
+    this.headers['Authorization'] = `${type} ${token}`;
+    if (this.axios) {
+      this.axios.defaults.headers.common['Authorization'] = `${type} ${token}`;
+    }
+  }
+
+  setCacheTTL(ttl) {
+    this.cacheTTL = ttl;
+  }
+
+  setMaxRetries(retries) {
+    this.maxRetries = retries;
+  }
+}
+
+function createHttp(options) {
+  return new KupolaHttp(options);
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { KupolaHttp, createHttp };
+} else {
+  window.KupolaHttp = KupolaHttp;
+  window.createHttp = createHttp;
+}

package/js/i18n.js

@@ -0,0 +1,228 @@
+class KupolaI18n {
+  constructor(options = {}) {
+    this.locales = options.locales || {};
+    this.currentLocale = options.defaultLocale || 'zh-CN';
+    this.fallbackLocale = options.fallbackLocale || 'zh-CN';
+    this.delimiter = options.delimiter || '.';
+    this.missingHandler = options.missingHandler || ((key) => {
+      console.warn(`Missing translation: ${key}`);
+      return key;
+    });
+    
+    this._initFromDOM();
+  }
+
+  _initFromDOM() {
+    const scriptTags = document.querySelectorAll('script[type="application/json"][data-kupola-i18n]');
+    scriptTags.forEach(script => {
+      const locale = script.dataset.kupolaI18n;
+      if (locale) {
+        try {
+          const data = JSON.parse(script.textContent);
+          this.addLocale(locale, data);
+        } catch (e) {
+          console.error('Failed to parse i18n data:', e);
+        }
+      }
+    });
+
+    const htmlLang = document.documentElement.lang;
+    if (htmlLang && this.locales[htmlLang]) {
+      this.currentLocale = htmlLang;
+    }
+  }
+
+  addLocale(locale, data) {
+    if (!this.locales[locale]) {
+      this.locales[locale] = {};
+    }
+    this._mergeDeep(this.locales[locale], data);
+  }
+
+  _mergeDeep(target, source) {
+    for (const key of Object.keys(source)) {
+      if (source[key] instanceof Object && key in target) {
+        this._mergeDeep(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    }
+  }
+
+  setLocale(locale) {
+    if (this.locales[locale]) {
+      this.currentLocale = locale;
+      document.documentElement.lang = locale;
+      this._emitChange();
+      return true;
+    }
+    return false;
+  }
+
+  getLocale() {
+    return this.currentLocale;
+  }
+
+  t(key, params = {}) {
+    let value = this._getTranslation(key, this.currentLocale);
+    
+    if (!value) {
+      value = this._getTranslation(key, this.fallbackLocale);
+    }
+    
+    if (!value) {
+      return this.missingHandler(key);
+    }
+    
+    return this._interpolate(value, params);
+  }
+
+  _getTranslation(key, locale) {
+    if (!this.locales[locale]) return null;
+    
+    const keys = key.split(this.delimiter);
+    let value = this.locales[locale];
+    
+    for (const k of keys) {
+      if (value && typeof value === 'object' && k in value) {
+        value = value[k];
+      } else {
+        return null;
+      }
+    }
+    
+    return typeof value === 'string' ? value : null;
+  }
+
+  _interpolate(str, params) {
+    return str.replace(/\{(\w+)\}/g, (match, key) => {
+      return params[key] !== undefined ? params[key] : match;
+    });
+  }
+
+  n(key, count, params = {}) {
+    const value = this.t(key, { ...params, count });
+    
+    if (!value) return value;
+    
+    const parts = value.split('|');
+    
+    if (parts.length === 1) {
+      return value.replace('{count}', count);
+    }
+    
+    if (parts.length === 2) {
+      return count === 1 ? parts[0] : parts[1];
+    }
+    
+    if (parts.length >= 3) {
+      if (count === 0) return parts[0];
+      if (count === 1) return parts[1];
+      return parts[2];
+    }
+    
+    return value;
+  }
+
+  _emitChange() {
+    const event = new CustomEvent('kupola:i18n:change', {
+      detail: { locale: this.currentLocale },
+      bubbles: true
+    });
+    document.dispatchEvent(event);
+  }
+
+  async loadLocale(locale, url) {
+    try {
+      const response = await fetch(url);
+      const data = await response.json();
+      this.addLocale(locale, data);
+      return true;
+    } catch (error) {
+      console.error('Failed to load locale:', error);
+      return false;
+    }
+  }
+
+  getAvailableLocales() {
+    return Object.keys(this.locales);
+  }
+
+  hasLocale(locale) {
+    return !!this.locales[locale];
+  }
+
+  formatDate(date, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    const dateObj = typeof date === 'string' ? new Date(date) : date;
+    
+    return new Intl.DateTimeFormat(locale, options).format(dateObj);
+  }
+
+  formatNumber(number, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    
+    return new Intl.NumberFormat(locale, options).format(number);
+  }
+
+  formatCurrency(number, currency, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    
+    return new Intl.NumberFormat(locale, {
+      style: 'currency',
+      currency,
+      ...options
+    }).format(number);
+  }
+
+  formatRelativeTime(value, unit, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    
+    return new Intl.RelativeTimeFormat(locale, options).format(value, unit);
+  }
+}
+
+const kupolaI18n = new KupolaI18n();
+
+function createI18n(options) {
+  return new KupolaI18n(options);
+}
+
+function t(key, params = {}) {
+  return kupolaI18n.t(key, params);
+}
+
+function n(key, count, params = {}) {
+  return kupolaI18n.n(key, count, params);
+}
+
+function setLocale(locale) {
+  return kupolaI18n.setLocale(locale);
+}
+
+function getLocale() {
+  return kupolaI18n.getLocale();
+}
+
+function formatDate(date, options = {}) {
+  return kupolaI18n.formatDate(date, options);
+}
+
+function formatNumber(number, options = {}) {
+  return kupolaI18n.formatNumber(number, options);
+}
+
+function formatCurrency(number, currency, options = {}) {
+  return kupolaI18n.formatCurrency(number, currency, options);
+}
+
+window.KupolaI18n = KupolaI18n;
+window.kupolaI18n = kupolaI18n;
+window.createI18n = createI18n;
+window.t = t;
+window.n = n;
+window.setLocale = setLocale;
+window.getLocale = getLocale;
+window.formatDate = formatDate;
+window.formatNumber = formatNumber;
+window.formatCurrency = formatCurrency;