@zairakai/js-utils 1.0.0

package/dist/arrays.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Array manipulation and utility functions
+ * Inspired by Laravel's array helpers
+ */
+/**
+ * Add an element to an array or record at a specific key.
+ *
+ * @param {T[] | Record<string, T>} array The source array or record
+ * @param {string} key The key to add the value at
+ * @param {T} value The value to add
+ * @returns {Record<string, unknown>} The resulting record
+ */
+declare const arrayAdd: <T>(array: T[] | Record<string, T>, key: string, value: T) => Record<string, unknown>;
+/**
+ * Collapse an array of arrays into a single array.
+ *
+ * @param {T[][]} array The array of arrays to collapse
+ * @returns {T[]} The collapsed array
+ */
+declare const arrayCollapse: <T>(array: T[][]) => T[];
+/**
+ * Divide an array into two arrays: one with keys (indices) and one with values.
+ *
+ * @param {T[]} array The array to divide
+ * @returns {[string[], T[]]} A tuple containing keys and values
+ */
+declare const arrayDivide: <T>(array: T[]) => [string[], T[]];
+/**
+ * Flatten a multi-dimensional record into a single-level record using dot notation.
+ *
+ * @param {Record<string, unknown>} array The record to flatten
+ * @param {string} prepend The string to prepend to keys
+ * @returns {Record<string, unknown>} The flattened record
+ */
+declare const arrayDot: (array: Record<string, unknown>, prepend?: string) => Record<string, unknown>;
+/**
+ * Get all of the given array except for a specified array of keys (indices).
+ *
+ * @param {T[]} array The source array
+ * @param {string[]} keys The keys to exclude
+ * @returns {T[]} The filtered array
+ */
+declare const arrayExcept: <T>(array: T[], keys: string[]) => T[];
+/**
+ * Return the first element in an array passing a given truth test.
+ *
+ * @param {T[]} array The source array
+ * @param {Function} [callback] Optional callback for truth test
+ * @param {T} [defaultValue] Optional default value if no element found
+ * @returns {T | undefined} The first matching element or default value
+ */
+declare const arrayFirst: <T>(array: T[], callback?: (item: T, index: number) => boolean, defaultValue?: T) => T | undefined;
+/**
+ * Flatten a multi-dimensional array into a single level.
+ *
+ * @param {unknown[]} array The array to flatten
+ * @param {number} [depth=Infinity] The depth to flatten to
+ * @returns {T[]} The flattened array
+ */
+declare const arrayFlatten: <T>(array: unknown[], depth?: number) => T[];
+/**
+ * Get an item from a record using dot notation.
+ *
+ * @param {Record<string, unknown>} array The source record
+ * @param {string} key The key to retrieve
+ * @param {unknown} [defaultValue] The default value if key not found
+ * @returns {unknown} The value at the key or default value
+ */
+declare const arrayGet: (array: Record<string, unknown>, key: string, defaultValue?: unknown) => unknown;
+/**
+ * Check if an item or items exist in a record using "dot" notation.
+ *
+ * @param {Record<string, unknown>} array The source record
+ * @param {string | string[]} keys The key or keys to check
+ * @returns {boolean} True if all keys exist, false otherwise
+ */
+declare const arrayHas: (array: Record<string, unknown>, keys: string | string[]) => boolean;
+/**
+ * Get a subset of the array's elements specified by keys (indices).
+ *
+ * @param {T[]} array The source array
+ * @param {string[]} keys The keys to include
+ * @returns {T[]} The filtered array
+ */
+declare const arrayOnly: <T>(array: T[], keys: string[]) => T[];
+/**
+ * Filter the array using the given callback.
+ *
+ * @param {T[]} array The source array
+ * @param {Function} callback The callback to use for filtering
+ * @returns {T[]} The filtered array
+ */
+declare const arrayWhere: <T>(array: T[], callback: (item: T, index: number) => boolean) => T[];
+/**
+ * Pluck an array of values from an array of objects.
+ *
+ * @param {T[]} array The source array
+ * @param {K} key The key to pluck
+ * @returns {T[K][]} The plucked values
+ */
+declare const arrayPluck: <T, K extends keyof T>(array: T[], key: K) => T[K][];
+/**
+ * Group an array's items by a given key or callback.
+ *
+ * @param {T[]} array The source array
+ * @param {keyof T | Function} keyOrFn The key or callback to group by
+ * @returns {Record<string, T[]>} The grouped items
+ */
+declare const arrayGroupBy: <T>(array: T[], keyOrFn: keyof T | ((item: T) => string | number)) => Record<string, T[]>;
+/**
+ * Filter the array to only unique elements.
+ *
+ * @param {T[]} array The source array
+ * @param {keyof T} [key] Optional key to use for uniqueness
+ * @returns {T[]} The array with unique elements
+ */
+declare const arrayUnique: <T>(array: T[], key?: keyof T) => T[];
+
+export { arrayAdd, arrayCollapse, arrayDivide, arrayDot, arrayExcept, arrayFirst, arrayFlatten, arrayGet, arrayGroupBy, arrayHas, arrayOnly, arrayPluck, arrayUnique, arrayWhere };

package/dist/arrays.js

@@ -0,0 +1,32 @@
+import {
+  arrayAdd,
+  arrayCollapse,
+  arrayDivide,
+  arrayDot,
+  arrayExcept,
+  arrayFirst,
+  arrayFlatten,
+  arrayGet,
+  arrayGroupBy,
+  arrayHas,
+  arrayOnly,
+  arrayPluck,
+  arrayUnique,
+  arrayWhere
+} from "./chunk-7SXRFZBB.js";
+export {
+  arrayAdd,
+  arrayCollapse,
+  arrayDivide,
+  arrayDot,
+  arrayExcept,
+  arrayFirst,
+  arrayFlatten,
+  arrayGet,
+  arrayGroupBy,
+  arrayHas,
+  arrayOnly,
+  arrayPluck,
+  arrayUnique,
+  arrayWhere
+};

package/dist/chunk-27YHP2CK.js

@@ -0,0 +1,407 @@
+import {
+  camelCase,
+  capitalize,
+  kebabCase,
+  slugify,
+  snakeCase,
+  strContainsAll,
+  strContainsAny,
+  strFinish,
+  strLimit,
+  strMask,
+  strReverse,
+  strStart,
+  studlyCase,
+  titleCase
+} from "./chunk-F6RSTW65.js";
+
+// src/str.ts
+var Stringable = class {
+  constructor(value) {
+    this.value = String(value ?? "");
+  }
+  /**
+   * Get the raw string value
+   *
+   * @returns {string} The raw string
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Alias for toString()
+   *
+   * @returns {string} The raw string
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Convert to title case
+   *
+   * @returns {this} The Stringable instance
+   */
+  title() {
+    this.value = titleCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to slug
+   *
+   * @returns {this} The Stringable instance
+   */
+  slug() {
+    this.value = slugify(this.value);
+    return this;
+  }
+  /**
+   * Convert to snake_case
+   *
+   * @returns {this} The Stringable instance
+   */
+  snake() {
+    this.value = snakeCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to kebab-case
+   *
+   * @returns {this} The Stringable instance
+   */
+  kebab() {
+    this.value = kebabCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to camelCase
+   *
+   * @returns {this} The Stringable instance
+   */
+  camel() {
+    this.value = camelCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to StudlyCase
+   *
+   * @returns {this} The Stringable instance
+   */
+  studly() {
+    this.value = studlyCase(this.value);
+    return this;
+  }
+  /**
+   * Limit the string length
+   *
+   * @param {number} size The maximum length
+   * @param {string} [end='…'] The string to append if limited
+   * @returns {this} The Stringable instance
+   */
+  limit(size, end = "\u2026") {
+    this.value = strLimit(this.value, size);
+    if (this.value.endsWith("\u2026") && "\u2026" !== end) {
+      this.value = this.value.slice(0, -1) + end;
+    }
+    return this;
+  }
+  /**
+   * Append a value to the string
+   *
+   * @param {...unknown[]} values The values to append
+   * @returns {this} The Stringable instance
+   */
+  append(...values) {
+    this.value += values.join("");
+    return this;
+  }
+  /**
+   * Prepend a value to the string
+   *
+   * @param {...unknown[]} values The values to prepend
+   * @returns {this} The Stringable instance
+   */
+  prepend(...values) {
+    this.value = values.join("") + this.value;
+    return this;
+  }
+  /**
+   * Cap the string with a value if it doesn't already end with it
+   *
+   * @param {string} cap The string to end with
+   * @returns {this} The Stringable instance
+   */
+  finish(cap) {
+    this.value = strFinish(this.value, cap);
+    return this;
+  }
+  /**
+   * Start the string with a value if it doesn't already start with it
+   *
+   * @param {string} prefix The string to start with
+   * @returns {this} The Stringable instance
+   */
+  start(prefix) {
+    this.value = strStart(this.value, prefix);
+    return this;
+  }
+  /**
+   * Replace the first occurrence of a value
+   *
+   * @param {string | RegExp} search The value to search for
+   * @param {string} replace The value to replace with
+   * @returns {this} The Stringable instance
+   */
+  replace(search, replace) {
+    this.value = this.value.replace(search, replace);
+    return this;
+  }
+  /**
+   * Replace all occurrences of a value
+   *
+   * @param {string | RegExp} search The value to search for
+   * @param {string} replace The value to replace with
+   * @returns {this} The Stringable instance
+   */
+  replaceAll(search, replace) {
+    if ("string" === typeof search) {
+      this.value = this.value.split(search).join(replace);
+    } else {
+      const flags = search.flags.includes("g") ? search.flags : `${search.flags}g`;
+      this.value = this.value.replace(new RegExp(search.source, flags), replace);
+    }
+    return this;
+  }
+  /**
+   * Reverse the string
+   *
+   * @returns {this} The Stringable instance
+   */
+  reverse() {
+    this.value = strReverse(this.value);
+    return this;
+  }
+  /**
+   * Mask a portion of the string
+   *
+   * @param {string} character The masking character
+   * @param {number} index The starting index
+   * @param {number} [length] The number of characters to mask
+   * @returns {this} The Stringable instance
+   */
+  mask(character, index, length) {
+    this.value = strMask(this.value, character, index, length);
+    return this;
+  }
+  /**
+   * Trim the string
+   *
+   * @param {string} [chars] The characters to trim (defaults to whitespace)
+   * @returns {this} The Stringable instance
+   */
+  trim(chars) {
+    if (!chars) {
+      this.value = this.value.trim();
+    } else {
+      const pattern = new RegExp(`^[${chars}]+|[${chars}]+$`, "g");
+      this.value = this.value.replace(pattern, "");
+    }
+    return this;
+  }
+  /**
+   * Convert to lower case
+   *
+   * @returns {this} The Stringable instance
+   */
+  lower() {
+    this.value = this.value.toLowerCase();
+    return this;
+  }
+  /**
+   * Convert to upper case
+   *
+   * @returns {this} The Stringable instance
+   */
+  upper() {
+    this.value = this.value.toUpperCase();
+    return this;
+  }
+  /**
+   * Capitalize the first letter
+   *
+   * @returns {this} The Stringable instance
+   */
+  capitalize() {
+    this.value = capitalize(this.value);
+    return this;
+  }
+  /**
+   * Check if string contains a value
+   *
+   * @param {string | string[]} needles The values to search for
+   * @returns {boolean} True if the string contains any of the values
+   */
+  contains(needles) {
+    if (Array.isArray(needles)) {
+      return strContainsAny(this.value, needles);
+    }
+    return this.value.includes(needles);
+  }
+  /**
+   * Check if string contains all values
+   *
+   * @param {string[]} needles The values to search for
+   * @returns {boolean} True if the string contains all values
+   */
+  containsAll(needles) {
+    return strContainsAll(this.value, needles);
+  }
+  /**
+   * Check if string starts with a value
+   *
+   * @param {string | string[]} needles The values to check
+   * @returns {boolean} True if the string starts with any of the values
+   */
+  startsWith(needles) {
+    if (Array.isArray(needles)) {
+      return needles.some((needle) => this.value.startsWith(needle));
+    }
+    return this.value.startsWith(needles);
+  }
+  /**
+   * Check if string ends with a value
+   *
+   * @param {string | string[]} needles The values to check
+   * @returns {boolean} True if the string ends with any of the values
+   */
+  endsWith(needles) {
+    if (Array.isArray(needles)) {
+      return needles.some((needle) => this.value.endsWith(needle));
+    }
+    return this.value.endsWith(needles);
+  }
+  /**
+   * Execute a callback with the stringable and return the result
+   *
+   * @param {(str: this) => U} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Conditionally execute a callback
+   *
+   * @param {boolean | (() => boolean)} condition The condition to check
+   * @param {(str: this) => void} callback The callback to execute
+   * @returns {this} The Stringable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+  /**
+   * Execute a callback and return the stringable (for side effects)
+   *
+   * @param {(str: this) => void} callback The callback to execute
+   * @returns {this} The Stringable instance
+   */
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+};
+var str = (value) => {
+  return new Stringable(value);
+};
+var Str = {
+  /**
+   * Create a new fluent stringable instance
+   *
+   * @param {unknown} value The initial string value
+   * @returns {Stringable} A new Stringable instance
+   */
+  of: (value) => new Stringable(value),
+  /**
+   * Convert a string to a slug
+   *
+   * @param {string} value The string to slugify
+   * @returns {string} The slugified string
+   */
+  slug: (value) => slugify(value),
+  /**
+   * Convert a string to snake_case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The snake_case string
+   */
+  snake: (value) => snakeCase(value),
+  /**
+   * Convert a string to kebab-case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The kebab-case string
+   */
+  kebab: (value) => kebabCase(value),
+  /**
+   * Convert a string to camelCase
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The camelCase string
+   */
+  camel: (value) => camelCase(value),
+  /**
+   * Convert a string to StudlyCase
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The StudlyCase string
+   */
+  studly: (value) => studlyCase(value),
+  /**
+   * Convert a string to title case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The title case string
+   */
+  title: (value) => titleCase(value),
+  /**
+   * Limit the length of a string
+   *
+   * @param {string} value The string to limit
+   * @param {number} size The maximum length
+   * @param {string} [end='…'] The string to append if limited
+   * @returns {string} The limited string
+   */
+  limit: (value, size, end = "\u2026") => {
+    const result = strLimit(value, size);
+    return result.endsWith("\u2026") && "\u2026" !== end ? result.slice(0, -1) + end : result;
+  },
+  /**
+   * Generate a random alphanumeric string
+   *
+   * @param {number} [length=16] The length of the random string
+   * @returns {string} The random string
+   */
+  random: (length = 16) => {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  },
+  /**
+   * Generate a UUID (version 4)
+   *
+   * @returns {string} The generated UUID
+   */
+  uuid: () => crypto.randomUUID()
+};
+
+export {
+  Stringable,
+  str,
+  Str
+};

package/dist/chunk-3WNRYKPG.js

@@ -0,0 +1,37 @@
+// src/datetime.ts
+import dayjsModule from "dayjs";
+import isBetween from "dayjs/plugin/isBetween";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter";
+import isSameOrBefore from "dayjs/plugin/isSameOrBefore";
+import relativeTime from "dayjs/plugin/relativeTime";
+import utc from "dayjs/plugin/utc";
+dayjsModule.extend(isBetween);
+dayjsModule.extend(isSameOrAfter);
+dayjsModule.extend(isSameOrBefore);
+dayjsModule.extend(relativeTime);
+dayjsModule.extend(utc);
+var dayjs = dayjsModule;
+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());
+
+export {
+  dayjs,
+  now,
+  today,
+  tomorrow,
+  yesterday,
+  isBetweenDates,
+  fromNow,
+  isToday,
+  isPast,
+  isFuture
+};