@zairakai/js-utils 1.0.0

package/dist/collections.js

@@ -0,0 +1,17 @@
+import {
+  EnhancedArray,
+  EnhancedMap,
+  collect,
+  collectMap,
+  mapToObject,
+  objectToMap
+} from "./chunk-TY75OOIQ.js";
+import "./chunk-LDSWHSRX.js";
+export {
+  EnhancedArray,
+  EnhancedMap,
+  collect,
+  collectMap,
+  mapToObject,
+  objectToMap
+};

package/dist/datetime.cjs

@@ -0,0 +1,80 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/datetime.ts
+var datetime_exports = {};
+__export(datetime_exports, {
+  dayjs: () => dayjs,
+  fromNow: () => fromNow,
+  isBetweenDates: () => isBetweenDates,
+  isFuture: () => isFuture,
+  isPast: () => isPast,
+  isToday: () => isToday,
+  now: () => now,
+  today: () => today,
+  tomorrow: () => tomorrow,
+  yesterday: () => yesterday
+});
+module.exports = __toCommonJS(datetime_exports);
+var import_dayjs = __toESM(require("dayjs"), 1);
+var import_isBetween = __toESM(require("dayjs/plugin/isBetween"), 1);
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"), 1);
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"), 1);
+var import_relativeTime = __toESM(require("dayjs/plugin/relativeTime"), 1);
+var import_utc = __toESM(require("dayjs/plugin/utc"), 1);
+import_dayjs.default.extend(import_isBetween.default);
+import_dayjs.default.extend(import_isSameOrAfter.default);
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_relativeTime.default);
+import_dayjs.default.extend(import_utc.default);
+var dayjs = import_dayjs.default;
+var now = () => dayjs();
+var today = () => dayjs().startOf("day");
+var tomorrow = () => dayjs().add(1, "day").startOf("day");
+var yesterday = () => dayjs().subtract(1, "day").startOf("day");
+var isBetweenDates = (date, start, end, unit = "day", inclusivity = "[]") => {
+  return dayjs(date).isBetween(dayjs(start), dayjs(end), unit, inclusivity);
+};
+var fromNow = (date) => dayjs(date).fromNow();
+var isToday = (date) => dayjs(date).isSame(dayjs(), "day");
+var isPast = (date) => dayjs(date).isBefore(dayjs());
+var isFuture = (date) => dayjs(date).isAfter(dayjs());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dayjs,
+  fromNow,
+  isBetweenDates,
+  isFuture,
+  isPast,
+  isToday,
+  now,
+  today,
+  tomorrow,
+  yesterday
+});

package/dist/datetime.d.cts

@@ -0,0 +1,75 @@
+import dayjsModule, { ConfigType, Dayjs } from 'dayjs';
+
+/**
+ * Date and time utilities using Day.js
+ */
+
+/**
+ * Configured Dayjs instance.
+ */
+declare const dayjs: typeof dayjsModule;
+/**
+ * Get the current date and time as a Dayjs instance.
+ *
+ * @returns {Dayjs} Current date and time
+ */
+declare const now: () => Dayjs;
+/**
+ * Get today's date at the start of the day.
+ *
+ * @returns {Dayjs} Today's date
+ */
+declare const today: () => Dayjs;
+/**
+ * Get tomorrow's date at the start of the day.
+ *
+ * @returns {Dayjs} Tomorrow's date
+ */
+declare const tomorrow: () => Dayjs;
+/**
+ * Get yesterday's date at the start of the day.
+ *
+ * @returns {Dayjs} Yesterday's date
+ */
+declare const yesterday: () => Dayjs;
+/**
+ * Check if a date is between two other dates.
+ *
+ * @param {ConfigType} date Date to check
+ * @param {ConfigType} start Start date
+ * @param {ConfigType} end End date
+ * @param {dayjsModule.OpUnitType} [unit='day'] Unit of comparison (day, month, year, etc.)
+ * @param {'()' | '[]' | '[)' | '(]'} [inclusivity='[]'] Inclusivity
+ * @returns {boolean} True if the date is between start and end
+ */
+declare const isBetweenDates: (date: ConfigType, start: ConfigType, end: ConfigType, unit?: dayjsModule.OpUnitType, inclusivity?: "()" | "[]" | "[)" | "(]") => boolean;
+/**
+ * Format a date to a human-readable relative time.
+ *
+ * @param {ConfigType} date Date to format
+ * @returns {string} Relative time (e.g., "2 hours ago")
+ */
+declare const fromNow: (date: ConfigType) => string;
+/**
+ * Check if a date is today.
+ *
+ * @param {ConfigType} date Date to check
+ * @returns {boolean} True if the date is today
+ */
+declare const isToday: (date: ConfigType) => boolean;
+/**
+ * Check if a date is in the past.
+ *
+ * @param {ConfigType} date Date to check
+ * @returns {boolean} True if the date is in the past
+ */
+declare const isPast: (date: ConfigType) => boolean;
+/**
+ * Check if a date is in the future.
+ *
+ * @param {ConfigType} date Date to check
+ * @returns {boolean} True if the date is in the future
+ */
+declare const isFuture: (date: ConfigType) => boolean;
+
+export { dayjs, fromNow, isBetweenDates, isFuture, isPast, isToday, now, today, tomorrow, yesterday };

package/dist/datetime.d.ts

@@ -0,0 +1,75 @@
+import dayjsModule, { ConfigType, Dayjs } from 'dayjs';
+
+/**
+ * Date and time utilities using Day.js
+ */
+
+/**
+ * Configured Dayjs instance.
+ */
+declare const dayjs: typeof dayjsModule;
+/**
+ * Get the current date and time as a Dayjs instance.
+ *
+ * @returns {Dayjs} Current date and time
+ */
+declare const now: () => Dayjs;
+/**
+ * Get today's date at the start of the day.
+ *
+ * @returns {Dayjs} Today's date
+ */
+declare const today: () => Dayjs;
+/**
+ * Get tomorrow's date at the start of the day.
+ *
+ * @returns {Dayjs} Tomorrow's date
+ */
+declare const tomorrow: () => Dayjs;
+/**
+ * Get yesterday's date at the start of the day.
+ *
+ * @returns {Dayjs} Yesterday's date
+ */
+declare const yesterday: () => Dayjs;
+/**
+ * Check if a date is between two other dates.
+ *
+ * @param {ConfigType} date Date to check
+ * @param {ConfigType} start Start date
+ * @param {ConfigType} end End date
+ * @param {dayjsModule.OpUnitType} [unit='day'] Unit of comparison (day, month, year, etc.)
+ * @param {'()' | '[]' | '[)' | '(]'} [inclusivity='[]'] Inclusivity
+ * @returns {boolean} True if the date is between start and end
+ */
+declare const isBetweenDates: (date: ConfigType, start: ConfigType, end: ConfigType, unit?: dayjsModule.OpUnitType, inclusivity?: "()" | "[]" | "[)" | "(]") => boolean;
+/**
+ * Format a date to a human-readable relative time.
+ *
+ * @param {ConfigType} date Date to format
+ * @returns {string} Relative time (e.g., "2 hours ago")
+ */
+declare const fromNow: (date: ConfigType) => string;
+/**
+ * Check if a date is today.
+ *
+ * @param {ConfigType} date Date to check
+ * @returns {boolean} True if the date is today
+ */
+declare const isToday: (date: ConfigType) => boolean;
+/**
+ * Check if a date is in the past.
+ *
+ * @param {ConfigType} date Date to check
+ * @returns {boolean} True if the date is in the past
+ */
+declare const isPast: (date: ConfigType) => boolean;
+/**
+ * Check if a date is in the future.
+ *
+ * @param {ConfigType} date Date to check
+ * @returns {boolean} True if the date is in the future
+ */
+declare const isFuture: (date: ConfigType) => boolean;
+
+export { dayjs, fromNow, isBetweenDates, isFuture, isPast, isToday, now, today, tomorrow, yesterday };

package/dist/datetime.js

@@ -0,0 +1,24 @@
+import {
+  dayjs,
+  fromNow,
+  isBetweenDates,
+  isFuture,
+  isPast,
+  isToday,
+  now,
+  today,
+  tomorrow,
+  yesterday
+} from "./chunk-3WNRYKPG.js";
+export {
+  dayjs,
+  fromNow,
+  isBetweenDates,
+  isFuture,
+  isPast,
+  isToday,
+  now,
+  today,
+  tomorrow,
+  yesterday
+};

package/dist/equals.cjs

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/equals.ts
+var equals_exports = {};
+__export(equals_exports, {
+  diff: () => diff,
+  isEqual: () => isEqual
+});
+module.exports = __toCommonJS(equals_exports);
+var isEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && "object" === typeof a && "object" === typeof b) {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (Array.isArray(a)) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!isEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const [key, val] of a) {
+        if (!b.has(key) || !isEqual(val, b.get(key))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const val of a) {
+        if (!b.has(val)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a.constructor === RegExp) {
+      return a.source === b.source && a.flags === b.flags;
+    }
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf();
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString();
+    }
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) {
+      return false;
+    }
+    const bObj = b;
+    const aObj = a;
+    for (const key of keys) {
+      if (!Object.prototype.hasOwnProperty.call(bObj, key)) {
+        return false;
+      }
+      if (!isEqual(aObj[key], bObj[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+};
+var diff = (original, current) => {
+  const result = {};
+  if (isEqual(original, current)) {
+    return result;
+  }
+  if (!original || !current || "object" !== typeof original || "object" !== typeof current) {
+    return current || {};
+  }
+  const originalObj = original;
+  const currentObj = current;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(originalObj), ...Object.keys(currentObj)]);
+  for (const key of keys) {
+    if (!isEqual(originalObj[key], currentObj[key])) {
+      if (originalObj[key] && currentObj[key] && "object" === typeof originalObj[key] && "object" === typeof currentObj[key] && !Array.isArray(originalObj[key])) {
+        result[key] = diff(originalObj[key], currentObj[key]);
+      } else {
+        result[key] = currentObj[key];
+      }
+    }
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diff,
+  isEqual
+});

package/dist/equals.d.cts

@@ -0,0 +1,24 @@
+import { GenericRecord } from './types.cjs';
+
+/**
+ * Deep equality and comparison utilities
+ */
+/**
+ * Perform a deep comparison between two values to determine if they are equivalent.
+ *
+ * @param {unknown} a The first value to compare
+ * @param {unknown} b The second value to compare
+ * @returns {boolean} True if the values are equivalent, false otherwise
+ */
+declare const isEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * Find the differences between two objects.
+ * Returns an object containing only the keys that differ.
+ *
+ * @param {unknown} original The original object
+ * @param {unknown} current The current object
+ * @returns {GenericRecord} An object containing the differences
+ */
+declare const diff: (original: unknown, current: unknown) => GenericRecord;
+
+export { diff, isEqual };

package/dist/equals.d.ts

@@ -0,0 +1,24 @@
+import { GenericRecord } from './types.js';
+
+/**
+ * Deep equality and comparison utilities
+ */
+/**
+ * Perform a deep comparison between two values to determine if they are equivalent.
+ *
+ * @param {unknown} a The first value to compare
+ * @param {unknown} b The second value to compare
+ * @returns {boolean} True if the values are equivalent, false otherwise
+ */
+declare const isEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * Find the differences between two objects.
+ * Returns an object containing only the keys that differ.
+ *
+ * @param {unknown} original The original object
+ * @param {unknown} current The current object
+ * @returns {GenericRecord} An object containing the differences
+ */
+declare const diff: (original: unknown, current: unknown) => GenericRecord;
+
+export { diff, isEqual };

package/dist/equals.js

@@ -0,0 +1,8 @@
+import {
+  diff,
+  isEqual
+} from "./chunk-LDSWHSRX.js";
+export {
+  diff,
+  isEqual
+};

package/dist/formatters.cjs

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/formatters.ts
+var formatters_exports = {};
+__export(formatters_exports, {
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  kebabCase: () => kebabCase,
+  normalizeString: () => normalizeString,
+  numberFormat: () => numberFormat,
+  slugify: () => slugify,
+  snakeCase: () => snakeCase,
+  strContainsAll: () => strContainsAll,
+  strContainsAny: () => strContainsAny,
+  strFinish: () => strFinish,
+  strLimit: () => strLimit,
+  strMask: () => strMask,
+  strPadBoth: () => strPadBoth,
+  strPadLeft: () => strPadLeft,
+  strPadRight: () => strPadRight,
+  strRemove: () => strRemove,
+  strReverse: () => strReverse,
+  strStart: () => strStart,
+  strWordCount: () => strWordCount,
+  strWords: () => strWords,
+  studlyCase: () => studlyCase,
+  titleCase: () => titleCase
+});
+module.exports = __toCommonJS(formatters_exports);
+var capitalize = (value) => {
+  if (value == null) {
+    return "";
+  }
+  const stringValue = String(value);
+  return stringValue.charAt(0).toUpperCase() + stringValue.slice(1).toLowerCase();
+};
+var slugify = (text) => {
+  if (!text) {
+    return "";
+  }
+  return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-");
+};
+var strLimit = (value, size) => {
+  if (!value) {
+    return "";
+  }
+  const stringValue = String(value);
+  return stringValue.length <= size ? stringValue : `${stringValue.slice(0, size)}\u2026`;
+};
+var normalizeString = (value) => {
+  if (!value) {
+    return value;
+  }
+  return value.trim().toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+};
+var strContainsAll = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.every((needle) => haystack.includes(needle));
+};
+var strContainsAny = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.some((needle) => haystack.includes(needle));
+};
+var strFinish = (value, cap) => {
+  if (!value) {
+    return cap;
+  }
+  if (!cap) {
+    return value;
+  }
+  return value.endsWith(cap) ? value : value + cap;
+};
+var strStart = (value, prefix) => {
+  if (!value) {
+    return prefix;
+  }
+  if (!prefix) {
+    return value;
+  }
+  return value.startsWith(prefix) ? value : prefix + value;
+};
+var strPadBoth = (str, length, pad = " ") => {
+  if (str.length >= length) {
+    return str;
+  }
+  const totalPad = length - str.length;
+  const leftPad = Math.floor(totalPad / 2);
+  const rightPad = totalPad - leftPad;
+  return pad.repeat(leftPad) + str + pad.repeat(rightPad);
+};
+var strPadLeft = (str, length, pad = " ") => {
+  return str.padStart(length, pad);
+};
+var strPadRight = (str, length, pad = " ") => {
+  return str.padEnd(length, pad);
+};
+var strReverse = (value) => {
+  return value.split("").reverse().join("");
+};
+var strRemove = (search, subject, caseSensitive = true) => {
+  if (!search || !subject) {
+    return subject;
+  }
+  const flags = caseSensitive ? "g" : "gi";
+  return subject.replace(new RegExp(search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags), "");
+};
+var strMask = (str, character, index, length) => {
+  if (!str) {
+    return str;
+  }
+  const start = Math.max(0, index);
+  const end = length !== void 0 ? start + length : str.length;
+  return str.substring(0, start) + character.repeat(end - start) + str.substring(end);
+};
+var strWordCount = (str, characters) => {
+  if (!str) {
+    return 0;
+  }
+  const pattern = characters ? new RegExp(`[${characters}\\s]+`) : /\s+/;
+  return str.trim().split(pattern).filter((word) => 0 < word.length).length;
+};
+var strWords = (value, words = 100, end = "...") => {
+  if (!value) {
+    return "";
+  }
+  const wordArray = value.trim().split(/\s+/);
+  if (wordArray.length <= words) {
+    return value;
+  }
+  return wordArray.slice(0, words).join(" ") + end;
+};
+var camelCase = (value) => {
+  const studly = studlyCase(value);
+  return studly.charAt(0).toLowerCase() + studly.slice(1);
+};
+var snakeCase = (value) => {
+  return value.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+};
+var kebabCase = (value) => {
+  return value.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+};
+var studlyCase = (value) => {
+  return value.replace(/[_-]/g, " ").replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase()).replace(/\s+/g, "");
+};
+var titleCase = (value) => {
+  return value.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+  });
+};
+var numberFormat = (value, decimals = 2, locale = "en-US") => {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  camelCase,
+  capitalize,
+  kebabCase,
+  normalizeString,
+  numberFormat,
+  slugify,
+  snakeCase,
+  strContainsAll,
+  strContainsAny,
+  strFinish,
+  strLimit,
+  strMask,
+  strPadBoth,
+  strPadLeft,
+  strPadRight,
+  strRemove,
+  strReverse,
+  strStart,
+  strWordCount,
+  strWords,
+  studlyCase,
+  titleCase
+});