@pol-studios/utils 1.0.0

package/dist/index.js

@@ -0,0 +1,1279 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/string/index.ts
+var string_exports = {};
+__export(string_exports, {
+  camelize: () => camelize,
+  generateSlug: () => generateSlug,
+  isBlank: () => isBlank,
+  isNullOrWhitespace: () => isNullOrWhitespace,
+  pascalize: () => pascalize,
+  pascalizeWithSpaces: () => pascalizeWithSpaces,
+  sanitizeInput: () => sanitizeInput,
+  slugify: () => slugify
+});
+
+// src/string/camelize.ts
+function camelize(str) {
+  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+    return index === 0 ? word.toLowerCase() : word.toUpperCase();
+  }).replace(/\s+/g, "");
+}
+
+// src/internal/isUsable.ts
+function isUsable(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// src/string/pascalize.ts
+function pascalize(str) {
+  return str.replace(/(\w)(\w*)/g, function(g0, g1, g2) {
+    return g1.toUpperCase() + g2.toLowerCase();
+  });
+}
+function pascalizeWithSpaces(input) {
+  if (isUsable(input) === false) return input;
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+
+// src/string/slugify.ts
+function slugify(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var generateSlug = slugify;
+
+// src/string/sanitize.ts
+function sanitizeInput(value) {
+  return value.replace(/"/g, '""').replace(/'/g, "''");
+}
+
+// src/string/isBlank.ts
+function isBlank(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "string" && value.trim().length === 0) {
+    return true;
+  }
+  return false;
+}
+var isNullOrWhitespace = isBlank;
+
+// src/array/index.ts
+var array_exports = {};
+__export(array_exports, {
+  chunk: () => chunk,
+  chunkArray: () => chunkArray,
+  convertArrayToObject: () => convertArrayToObject,
+  getAverage: () => getAverage,
+  groupBy: () => groupBy,
+  groupByMultipleCriteria: () => groupByMultipleCriteria,
+  mapUnique: () => mapUnique,
+  mapUnqiue: () => mapUnqiue,
+  range: () => range,
+  selectByMin: () => selectByMin,
+  sort: () => sort,
+  sortBy: () => sortBy,
+  tryGetAverage: () => tryGetAverage,
+  tryGetSum: () => tryGetSum,
+  unique: () => unique
+});
+
+// src/array/sortBy.ts
+function sortBy(items, property, isAscending = false) {
+  if (items === null || items === void 0) return [];
+  return [...items]?.sort((a, b) => {
+    const aProp = a[property];
+    const bProp = b[property];
+    if (isAscending) {
+      return aProp === bProp ? 0 : aProp < bProp ? 1 : -1;
+    }
+    return aProp === bProp ? 0 : aProp < bProp ? -1 : 1;
+  });
+}
+function sort(items, func, isAscending = false) {
+  const startingValue = isAscending ? 1 : -1;
+  const endingValue = isAscending ? -1 : 1;
+  return [...items].sort(
+    (a, b) => func(a) === func(b) ? 0 : func(a) < func(b) ? startingValue : endingValue
+  );
+}
+function selectByMin(items, action) {
+  return items.reduce((min, current) => {
+    return action(current) < action(min) ? current : min;
+  });
+}
+
+// src/array/groupBy.ts
+function groupBy(list, key) {
+  const map = /* @__PURE__ */ new Map();
+  if (isUsable(list) === false) return map;
+  list.forEach((item) => {
+    const keyValue = typeof key === "function" ? key(item) : item[key];
+    const collection = map.get(keyValue);
+    if (!collection) {
+      map.set(keyValue, [item]);
+    } else {
+      collection.push(item);
+    }
+  });
+  return map;
+}
+function groupByMultipleCriteria(items, criteria) {
+  if (isUsable(items) === false) return [];
+  const grouped = {};
+  items.forEach((item) => {
+    const key = criteria.map((criterion) => item[criterion]).join("|");
+    if (!grouped[key]) {
+      grouped[key] = [];
+    }
+    grouped[key].push(item);
+  });
+  const results = Object.values(grouped).map((group) => ({
+    items: Array.isArray(group) ? group : []
+  }));
+  return results;
+}
+
+// src/array/chunk.ts
+function chunk(array, chunkSize) {
+  if (chunkSize <= 0) throw new Error("chunkSize must be greater than 0");
+  const chunks = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+var chunkArray = chunk;
+
+// src/array/unique.ts
+function unique(array, key) {
+  if (isUsable(array) === false) return [];
+  return Array.from(new Set(array.map((x) => x[key])));
+}
+var mapUnique = unique;
+var mapUnqiue = unique;
+
+// src/array/range.ts
+function range(size, startAt = 0) {
+  return [...Array(size).keys()].map((i, index) => index + startAt);
+}
+
+// src/array/sum.ts
+function tryGetSum(itemsArray, defaultValue = 0) {
+  if (isUsable(itemsArray) === false) return defaultValue;
+  if (itemsArray.length === 0) return defaultValue;
+  const results = itemsArray.reduce((a, b) => a + b, defaultValue);
+  if (Number.isNaN(results)) {
+    return defaultValue;
+  }
+  return results;
+}
+
+// src/array/average.ts
+function tryGetAverage(items, defaultValue = 0) {
+  if (isUsable(items) === false) return defaultValue;
+  if (items.length === 0) return defaultValue;
+  const sum = tryGetSum(items, defaultValue);
+  const response = sum / items.length;
+  return response;
+}
+function getAverage(arr) {
+  const sum = arr.reduce((acc, curr) => acc + curr, 0);
+  return sum / arr.length;
+}
+
+// src/array/convertToObject.ts
+function convertArrayToObject(array, key) {
+  return array?.reduce(
+    (obj, item) => {
+      obj[item[key]] = item;
+      return obj;
+    },
+    {}
+  );
+}
+
+// src/object/index.ts
+var object_exports = {};
+__export(object_exports, {
+  deepEquals: () => deepEquals,
+  diff: () => diff,
+  getPath: () => getPath,
+  getValueByPath: () => getValueByPath,
+  includeOnly: () => includeOnly,
+  isDeepEqual: () => isDeepEqual,
+  omit: () => omit,
+  pick: () => pick,
+  setPath: () => setPath,
+  setValueByPath: () => setValueByPath
+});
+
+// src/object/omit.ts
+function omit(obj, keys) {
+  const keysArray = Array.isArray(keys) ? keys : [keys];
+  const newObj = { ...obj };
+  keysArray.forEach((key) => {
+    if (key in newObj) {
+      delete newObj[key];
+    }
+  });
+  return newObj;
+}
+
+// src/object/pick.ts
+function pick(obj, keys) {
+  const newValue = {};
+  keys.forEach((key) => {
+    if (key in obj) {
+      newValue[key] = obj[key];
+    }
+  });
+  return newValue;
+}
+var includeOnly = pick;
+
+// src/object/diff.ts
+function diff(oldValue, newValue) {
+  if (isUsable(oldValue) === false) {
+    return { ...newValue };
+  }
+  const result = {};
+  function compare(o1, o2, res) {
+    for (const key in o1) {
+      if (o1.hasOwnProperty(key)) {
+        if (typeof o1[key] === "object" && o1[key] !== null && typeof o2[key] === "object" && o2[key] !== null) {
+          const nestedDiff = diff(o1[key], o2[key]);
+          if (Object.keys(nestedDiff).length > 0) {
+            res[key] = nestedDiff;
+          }
+        } else if (o1[key] !== o2[key]) {
+          res[key] = o2[key];
+        }
+      }
+    }
+    for (const key in o2) {
+      if (o2.hasOwnProperty(key) && !o1.hasOwnProperty(key)) {
+        res[key] = o2[key];
+      }
+    }
+  }
+  compare(oldValue, newValue, result);
+  return result;
+}
+
+// src/object/getPath.ts
+function getPath(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current[key] === void 0) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+var getValueByPath = getPath;
+
+// src/object/setPath.ts
+function setPath(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === void 0) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+}
+var setValueByPath = setPath;
+
+// src/object/deepEqual.ts
+function deepEquals(obj1, obj2) {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+var isDeepEqual = deepEquals;
+
+// src/date/index.ts
+var date_exports = {};
+__export(date_exports, {
+  addDates: () => addDates,
+  addDays: () => addDays,
+  areDatesEqual: () => areDatesEqual,
+  dateReviver: () => dateReviver,
+  getUtcDate: () => getUtcDate,
+  getUtcMoment: () => getUtcMoment,
+  isValidDate: () => isValidDate,
+  parseWithDate: () => parseWithDate,
+  toUtcDate: () => toUtcDate
+});
+
+// src/date/utc.ts
+import moment from "moment";
+function getUtcDate() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(
+    Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      now.getUTCDate(),
+      now.getUTCHours(),
+      now.getUTCMinutes(),
+      now.getUTCSeconds()
+    )
+  );
+}
+function toUtcDate(date) {
+  if (isUsable(date) === false) return null;
+  return new Date(
+    Date.UTC(
+      date.getUTCFullYear(),
+      date.getUTCMonth(),
+      date.getUTCDate(),
+      date.getUTCHours(),
+      date.getUTCMinutes(),
+      date.getUTCSeconds()
+    )
+  );
+}
+function getUtcMoment() {
+  return moment.utc(moment.now());
+}
+
+// src/date/compare.ts
+function areDatesEqual(date1, date2) {
+  return date1 === date2;
+}
+
+// src/date/parse.ts
+import moment2 from "moment";
+function dateReviver(key, value) {
+  if (typeof value !== "string") return value;
+  const isUtcOrLocalDate = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,7})?(Z)?$/.test(value);
+  if (isUtcOrLocalDate) {
+    return moment2.utc(value);
+  } else {
+    const isTimeZoneDate = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,7})?[+-]\d{2}:\d{2}$/.test(
+      value
+    );
+    if (isTimeZoneDate) {
+      return moment2(value);
+    }
+  }
+  return value;
+}
+function parseWithDate(key, value) {
+  if (typeof value !== "string") return value;
+  const isUtcOrLocalDate = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,7})?(Z)?$/.test(value);
+  if (isUtcOrLocalDate) {
+    return new Date(value);
+  } else {
+    const isTimeZoneDate = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,7})?[+-]\d{2}:\d{2}$/.test(
+      value
+    );
+    if (isTimeZoneDate) {
+      return new Date(value);
+    }
+  }
+  return value;
+}
+function isValidDate(date) {
+  if (isUsable(date) === false) return false;
+  return date.getTime() === date.getTime();
+}
+
+// src/date/add.ts
+import moment3 from "moment";
+function addDates(date1, date2) {
+  const duration = moment3.duration(date2.diff(date1));
+  return date1.add(duration);
+}
+function addDays(date1, days) {
+  const newDate = date1.add(days, "days");
+  return newDate;
+}
+
+// src/async/index.ts
+var async_exports = {};
+__export(async_exports, {
+  Semaphore: () => Semaphore,
+  concurrent: () => concurrent,
+  debounce: () => debounce,
+  delay: () => delay,
+  promiseAllWithConcurrencyLimit: () => promiseAllWithConcurrencyLimit
+});
+
+// src/async/delay.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/async/debounce.ts
+var timeoutId = null;
+function debounce(func, wait) {
+  if (timeoutId !== null) {
+    clearTimeout(timeoutId);
+  }
+  timeoutId = setTimeout(() => {
+    func();
+  }, wait);
+}
+
+// src/async/concurrent.ts
+async function concurrent(tasks, concurrency) {
+  const results = [];
+  let current = 0;
+  async function worker() {
+    while (current < tasks.length) {
+      const index = current++;
+      results[index] = await tasks[index]();
+    }
+  }
+  const workers = [];
+  for (let i = 0; i < concurrency; i++) {
+    workers.push(worker());
+  }
+  await Promise.all(workers);
+  return results;
+}
+var promiseAllWithConcurrencyLimit = concurrent;
+
+// src/async/semaphore.ts
+var Semaphore = class {
+  constructor(count) {
+    this.tasks = [];
+    this.count = count;
+  }
+  acquire() {
+    if (this.count > 0) {
+      this.count--;
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve) => this.tasks.push(resolve));
+    }
+  }
+  release() {
+    if (this.tasks.length > 0) {
+      const resolve = this.tasks.shift();
+      if (resolve) resolve();
+    } else {
+      this.count++;
+    }
+  }
+};
+
+// src/format/index.ts
+var format_exports = {};
+__export(format_exports, {
+  formatCurrency: () => formatCurrency,
+  toDecimalString: () => toDecimalString,
+  toNumberString: () => toNumberString,
+  toUsdString: () => toUsdString
+});
+
+// src/format/currency.ts
+function formatCurrency(value) {
+  if (isUsable(value) === false) return "";
+  const formatter = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD"
+  });
+  return formatter.format(value);
+}
+var toUsdString = formatCurrency;
+function toNumberString(value) {
+  const formatter = new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 2
+  });
+  return formatter.format(value);
+}
+
+// src/format/decimal.ts
+function toDecimalString(num, decimalPlaces) {
+  if (isUsable(num) === false) return "";
+  return num.toLocaleString("en-US", {
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces
+  });
+}
+
+// src/tailwind/index.ts
+var tailwind_exports = {};
+__export(tailwind_exports, {
+  cn: () => cn
+});
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/cache/index.ts
+var cache_exports = {};
+__export(cache_exports, {
+  cacheFunction: () => cacheFunction,
+  clearAllCache: () => clearAllCache,
+  clearCache: () => clearCache
+});
+var cacheStore = /* @__PURE__ */ new Map();
+async function cacheFunction(key, fn, duration) {
+  const now = Date.now();
+  const cached = cacheStore.get(key);
+  if (cached) {
+    if (now < cached.expiresAt) {
+      return cached.data;
+    }
+    if (cached.promise) {
+      return cached.promise;
+    }
+  }
+  const promise = fn().then((result) => {
+    cacheStore.set(key, {
+      data: result,
+      expiresAt: Date.now() + duration
+    });
+    return result;
+  }).catch((error) => {
+    cacheStore.delete(key);
+    throw error;
+  });
+  cacheStore.set(key, {
+    data: cached?.data,
+    // Retain existing data until new data is fetched
+    expiresAt: cached?.expiresAt || now,
+    promise
+  });
+  return promise;
+}
+function clearCache(key) {
+  cacheStore.delete(key);
+}
+function clearAllCache() {
+  cacheStore.clear();
+}
+
+// src/types/index.ts
+var types_exports = {};
+__export(types_exports, {
+  getContentType: () => getContentType,
+  isImageType: () => isImageType,
+  isPdfType: () => isPdfType,
+  isRenderableType: () => isRenderableType,
+  isUsable: () => isUsable2,
+  isVideoType: () => isVideoType
+});
+
+// src/types/guards.ts
+function isUsable2(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// src/types/StorageObjectMetadata.ts
+function getContentType(metadata, path) {
+  if (metadata?.contentType) {
+    return metadata.contentType;
+  }
+  const ext = path.split(".").pop()?.toUpperCase();
+  return ext || "Unknown";
+}
+function isImageType(contentType) {
+  return ["JPEG", "JPG", "PNG", "GIF", "WEBP", "SVG", "HEIC", "HEIF"].includes(
+    contentType.toUpperCase()
+  );
+}
+function isVideoType(contentType) {
+  return ["MP4", "QUICKTIME", "MOV", "WEBM", "AVI", "MKV"].includes(
+    contentType.toUpperCase()
+  );
+}
+function isPdfType(contentType) {
+  return contentType.toUpperCase() === "PDF";
+}
+function isRenderableType(contentType) {
+  return isImageType(contentType) || isVideoType(contentType) || isPdfType(contentType);
+}
+
+// src/color/index.ts
+var color_exports = {};
+__export(color_exports, {
+  isDarkColor: () => isDarkColor
+});
+function isDarkColor(c) {
+  c = c.substring(1);
+  const rgb = parseInt(c, 16);
+  const r = rgb >> 16 & 255;
+  const g = rgb >> 8 & 255;
+  const b = rgb >> 0 & 255;
+  const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  if (luma < 70) {
+    return true;
+  }
+  return false;
+}
+
+// src/validation/index.ts
+var validation_exports = {};
+__export(validation_exports, {
+  calculatePasswordStrength: () => calculatePasswordStrength,
+  validateEmail: () => validateEmail,
+  validateMaxLength: () => validateMaxLength,
+  validateMinLength: () => validateMinLength,
+  validatePattern: () => validatePattern,
+  validateRequired: () => validateRequired,
+  validateValue: () => validateValue
+});
+
+// src/validation/validators.ts
+function validateValue(value, rules) {
+  for (const rule of rules) {
+    if (!rule.validate(value)) {
+      return { isValid: false, error: rule.message };
+    }
+  }
+  return { isValid: true };
+}
+function validateEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!email || email.trim().length === 0) {
+    return { isValid: false, error: "Email is required" };
+  }
+  if (!emailRegex.test(email)) {
+    return { isValid: false, error: "Please enter a valid email address" };
+  }
+  return { isValid: true };
+}
+function validateRequired(value) {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: false, error: "This field is required" };
+  }
+  if (typeof value === "string" && value.trim().length === 0) {
+    return { isValid: false, error: "This field is required" };
+  }
+  return { isValid: true };
+}
+function validateMinLength(min) {
+  return (value) => {
+    if (!value || value.length < min) {
+      return {
+        isValid: false,
+        error: `Must be at least ${min} characters`
+      };
+    }
+    return { isValid: true };
+  };
+}
+function validateMaxLength(max) {
+  return (value) => {
+    if (value && value.length > max) {
+      return {
+        isValid: false,
+        error: `Must be no more than ${max} characters`
+      };
+    }
+    return { isValid: true };
+  };
+}
+function validatePattern(pattern, message) {
+  return (value) => {
+    if (value && !pattern.test(value)) {
+      return { isValid: false, error: message };
+    }
+    return { isValid: true };
+  };
+}
+
+// src/validation/password.ts
+function calculatePasswordStrength(password) {
+  if (!password || password.length === 0) {
+    return {
+      strength: "weak",
+      score: 0,
+      feedback: []
+    };
+  }
+  let score = 0;
+  const feedback = [];
+  if (password.length >= 8) {
+    score += 1;
+  } else {
+    feedback.push("Use at least 8 characters");
+  }
+  if (password.length >= 12) {
+    score += 1;
+  }
+  if (/[a-z]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add lowercase letters");
+  }
+  if (/[A-Z]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add uppercase letters");
+  }
+  if (/[0-9]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add numbers");
+  }
+  if (/[^a-zA-Z0-9]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add special characters");
+  }
+  let strength;
+  if (score <= 2) {
+    strength = "weak";
+  } else if (score <= 3) {
+    strength = "fair";
+  } else if (score <= 4) {
+    strength = "good";
+  } else {
+    strength = "strong";
+  }
+  return {
+    strength,
+    score,
+    feedback: feedback.length > 0 ? feedback : []
+  };
+}
+
+// src/error/index.ts
+var error_exports = {};
+__export(error_exports, {
+  extractFieldName: () => extractFieldName,
+  getFormFieldError: () => getFormFieldError,
+  getUserFriendlyError: () => getUserFriendlyError,
+  isNetworkError: () => isNetworkError,
+  isPostgrestError: () => isPostgrestError
+});
+
+// src/error/mapper.ts
+var errorMappings = [
+  // Unique constraint violation
+  {
+    code: "23505",
+    message: "This item already exists",
+    action: "Please use a different name or value"
+  },
+  // Foreign key violation
+  {
+    code: "23503",
+    message: "Cannot delete: this item is in use",
+    action: "Remove all references to this item before deleting"
+  },
+  // Check constraint violation
+  {
+    code: "23514",
+    message: "Invalid value provided",
+    action: "Please check your input and try again"
+  },
+  // Undefined table
+  {
+    code: "42P01",
+    message: "Service temporarily unavailable",
+    action: "Please try again in a moment"
+  },
+  // Insufficient privilege
+  {
+    code: "42501",
+    message: "You don't have permission to perform this action",
+    action: "Contact your administrator if you need access"
+  },
+  // Not found (PostgREST)
+  {
+    code: "PGRST116",
+    message: "Item not found",
+    action: "The item may have been deleted or moved"
+  },
+  // Network errors
+  {
+    pattern: /network|connection|fetch|timeout|offline/i,
+    message: "Connection problem",
+    action: "Please check your internet connection and try again"
+  },
+  // Authentication errors
+  {
+    pattern: /unauthorized|authentication|token|session/i,
+    message: "Your session has expired",
+    action: "Please sign in again"
+  },
+  // Validation errors
+  {
+    pattern: /validation|invalid|required|missing/i,
+    message: "Please check your input",
+    action: "Make sure all required fields are filled correctly"
+  },
+  // Generic fallback
+  {
+    message: "Something went wrong",
+    action: "Please try again"
+  }
+];
+function extractErrorCode(error) {
+  if (error?.code) return error.code;
+  if (error?.error?.code) return error.error.code;
+  return void 0;
+}
+function extractErrorMessage(error) {
+  if (error?.message) return error.message;
+  if (error?.error?.message) return error.error.message;
+  if (typeof error === "string") return error;
+  return "An unknown error occurred";
+}
+function getUserFriendlyError(error) {
+  const errorCode = extractErrorCode(error);
+  const errorMessage = extractErrorMessage(error);
+  if (errorCode) {
+    const codeMatch = errorMappings.find((mapping) => mapping.code === errorCode);
+    if (codeMatch) {
+      return {
+        message: codeMatch.message,
+        action: codeMatch.action
+      };
+    }
+  }
+  const patternMatch = errorMappings.find(
+    (mapping) => mapping.pattern && mapping.pattern.test(errorMessage)
+  );
+  if (patternMatch) {
+    return {
+      message: patternMatch.message,
+      action: patternMatch.action
+    };
+  }
+  const fallback = errorMappings[errorMappings.length - 1];
+  return {
+    message: fallback.message,
+    action: fallback.action
+  };
+}
+function isPostgrestError(error) {
+  return error && typeof error === "object" && "code" in error && "message" in error && typeof error.code === "string";
+}
+function isNetworkError(error) {
+  const message = extractErrorMessage(error).toLowerCase();
+  return /network|connection|fetch|timeout|offline|failed to fetch/i.test(message);
+}
+
+// src/error/form.ts
+var validationMappings = [
+  {
+    pattern: /required|missing|empty/i,
+    message: "This field is required",
+    action: "Please fill in this field"
+  },
+  {
+    pattern: /min.*length|too short/i,
+    message: "This field is too short",
+    action: "Please enter more characters"
+  },
+  {
+    pattern: /max.*length|too long/i,
+    message: "This field is too long",
+    action: "Please enter fewer characters"
+  },
+  {
+    pattern: /email|invalid.*email/i,
+    message: "Please enter a valid email address",
+    action: "Example: name@example.com"
+  },
+  {
+    pattern: /password|weak/i,
+    message: "Password is too weak",
+    action: "Use at least 8 characters with numbers and letters"
+  },
+  {
+    pattern: /match|doesn't match/i,
+    message: "Values don't match",
+    action: "Please check that both fields match"
+  },
+  {
+    pattern: /number|numeric/i,
+    message: "Please enter a valid number",
+    action: "Only numbers are allowed"
+  },
+  {
+    pattern: /date|invalid.*date/i,
+    message: "Please enter a valid date",
+    action: "Use format: MM/DD/YYYY"
+  },
+  {
+    pattern: /url|invalid.*url/i,
+    message: "Please enter a valid URL",
+    action: "Example: https://example.com"
+  },
+  {
+    pattern: /phone|invalid.*phone/i,
+    message: "Please enter a valid phone number",
+    action: "Example: (555) 123-4567"
+  },
+  {
+    message: "Invalid value",
+    action: "Please check your input"
+  }
+];
+function getFormFieldError(error) {
+  if (!error) return null;
+  const errorMessage = typeof error === "string" ? error : error.message || "";
+  if (!errorMessage) return null;
+  const patternMatch = validationMappings.find(
+    (mapping) => mapping.pattern && mapping.pattern.test(errorMessage)
+  );
+  if (patternMatch) {
+    return {
+      message: patternMatch.message,
+      action: patternMatch.action
+    };
+  }
+  const fallback = validationMappings[validationMappings.length - 1];
+  return {
+    message: fallback.message,
+    action: fallback.action
+  };
+}
+function extractFieldName(errorMessage) {
+  const fieldMatch = errorMessage.match(/(?:field|property|column)\s+['"]?(\w+)['"]?/i);
+  if (fieldMatch && fieldMatch[1]) {
+    return fieldMatch[1];
+  }
+  return null;
+}
+
+// src/device/index.ts
+var device_exports = {};
+__export(device_exports, {
+  hasCameraAsync: () => hasCameraAsync,
+  isIphone: () => isIphone,
+  isPwaLaunched: () => isPwaLaunched,
+  isSmallDevice: () => isSmallDevice
+});
+function isSmallDevice() {
+  return window.innerWidth <= 640;
+}
+function isIphone() {
+  return /iPhone/.test(navigator.userAgent);
+}
+function isPwaLaunched() {
+  if (window.navigator.standalone) {
+    return true;
+  }
+  if (window.matchMedia("(display-mode: standalone)").matches) {
+    return true;
+  }
+  return false;
+}
+async function hasCameraAsync() {
+  try {
+    const devices = await navigator.mediaDevices?.enumerateDevices();
+    return devices?.some((device) => device.kind === "videoinput") ?? false;
+  } catch (error) {
+    console.error("Error checking for camera:", error);
+    return false;
+  }
+}
+
+// src/uuid/index.ts
+var uuid_exports = {};
+__export(uuid_exports, {
+  newUuid: () => newUuid
+});
+function newUuid() {
+  return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, () => {
+    const r = Math.random() * 16 | 0;
+    return r.toString(16);
+  });
+}
+
+// src/state/index.ts
+var state_exports = {};
+__export(state_exports, {
+  getObjectChanges: () => getObjectChanges,
+  withUpdate: () => withUpdate
+});
+function withUpdate(item, updates) {
+  return { ...item, ...updates };
+}
+function getObjectChanges(oldObj, newObj) {
+  const changes = {};
+  for (const key of Object.keys(newObj)) {
+    if (newObj[key] !== oldObj[key]) {
+      changes[key] = newObj[key];
+    }
+  }
+  return changes;
+}
+
+// src/enum/index.ts
+var enum_exports = {};
+__export(enum_exports, {
+  getEnumValues: () => getEnumValues,
+  parseStringToEnum: () => parseStringToEnum
+});
+function getEnumValues(enumObject) {
+  const values = Object.values(enumObject);
+  return values.filter((value) => typeof value !== "number");
+}
+function parseStringToEnum(enumType, value) {
+  if (value in enumType) {
+    return enumType[value];
+  }
+  const numericValue = parseInt(value, 10);
+  if (!isNaN(numericValue) && Object.values(enumType).includes(numericValue)) {
+    return numericValue;
+  }
+  return void 0;
+}
+
+// src/dev/index.ts
+var dev_exports = {};
+__export(dev_exports, {
+  debugLog: () => debugLog,
+  isDev: () => isDev,
+  isDevEnvironment: () => isDevEnvironment
+});
+function isDevEnvironment() {
+  if (typeof process === "undefined") return false;
+  const development = (process.env.WITH_MODE ?? "") === "development";
+  return development;
+}
+function isDev() {
+  if (typeof process === "undefined") return false;
+  const development = (process.env.WITH_MODE ?? "") === "development";
+  return development;
+}
+function debugLog(message, ...optionalParams) {
+  if (isDevEnvironment()) {
+    console.log(message, ...optionalParams);
+  }
+}
+
+// src/constants/index.ts
+var constants_exports = {};
+__export(constants_exports, {
+  AccessKeys: () => AccessKeys
+});
+
+// src/constants/AccessKeys.ts
+var AccessKeys = {
+  Timesheet: "timesheet",
+  TimesheetAdmin: "admin_timesheet",
+  InternalAdmin: "internal",
+  Invoicing: "invoicing",
+  ExpenseReport: "expense_report",
+  ExpenseReportAdmin: "admin_expense_report",
+  ProjectAdmin: "admin_project",
+  FixtureCatalog: "fixture_catalog",
+  ProjectDatabase: "project_database",
+  Owner: "owner",
+  User: "user"
+};
+
+// src/download/index.ts
+var download_exports = {};
+__export(download_exports, {
+  downloadFile: () => downloadFile,
+  getFile: () => getFile,
+  getFilePost: () => getFilePost
+});
+async function getFile(url, fileName) {
+  const response = await fetch(url);
+  const blob = await response.blob();
+  const link = document.createElement("a");
+  link.href = URL.createObjectURL(blob);
+  link.download = fileName;
+  link.click();
+  URL.revokeObjectURL(link.href);
+}
+async function downloadFile(text) {
+  const blob = new Blob([text], { type: "text/plain" });
+  const link = document.createElement("a");
+  link.style.display = "none";
+  link.href = URL.createObjectURL(blob);
+  document.body.appendChild(link);
+  link.click();
+  URL.revokeObjectURL(link.href);
+  document.body.removeChild(link);
+}
+async function getFilePost(url, fileName, queryParams) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(queryParams)
+  });
+  if (response.ok === false) {
+    if (response.status === 404) throw new Error(response.statusText);
+    if (response.status === 500) throw new Error(response.statusText);
+    throw new Error(response.statusText);
+  }
+  const blob = await response.blob();
+  const link = document.createElement("a");
+  link.href = URL.createObjectURL(blob);
+  link.download = fileName;
+  link.click();
+  URL.revokeObjectURL(link.href);
+}
+
+// src/meta/index.ts
+var meta_exports = {};
+__export(meta_exports, {
+  getCallerUniqueKey: () => getCallerUniqueKey
+});
+function getCallerUniqueKey() {
+  const err = new Error();
+  let stack = err.stack;
+  if (stack === void 0) {
+    try {
+      throw err;
+    } catch (e) {
+      stack = e.stack;
+    }
+  }
+  stack = stack || "";
+  const lines = stack.split("\n");
+  let earliestExecutionLine = 10;
+  const filteredLines = lines.filter((line, index) => {
+    const isIncluded = (line.includes("React") || line.trim().startsWith("at commitHook") || line.trim().includes("MountEffects")) === false;
+    if (index < earliestExecutionLine && isIncluded === false) {
+      earliestExecutionLine = index;
+    }
+    return isIncluded;
+  });
+  const result = filteredLines.filter((x, index) => index < earliestExecutionLine).join("-");
+  return result;
+}
+export {
+  AccessKeys,
+  Semaphore,
+  addDates,
+  addDays,
+  areDatesEqual,
+  array_exports as array,
+  async_exports as async,
+  cache_exports as cache,
+  cacheFunction,
+  calculatePasswordStrength,
+  camelize,
+  chunk,
+  chunkArray,
+  clearAllCache,
+  clearCache,
+  cn,
+  color_exports as color,
+  concurrent,
+  constants_exports as constants,
+  convertArrayToObject,
+  date_exports as date,
+  dateReviver,
+  debounce,
+  debugLog,
+  deepEquals,
+  delay,
+  dev_exports as dev,
+  device_exports as device,
+  diff,
+  download_exports as download,
+  downloadFile,
+  enum_exports as enumUtils,
+  error_exports as error,
+  extractFieldName,
+  format_exports as format,
+  formatCurrency,
+  generateSlug,
+  getAverage,
+  getCallerUniqueKey,
+  getContentType,
+  getEnumValues,
+  getFile,
+  getFilePost,
+  getFormFieldError,
+  getObjectChanges,
+  getPath,
+  getUserFriendlyError,
+  getUtcDate,
+  getUtcMoment,
+  getValueByPath,
+  groupBy,
+  groupByMultipleCriteria,
+  hasCameraAsync,
+  includeOnly,
+  isBlank,
+  isDarkColor,
+  isDeepEqual,
+  isDev,
+  isDevEnvironment,
+  isImageType,
+  isIphone,
+  isNetworkError,
+  isNullOrWhitespace,
+  isPdfType,
+  isPostgrestError,
+  isPwaLaunched,
+  isRenderableType,
+  isSmallDevice,
+  isUsable,
+  isValidDate,
+  isVideoType,
+  mapUnique,
+  mapUnqiue,
+  meta_exports as meta,
+  newUuid,
+  object_exports as object,
+  omit,
+  parseStringToEnum,
+  parseWithDate,
+  pascalize,
+  pascalizeWithSpaces,
+  pick,
+  promiseAllWithConcurrencyLimit,
+  range,
+  sanitizeInput,
+  selectByMin,
+  setPath,
+  setValueByPath,
+  slugify,
+  sort,
+  sortBy,
+  state_exports as state,
+  string_exports as string,
+  tailwind_exports as tailwind,
+  toDecimalString,
+  toNumberString,
+  toUsdString,
+  toUtcDate,
+  tryGetAverage,
+  tryGetSum,
+  types_exports as types,
+  unique,
+  uuid_exports as uuid,
+  validateEmail,
+  validateMaxLength,
+  validateMinLength,
+  validatePattern,
+  validateRequired,
+  validateValue,
+  validation_exports as validation,
+  withUpdate
+};