@alibarbar/common 1.0.8 → 1.0.10

package/dist/{chunk-4RGXV4SJ.js → network.cjs}

@@ -102,5 +102,3 @@ exports.downloadFile = downloadFile;
 exports.fetchWithRetry = fetchWithRetry;
 exports.fetchWithTimeout = fetchWithTimeout;
 exports.request = request;
-//# sourceMappingURL=chunk-4RGXV4SJ.js.map
-//# sourceMappingURL=chunk-4RGXV4SJ.js.map

package/dist/network.js

@@ -1,29 +1,98 @@
-'use strict';
+// src/browser/network.ts
+async function fetchWithRetry(url, options = {}, retryCount = 3, retryDelay = 1e3) {
+  let lastError = null;
+  for (let i = 0; i <= retryCount; i++) {
+    try {
+      const response = await fetch(url, options);
+      if (response.ok) {
+        return response;
+      }
+      if (i < retryCount) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        continue;
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i < retryCount) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      }
+    }
+  }
+  throw lastError || new Error("Fetch failed after retries");
+}
+async function fetchWithTimeout(url, options = {}, timeout = 5e3) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timeout after ${timeout}ms`);
+    }
+    throw error;
+  }
+}
+async function downloadFile(url, filename) {
+  if (typeof window === "undefined") {
+    throw new Error("downloadFile is only available in browser environment");
+  }
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download file: ${response.statusText}`);
+    }
+    const blob = await response.blob();
+    const downloadUrl = window.URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = downloadUrl;
+    link.download = filename || url.split("/").pop() || "download";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    window.URL.revokeObjectURL(downloadUrl);
+  } catch (error) {
+    throw error instanceof Error ? error : new Error(String(error));
+  }
+}
+function checkOnline() {
+  if (typeof navigator === "undefined") return true;
+  return navigator.onLine;
+}
+async function request(url, options = {}) {
+  const { method = "GET", headers = {}, body, timeout, retry = 0 } = options;
+  const fetchOptions = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    }
+  };
+  if (body) {
+    fetchOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+  }
+  let fetchFn = fetch;
+  if (timeout) {
+    fetchFn = (url2, opts) => fetchWithTimeout(url2, opts, timeout);
+  }
+  if (retry > 0) {
+    fetchFn = (url2, opts) => fetchWithRetry(url2, opts, retry);
+  }
+  const response = await fetchFn(url, fetchOptions);
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  const contentType = response.headers.get("content-type");
+  if (contentType && contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
 
-var chunk4RGXV4SJ_js = require('./chunk-4RGXV4SJ.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "checkOnline", {
-  enumerable: true,
-  get: function () { return chunk4RGXV4SJ_js.checkOnline; }
-});
-Object.defineProperty(exports, "downloadFile", {
-  enumerable: true,
-  get: function () { return chunk4RGXV4SJ_js.downloadFile; }
-});
-Object.defineProperty(exports, "fetchWithRetry", {
-  enumerable: true,
-  get: function () { return chunk4RGXV4SJ_js.fetchWithRetry; }
-});
-Object.defineProperty(exports, "fetchWithTimeout", {
-  enumerable: true,
-  get: function () { return chunk4RGXV4SJ_js.fetchWithTimeout; }
-});
-Object.defineProperty(exports, "request", {
-  enumerable: true,
-  get: function () { return chunk4RGXV4SJ_js.request; }
-});
-//# sourceMappingURL=network.js.map
-//# sourceMappingURL=network.js.map
+export { checkOnline, downloadFile, fetchWithRetry, fetchWithTimeout, request };

package/dist/{chunk-3FRYJPHG.js → number.cjs}

@@ -89,5 +89,3 @@ exports.percent = percent;
 exports.random = random;
 exports.round = round;
 exports.toFixed = toFixed;
-//# sourceMappingURL=chunk-3FRYJPHG.js.map
-//# sourceMappingURL=chunk-3FRYJPHG.js.map

package/dist/number.js

@@ -1,57 +1,78 @@
-'use strict';
+// src/format/number.ts
+function formatNumber(num, options = {}) {
+  const { decimals, separator = ",", decimalPoint = ".", minimumFractionDigits } = options;
+  let numStr;
+  if (decimals !== void 0) {
+    numStr = num.toFixed(decimals);
+  } else if (minimumFractionDigits !== void 0) {
+    numStr = num.toFixed(minimumFractionDigits);
+  } else {
+    const str = num.toString();
+    if (str.includes(".")) {
+      numStr = str;
+    } else {
+      numStr = num.toFixed(0);
+    }
+  }
+  const parts = numStr.split(".");
+  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  return parts.join(decimalPoint);
+}
+function random(min, max, integer = false) {
+  const value = Math.random() * (max - min) + min;
+  return integer ? Math.floor(value) : value;
+}
+function clamp(num, min, max) {
+  return Math.min(Math.max(num, min), max);
+}
+function round(num, decimals = 0) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(num * factor) / factor;
+}
+function floor(num, decimals = 0) {
+  const factor = Math.pow(10, decimals);
+  return Math.floor(num * factor) / factor;
+}
+function ceil(num, decimals = 0) {
+  const factor = Math.pow(10, decimals);
+  return Math.ceil(num * factor) / factor;
+}
+function toFixed(num, decimals) {
+  return num.toFixed(decimals);
+}
+function parseNumber(str, defaultValue = 0) {
+  const num = Number(str);
+  return isNaN(num) ? defaultValue : num;
+}
+function isBetween(num, min, max, inclusive = true) {
+  if (inclusive) {
+    return num >= min && num <= max;
+  }
+  return num > min && num < max;
+}
+function percent(value, decimalsOrTotal, decimals) {
+  if (value >= 0 && value <= 1 && (decimalsOrTotal === void 0 || decimalsOrTotal < 10)) {
+    const dec2 = decimalsOrTotal ?? 0;
+    return Number((value * 100).toFixed(dec2));
+  }
+  if (decimalsOrTotal !== void 0 && decimalsOrTotal >= 10) {
+    const total = decimalsOrTotal;
+    const dec2 = decimals ?? 2;
+    if (total === 0) return "0%";
+    return `${(value / total * 100).toFixed(dec2)}%`;
+  }
+  const dec = decimalsOrTotal ?? 0;
+  return Number((value * 100).toFixed(dec));
+}
+function formatCurrency(num, currency = "\xA5", decimals = 2) {
+  return `${currency}${formatNumber(num, { decimals, separator: "," })}`;
+}
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
 
-var chunk3FRYJPHG_js = require('./chunk-3FRYJPHG.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "ceil", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.ceil; }
-});
-Object.defineProperty(exports, "clamp", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.clamp; }
-});
-Object.defineProperty(exports, "floor", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.floor; }
-});
-Object.defineProperty(exports, "formatBytes", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.formatBytes; }
-});
-Object.defineProperty(exports, "formatCurrency", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.formatCurrency; }
-});
-Object.defineProperty(exports, "formatNumber", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.formatNumber; }
-});
-Object.defineProperty(exports, "isBetween", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.isBetween; }
-});
-Object.defineProperty(exports, "parseNumber", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.parseNumber; }
-});
-Object.defineProperty(exports, "percent", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.percent; }
-});
-Object.defineProperty(exports, "random", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.random; }
-});
-Object.defineProperty(exports, "round", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.round; }
-});
-Object.defineProperty(exports, "toFixed", {
-  enumerable: true,
-  get: function () { return chunk3FRYJPHG_js.toFixed; }
-});
-//# sourceMappingURL=number.js.map
-//# sourceMappingURL=number.js.map
+export { ceil, clamp, floor, formatBytes, formatCurrency, formatNumber, isBetween, parseNumber, percent, random, round, toFixed };

package/dist/{chunk-27UDDVLZ.js → object.cjs}

@@ -255,5 +255,3 @@ exports.pickBy = pickBy;
 exports.set = set;
 exports.transform = transform;
 exports.values = values;
-//# sourceMappingURL=chunk-27UDDVLZ.js.map
-//# sourceMappingURL=chunk-27UDDVLZ.js.map

package/dist/object.js

@@ -1,81 +1,238 @@
-'use strict';
+// src/core/object.ts
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  if (typeof obj === "object") {
+    const clonedObj = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        clonedObj[key] = deepClone(obj[key]);
+      }
+    }
+    return clonedObj;
+  }
+  return obj;
+}
+function merge(target, ...sources) {
+  return Object.assign({}, target, ...sources);
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (!source) {
+    return deepMerge(target, ...sources);
+  }
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (isObject(sourceValue) && isObject(targetValue)) {
+          target[key] = deepMerge(
+            targetValue,
+            sourceValue
+          );
+        } else if (sourceValue !== void 0) {
+          target[key] = sourceValue;
+        }
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+function isObject(item) {
+  return item !== null && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && !(item instanceof RegExp) && !(item instanceof Map) && !(item instanceof Set);
+}
+function get(obj, path, defaultValue) {
+  if (!obj || typeof obj !== "object") {
+    return defaultValue;
+  }
+  const keys2 = Array.isArray(path) ? path : path.split(".");
+  if (keys2.length === 0) {
+    return defaultValue;
+  }
+  let result = obj;
+  for (const key of keys2) {
+    if (result == null || typeof result !== "object" || Array.isArray(result)) {
+      return defaultValue;
+    }
+    const record = result;
+    if (!(key in record)) {
+      return defaultValue;
+    }
+    result = record[key];
+  }
+  return result !== void 0 ? result : defaultValue;
+}
+function set(obj, path, value) {
+  const keys2 = Array.isArray(path) ? path : path.split(".");
+  if (keys2.length === 0) return obj;
+  const result = deepClone(obj);
+  let current = result;
+  for (let i = 0; i < keys2.length - 1; i++) {
+    const key = keys2[i];
+    if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys2[keys2.length - 1]] = value;
+  return result;
+}
+function pick(obj, keys2) {
+  const result = {};
+  keys2.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+function omit(obj, keys2) {
+  const result = { ...obj };
+  keys2.forEach((key) => {
+    delete result[key];
+  });
+  return result;
+}
+function keys(obj, deep = false) {
+  if (!deep) return Object.keys(obj);
+  const result = [];
+  const traverse = (current, prefix = "") => {
+    Object.keys(current).forEach((key) => {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      result.push(fullKey);
+      const value = current[key];
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp)) {
+        traverse(value, fullKey);
+      }
+    });
+  };
+  traverse(obj);
+  return result;
+}
+function values(obj, deep = false) {
+  if (!deep) return Object.values(obj);
+  const result = [];
+  const traverse = (current) => {
+    Object.values(current).forEach((value) => {
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp)) {
+        traverse(value);
+      } else {
+        result.push(value);
+      }
+    });
+  };
+  traverse(obj);
+  return result;
+}
+function mapKeys(obj, fn) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const newKey = fn(key, obj[key]);
+    result[newKey] = obj[key];
+  });
+  return result;
+}
+function mapValues(obj, fn) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    result[key] = fn(obj[key], key);
+  });
+  return result;
+}
+function invert(obj) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    result[String(obj[key])] = key;
+  });
+  return result;
+}
+function defaults(obj, ...defaults2) {
+  const result = { ...obj };
+  defaults2.reverse().forEach((defaultObj) => {
+    Object.keys(defaultObj).forEach((key) => {
+      const typedKey = key;
+      if (!(typedKey in result) || result[typedKey] === void 0) {
+        result[typedKey] = defaultObj[typedKey];
+      }
+    });
+  });
+  return result;
+}
+function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0;
+}
+function isEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (obj1 === null || obj2 === null) return false;
+  if (typeof obj1 !== "object" || typeof obj2 !== "object") return false;
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
+  }
+  if (Array.isArray(obj1) && Array.isArray(obj2)) {
+    if (obj1.length !== obj2.length) return false;
+    return obj1.every((item, index) => isEqual(item, obj2[index]));
+  }
+  if (Array.isArray(obj1) || Array.isArray(obj2)) return false;
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  return keys1.every((key) => {
+    const val1 = obj1[key];
+    const val2 = obj2[key];
+    return isEqual(val1, val2);
+  });
+}
+function transform(obj, iteratee, accumulator = {}) {
+  Object.keys(obj).forEach((key) => {
+    iteratee(accumulator, obj[key], key);
+  });
+  return accumulator;
+}
+function pickBy(obj, predicate) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const typedKey = key;
+    if (predicate(obj[typedKey], key)) {
+      result[typedKey] = obj[typedKey];
+    }
+  });
+  return result;
+}
+function omitBy(obj, predicate) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const typedKey = key;
+    if (!predicate(obj[typedKey], key)) {
+      result[typedKey] = obj[typedKey];
+    }
+  });
+  return result;
+}
 
-var chunk27UDDVLZ_js = require('./chunk-27UDDVLZ.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "deepClone", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.deepClone; }
-});
-Object.defineProperty(exports, "deepMerge", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.deepMerge; }
-});
-Object.defineProperty(exports, "defaults", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.defaults; }
-});
-Object.defineProperty(exports, "get", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.get; }
-});
-Object.defineProperty(exports, "invert", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.invert; }
-});
-Object.defineProperty(exports, "isEmptyObject", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.isEmptyObject; }
-});
-Object.defineProperty(exports, "isEqual", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.isEqual; }
-});
-Object.defineProperty(exports, "keys", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.keys; }
-});
-Object.defineProperty(exports, "mapKeys", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.mapKeys; }
-});
-Object.defineProperty(exports, "mapValues", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.mapValues; }
-});
-Object.defineProperty(exports, "merge", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.merge; }
-});
-Object.defineProperty(exports, "omit", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.omit; }
-});
-Object.defineProperty(exports, "omitBy", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.omitBy; }
-});
-Object.defineProperty(exports, "pick", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.pick; }
-});
-Object.defineProperty(exports, "pickBy", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.pickBy; }
-});
-Object.defineProperty(exports, "set", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.set; }
-});
-Object.defineProperty(exports, "transform", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.transform; }
-});
-Object.defineProperty(exports, "values", {
-  enumerable: true,
-  get: function () { return chunk27UDDVLZ_js.values; }
-});
-//# sourceMappingURL=object.js.map
-//# sourceMappingURL=object.js.map
+export { deepClone, deepMerge, defaults, get, invert, isEmptyObject, isEqual, keys, mapKeys, mapValues, merge, omit, omitBy, pick, pickBy, set, transform, values };

package/dist/{chunk-JQZBPAPO.js → performance.cjs}

@@ -153,5 +153,3 @@ exports.once = once;
 exports.retry = retry;
 exports.throttle = throttle;
 exports.timeout = timeout;
-//# sourceMappingURL=chunk-JQZBPAPO.js.map
-//# sourceMappingURL=chunk-JQZBPAPO.js.map