@pol-studios/utils 1.0.0

package/dist/array/index.d.ts

@@ -0,0 +1 @@
+export { G as GroupedItems, d as chunk, e as chunkArray, k as convertArrayToObject, j as getAverage, g as groupBy, c as groupByMultipleCriteria, m as mapUnique, f as mapUnqiue, r as range, b as selectByMin, a as sort, s as sortBy, h as tryGetAverage, t as tryGetSum, u as unique } from '../index-ByjfWGR4.js';

package/dist/array/index.js

@@ -0,0 +1,136 @@
+// 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/internal/isUsable.ts
+function isUsable(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// 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;
+    },
+    {}
+  );
+}
+export {
+  chunk,
+  chunkArray,
+  convertArrayToObject,
+  getAverage,
+  groupBy,
+  groupByMultipleCriteria,
+  mapUnique,
+  mapUnqiue,
+  range,
+  selectByMin,
+  sort,
+  sortBy,
+  tryGetAverage,
+  tryGetSum,
+  unique
+};

package/dist/async/index.d.ts

@@ -0,0 +1 @@
+export { S as Semaphore, c as concurrent, a as debounce, d as delay, p as promiseAllWithConcurrencyLimit } from '../index-C-YwC08Y.js';

package/dist/async/index.js

@@ -0,0 +1,67 @@
+// 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++;
+    }
+  }
+};
+export {
+  Semaphore,
+  concurrent,
+  debounce,
+  delay,
+  promiseAllWithConcurrencyLimit
+};

package/dist/cache/index.d.ts

@@ -0,0 +1 @@
+export { c as cacheFunction, b as clearAllCache, a as clearCache } from '../index-CrplC0qf.js';

package/dist/cache/index.js

@@ -0,0 +1,42 @@
+// src/cache/index.ts
+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();
+}
+export {
+  cacheFunction,
+  clearAllCache,
+  clearCache
+};

package/dist/color/index.d.ts

@@ -0,0 +1 @@
+export { a as isDarkColor } from '../index-Cvl_0aDq.js';

package/dist/color/index.js

@@ -0,0 +1,16 @@
+// src/color/index.ts
+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;
+}
+export {
+  isDarkColor
+};

package/dist/date/index.d.ts

@@ -0,0 +1,2 @@
+export { e as addDates, f as addDays, b as areDatesEqual, d as dateReviver, g as getUtcDate, a as getUtcMoment, c as isValidDate, p as parseWithDate, t as toUtcDate } from '../index-BDWEMkWa.js';
+import 'moment';

package/dist/date/index.js

@@ -0,0 +1,102 @@
+// src/date/utc.ts
+import moment from "moment";
+
+// src/internal/isUsable.ts
+function isUsable(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// src/date/utc.ts
+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;
+}
+export {
+  addDates,
+  addDays,
+  areDatesEqual,
+  dateReviver,
+  getUtcDate,
+  getUtcMoment,
+  isValidDate,
+  parseWithDate,
+  toUtcDate
+};

package/dist/dev/index.d.ts

@@ -0,0 +1 @@
+export { d as debugLog, b as isDev, a as isDevEnvironment } from '../index-vLuR45Km.js';

package/dist/dev/index.js

@@ -0,0 +1,21 @@
+// src/dev/index.ts
+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);
+  }
+}
+export {
+  debugLog,
+  isDev,
+  isDevEnvironment
+};

package/dist/device/index.d.ts

@@ -0,0 +1 @@
+export { h as hasCameraAsync, b as isIphone, c as isPwaLaunched, a as isSmallDevice } from '../index-C062CkPL.js';

package/dist/device/index.js

@@ -0,0 +1,31 @@
+// src/device/index.ts
+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;
+  }
+}
+export {
+  hasCameraAsync,
+  isIphone,
+  isPwaLaunched,
+  isSmallDevice
+};

package/dist/enum/index.d.ts

@@ -0,0 +1 @@
+export { g as getEnumValues, p as parseStringToEnum } from '../index-Cp7KyTeB.js';

package/dist/enum/index.js

@@ -0,0 +1,19 @@
+// src/enum/index.ts
+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;
+}
+export {
+  getEnumValues,
+  parseStringToEnum
+};

package/dist/error/index.d.ts

@@ -0,0 +1 @@
+export { E as ErrorMapping, P as PostgrestError, U as UserFriendlyError, V as ValidationErrorMapping, e as extractFieldName, c as getFormFieldError, g as getUserFriendlyError, b as isNetworkError, a as isPostgrestError } from '../index-B2oAfh_i.js';

package/dist/error/index.js

@@ -0,0 +1,198 @@
+// 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;
+}
+export {
+  extractFieldName,
+  getFormFieldError,
+  getUserFriendlyError,
+  isNetworkError,
+  isPostgrestError
+};

package/dist/format/index.d.ts

@@ -0,0 +1 @@
+export { f as formatCurrency, b as toDecimalString, a as toNumberString, t as toUsdString } from '../index-DdaZnk7j.js';