@h3ravel/support 0.14.4 → 0.14.5

package/dist/index.cjs

@@ -30,7 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 let crypto = require("crypto");
-crypto = __toESM(crypto);
 let process = require("process");
 process = __toESM(process);
 let util = require("util");
@@ -1559,6 +1558,15 @@ var DateTime = class DateTime extends TimeClass {
 		return this.startOf(unit);
 	}
 	/**
+	* Set the timezone for the instance
+	* 
+	* @param timezone 
+	* @returns 
+	*/
+	setTimezone(timezone$1, keepLocalTime) {
+		return new DateTime(this.tz(timezone$1, keepLocalTime));
+	}
+	/**
 	* End time of a specific unit.
 	* 
 	* @returns 
@@ -1613,7 +1621,7 @@ var DateTime = class DateTime extends TimeClass {
 	* @return {Date} object
 	*/
 	static fromTimestamp(timestamp) {
-		return /* @__PURE__ */ new Date(timestamp * 1e3);
+		return new DateTime(timestamp * 1e3);
 	}
 	/**
 	* Get current time instance.

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 /// <reference path="./app.globals.d.ts" />
-import { t as __export } from "./chunk-Bop6jNiL.js";
-import dayjs, { ConfigType, Dayjs, OpUnitType } from "dayjs";
+import "node:module";
 import { DotFlatten, DotNestedKeys, DotNestedValue } from "@h3ravel/shared";
+import dayjs, { ConfigType, Dayjs, OpUnitType } from "dayjs";
 
+//#region rolldown:runtime
+//#endregion
 //#region src/Contracts/StrContract.d.ts
 /**
  * Converts CamelCased strings to snake_case
@@ -33,10 +35,10 @@ interface Function {
  * Convert CamelCased Object keys to snake_case
  */
 type KeysToSnakeCase<T$1> = { [K in keyof T$1 as CamelToSnakeCase<string & K>]: T$1[K] };
-type TGeneric<V$1 = any, K$1 extends string = string> = Record<K$1, V$1>;
-type XGeneric<V$1 = TGeneric, T$1 = any> = {
+type TGeneric<V = any, K$1 extends string = string> = Record<K$1, V>;
+type XGeneric<V = TGeneric, T$1 = any> = {
   [key: string]: T$1;
-} & V$1;
+} & V;
 type DotPath<T$1> = T$1 extends object ? { [K in keyof T$1 & (string | number)]: T$1[K] extends object ? `${K}` | `${K}.${DotPath<T$1[K]>}` : `${K}` }[keyof T$1 & (string | number)] : never;
 //#endregion
 //#region src/Contracts/TypeCast.d.ts
@@ -261,7 +263,7 @@ declare namespace Obj_d_exports {
  * @param obj - The nested object to flatten
  * @returns A flattened object with dotted keys and inferred types
  */
-declare const dot: <T extends Record<string, any>>(obj: T) => DotFlatten<T>;
+declare const dot: <T$1 extends Record<string, any>>(obj: T$1) => DotFlatten<T$1>;
 /**
  * Extracts a subset of properties from an object.
  *
@@ -271,7 +273,7 @@ declare const dot: <T extends Record<string, any>>(obj: T) => DotFlatten<T>;
  * @param keys - Array of keys to extract
  * @returns A new object with only the specified keys
  */
-declare const extractProperties: <T extends object, K extends keyof T>(obj: T, keys?: readonly K[]) => Pick<T, K>;
+declare const extractProperties: <T$1 extends object, K$1 extends keyof T$1>(obj: T$1, keys?: readonly K$1[]) => Pick<T$1, K$1>;
 /**
  * Safely retrieves a value from an object by key or nested keys.
  *
@@ -280,7 +282,7 @@ declare const extractProperties: <T extends object, K extends keyof T>(obj: T, k
  * @param item - The source object
  * @returns The found value as a string or the key itself if not found
  */
-declare const getValue: <T extends Record<string, any>>(key: string | [keyof T, keyof T[string]], item: T) => string;
+declare const getValue: <T$1 extends Record<string, any>>(key: string | [keyof T$1, keyof T$1[string]], item: T$1) => string;
 /**
  * Maps over an object's entries and returns a new object
  * with transformed keys and/or values.
@@ -291,7 +293,7 @@ declare const getValue: <T extends Record<string, any>>(key: string | [keyof T,
  * @param callback - Function that receives [key, value] and returns [newKey, newValue]
  * @returns A new object with transformed entries
  */
-declare const modObj: <T extends object, R>(obj: T, callback: (_entry: [keyof T & string, T[keyof T]]) => [string, R]) => Record<string, R>;
+declare const modObj: <T$1 extends object, R>(obj: T$1, callback: (_entry: [keyof T$1 & string, T$1[keyof T$1]]) => [string, R]) => Record<string, R>;
 declare function safeDot<T$1 extends Record<string, any>>(_data: T$1): T$1;
 declare function safeDot<T$1 extends Record<string, any>, K$1 extends DotNestedKeys<T$1>>(_data: T$1, _key?: K$1): DotNestedValue<T$1, K$1>;
 /**
@@ -317,7 +319,7 @@ declare const setNested: (obj: Record<string, any>, key: string, value: any) =>
  * @param separator - Separator for slugified keys (default: "_")
  * @returns A new object with slugified keys
  */
-declare const slugifyKeys: <T extends object>(obj: T, only?: string[], separator?: string) => KeysToSnakeCase<T>;
+declare const slugifyKeys: <T$1 extends object>(obj: T$1, only?: string[], separator?: string) => KeysToSnakeCase<T$1>;
 /**
  * toCssClasses
  *
@@ -348,13 +350,13 @@ declare function undot(obj: Record<string, any>): Record<string, any>;
  *
  * Get a value from an object using dot notation.
  */
-declare function data_get<T$1 extends object, P$1 extends DotPath<T$1> | DotPath<T$1>[], D$1 = undefined>(obj: T$1, path: P$1, defaultValue?: D$1): T$1 | any;
+declare function data_get<T$1 extends object, P extends DotPath<T$1> | DotPath<T$1>[], D = undefined>(obj: T$1, path: P, defaultValue?: D): T$1 | any;
 /**
  * data_set
  *
  * Set a value in an object using dot notation. Mutates the object.
  */
-declare function data_set<T$1 extends Record<string, any>, P$1 extends string | string[], V$1>(obj: T$1, path: P$1, value: V$1): asserts obj is T$1 & Record<P$1 extends string ? P$1 : P$1[0], V$1>;
+declare function data_set<T$1 extends Record<string, any>, P extends string | string[], V>(obj: T$1, path: P, value: V): asserts obj is T$1 & Record<P extends string ? P : P[0], V>;
 /**
  * data_fill
  *
@@ -384,7 +386,7 @@ declare class Obj {
    *
    * Returns a new object (does not mutate original).
    */
-  static add<T extends Record<string, any>, K extends string, V>(obj: T, key: K, value: V): T & Record<K, V>;
+  static add<T$1 extends Record<string, any>, K$1 extends string, V>(obj: T$1, key: K$1, value: V): T$1 & Record<K$1, V>;
   /**
    * Deeply merges two or more objects.
    * - Arrays are replaced (not concatenated)
@@ -394,26 +396,26 @@ declare class Obj {
    * @param objects
    * @returns
    */
-  static deepMerge<T extends Record<string, any>>(...objects: (Partial<T> | undefined | null)[]): T;
+  static deepMerge<T$1 extends Record<string, any>>(...objects: (Partial<T$1> | undefined | null)[]): T$1;
   /**
    * Split object into [keys, values]
    */
-  static divide<T extends Record<string, any>>(obj: T): [string[], any[]];
+  static divide<T$1 extends Record<string, any>>(obj: T$1): [string[], any[]];
   /**
    * Check if a key exists in the object.
    */
-  static exists<T extends Record<string, any>>(obj: T, key: string | number): boolean;
+  static exists<T$1 extends Record<string, any>>(obj: T$1, key: string | number): boolean;
   /**
    * Get a value from an object using dot notation.
    *
    * Example:
    * Obj.get({a:{b:1}}, 'a.b') -> 1
    */
-  static get<T extends object, P extends DotPath<T>, D = undefined>(obj: T, path: P, defaultValue?: D): any;
+  static get<T$1 extends object, P extends DotPath<T$1>, D = undefined>(obj: T$1, path: P, defaultValue?: D): any;
   /**
    * Check if the object has a given key or keys (dot notation supported).
    */
-  static has<T extends object, P extends DotPath<T>>(obj: T, keys: P | P[]): boolean;
+  static has<T$1 extends object, P extends DotPath<T$1>>(obj: T$1, keys: P | P[]): boolean;
   /**
    * Check if an object is associative (has at least one non-numeric key).
    */
@@ -421,7 +423,7 @@ declare class Obj {
   /**
    * Add a prefix to all keys of the object.
    */
-  static prependKeysWith<T extends Record<string, any>>(obj: T, prefix: string): Record<string, any>;
+  static prependKeysWith<T$1 extends Record<string, any>>(obj: T$1, prefix: string): Record<string, any>;
   /**
    * Convert an object into a URL query string.
    *
@@ -482,7 +484,7 @@ declare class Arr {
    * Arr.divide(['a','b']) -> [[0,1], ['a','b']]
    * Arr.divide({x:1,y:2}) -> [['x','y'], [1,2]]
    */
-  static divide<A>(input: A[] | Record<string, A>): (number[] | A[])[] | (string[] | A[])[];
+  static divide<A>(input: A[] | Record<string, A>): (A[] | number[])[] | (A[] | string[])[];
   /**
    * Flatten a nested array/object structure into a single-level object
    * with dot-notated keys.
@@ -496,7 +498,7 @@ declare class Arr {
   /**
    * Checks if all elements satisfy the predicate
    */
-  static every<T>(array: T[], predicate: (item: T) => boolean): boolean;
+  static every<T$1>(array: T$1[], predicate: (item: T$1) => boolean): boolean;
   /**
    * Remove items by keys/indices from an array or properties from an object.
    *
@@ -551,11 +553,11 @@ declare class Arr {
    * Converts various input types into a plain array
    * Supports Arrays, Objects, Iterables, Map, WeakMap, and custom toArray/toJSON/jsonSerialize methods
    */
-  static from<T>(value: T | Iterable<T> | Arrayable | Jsonable | JsonSerializable | null | undefined): any[];
+  static from<T$1>(value: T$1 | Iterable<T$1> | Arrayable | Jsonable | JsonSerializable | null | undefined): any[];
   /**
    * Checks if an object has all the specified keys
    */
-  static hasAll<T extends object>(obj: T, keys: (keyof T)[]): boolean;
+  static hasAll<T$1 extends object>(obj: T$1, keys: (keyof T$1)[]): boolean;
   /**
    * For arrays: check if the array contains any of the provided values.
    *
@@ -592,7 +594,7 @@ declare class Arr {
    * Example:
    * Arr.keyBy([{id:1},{id:2}], 'id') -> { '1': {id:1}, '2': {id:2} }
    */
-  static keyBy<T>(array: T[], key: keyof T | ((item: T) => string | number)): Record<string, T>;
+  static keyBy<T$1>(array: T$1[], key: keyof T$1 | ((item: T$1) => string | number)): Record<string, T$1>;
   /**
    * Get the last element of an array, optionally matching a predicate,
    * or the last element if no predicate is provided, otherwise the defaultValue.
@@ -607,15 +609,15 @@ declare class Arr {
    *
    * @returns
    */
-  static last<T, P extends ((item: T) => boolean) | true>(array: T[], predicate?: P | T, defaultValue?: T): P extends true ? [T, T[]] : T | undefined;
+  static last<T$1, P extends ((item: T$1) => boolean) | true>(array: T$1[], predicate?: P | T$1, defaultValue?: T$1): P extends true ? [T$1, T$1[]] : T$1 | undefined;
   /**
    * Transform each element in an array using a callback.
    */
-  static map<T, U>(array: T[], callback: (item: T, index: number) => U): U[];
+  static map<T$1, U$1>(array: T$1[], callback: (item: T$1, index: number) => U$1): U$1[];
   /**
    * Maps a multi-dimensional array with a spread callback
    */
-  static mapSpread<T extends any[], U>(array: T[], callback: (...items: T) => U): U[];
+  static mapSpread<T$1 extends any[], U$1>(array: T$1[], callback: (...items: T$1) => U$1): U$1[];
   /**
    * Map each element to a key-value pair.
    *
@@ -623,25 +625,25 @@ declare class Arr {
    * Arr.mapWithKeys([{id:1, name:'A'}], x => [x.id, x.name])
    * -> { '1': 'A' }
    */
-  static mapWithKeys<T, K extends string | number, V>(array: T[], callback: (item: T, index: number) => [K, V]): Record<string, V>;
+  static mapWithKeys<T$1, K$1 extends string | number, V>(array: T$1[], callback: (item: T$1, index: number) => [K$1, V]): Record<string, V>;
   /**
    * Return only elements at the given indices.
    *
    * Example:
    * Arr.only([10,20,30], [0,2]) -> [10,30]
    */
-  static only<T>(array: T[], keys: number | number[]): T[];
+  static only<T$1>(array: T$1[], keys: number | number[]): T$1[];
   /**
    * Split an array into two arrays based on a predicate
    */
-  static partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]];
+  static partition<T$1>(array: T$1[], predicate: (item: T$1) => boolean): [T$1[], T$1[]];
   /**
    * Extract a property from each element in an array of objects.
    *
    * Example:
    * Arr.pluck([{name:'A'},{name:'B'}], 'name') -> ['A','B']
    */
-  static pluck<T, K extends keyof T>(array: T[], key: K): T[K][];
+  static pluck<T$1, K$1 extends keyof T$1>(array: T$1[], key: K$1): T$1[K$1][];
   /**
    * Add elements to the beginning of an array and return a new array.
    *
@@ -649,56 +651,56 @@ declare class Arr {
    * @param value
    * @returns
    */
-  static prepend<T>(array: T[], ...value: T[]): T[];
+  static prepend<T$1>(array: T$1[], ...value: T$1[]): T$1[];
   /**
    * Remove a value from an array by index and return it.
    * Returns a tuple: [newArray, removedValue]
    */
-  static pull<T>(array: T[], key: number): [T[], T | undefined];
+  static pull<T$1>(array: T$1[], key: number): [T$1[], T$1 | undefined];
   /**
    * Append values to an array (mutable)
    */
-  static push<T>(array: T[], ...values: T[]): T[];
+  static push<T$1>(array: T$1[], ...values: T$1[]): T$1[];
   /**
    * Pick one or more random elements from an array.
    */
-  static random<T>(array: T[], count?: number): T | T[] | undefined;
+  static random<T$1>(array: T$1[], count?: number): T$1 | T$1[] | undefined;
   /**
    * Returns array elements that do NOT satisfy the predicate
    */
-  static reject<T>(array: T[], predicate: (item: T) => boolean): T[];
+  static reject<T$1>(array: T$1[], predicate: (item: T$1) => boolean): T$1[];
   /**
    * Pick keys from an array of objects or an object
    */
-  static select<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+  static select<T$1 extends object, K$1 extends keyof T$1>(obj: T$1, keys: K$1[]): Pick<T$1, K$1>;
   /**
    * Returns the only element that passes a callback, throws if none or multiple
    */
-  static sole<T>(array: T[], predicate: (item: T) => boolean): T;
+  static sole<T$1>(array: T$1[], predicate: (item: T$1) => boolean): T$1;
   /**
    * Checks if at least one element satisfies the predicate
    */
-  static some<T>(array: T[], predicate: (item: T) => boolean): boolean;
+  static some<T$1>(array: T$1[], predicate: (item: T$1) => boolean): boolean;
   /**
    * Randomly shuffle an array and return a new array.
    */
-  static shuffle<T>(array: T[]): T[];
+  static shuffle<T$1>(array: T$1[]): T$1[];
   /**
    * Sort an array ascending using optional comparator.
    */
-  static sort<T>(array: T[], comparator?: (a: T, b: T) => number): T[];
+  static sort<T$1>(array: T$1[], comparator?: (a: T$1, b: T$1) => number): T$1[];
   /**
    * Sort an array descending using optional comparator.
    */
-  static sortDesc<T>(array: T[], comparator?: (a: T, b: T) => number): T[];
+  static sortDesc<T$1>(array: T$1[], comparator?: (a: T$1, b: T$1) => number): T$1[];
   /**
    * Recursively sort arrays inside an array.
    */
-  static sortRecursive<T>(array: T[]): T[];
+  static sortRecursive<T$1>(array: T$1[]): T$1[];
   /**
    * Recursively sort arrays inside an array descending.
    */
-  static sortRecursiveDesc<T>(array: T[]): T[];
+  static sortRecursiveDesc<T$1>(array: T$1[]): T$1[];
   /**
    * Retrieve a value using dot notation
    * Throws if value is not a string
@@ -711,15 +713,15 @@ declare class Arr {
    * @param count
    * @returns
    */
-  static take<T>(array: T[], count: number): T[];
+  static take<T$1>(array: T$1[], count: number): T$1[];
   /**
    * Filter an array based on a predicate function or key-value match.
    */
-  static where<T>(array: T[], predicate: ((item: T) => boolean) | Partial<T>): T[];
+  static where<T$1>(array: T$1[], predicate: ((item: T$1) => boolean) | Partial<T$1>): T$1[];
   /**
    * Filter an array of objects, keeping elements where the given key is not null/undefined.
    */
-  static whereNotNull<T>(array: T[], key: keyof T): T[];
+  static whereNotNull<T$1>(array: T$1[], key: keyof T$1): T$1[];
   /**
    * If the given value is not an array and not null, wrap it in one.
    *
@@ -728,11 +730,11 @@ declare class Arr {
    * @param value
    * @returns
    */
-  static wrap<T>(value: T | T[] | null | undefined): T[];
+  static wrap<T$1>(value: T$1 | T$1[] | null | undefined): T$1[];
   /**
    * Return the first element of an array, undefined if empty.
    */
-  static head<T>(array: T[]): T | undefined;
+  static head<T$1>(array: T$1[]): T$1 | undefined;
   /**
    * Splits an array into chunks of a specified size.
    *
@@ -741,7 +743,7 @@ declare class Arr {
    * @param size - Size of each chunk (default: 2)
    * @returns An array of chunks (arrays)
    */
-  static chunk: <T>(arr: T[], size?: number) => T[][];
+  static chunk: <T$1>(arr: T$1[], size?: number) => T$1[][];
   /**
    * Alternates between two arrays, creating a zipped result.
    *
@@ -749,7 +751,7 @@ declare class Arr {
    * @param b
    * @returns
    */
-  static alternate<T>(a: T[], b: T[]): T[];
+  static alternate<T$1>(a: T$1[], b: T$1[]): T$1[];
   /**
    * Combine arrays and sum their values element by element.
    *
@@ -764,35 +766,35 @@ declare class Arr {
    * @param arr
    * @returns
    */
-  static find<T>(key: T, arr: T[]): T | null;
+  static find<T$1>(key: T$1, arr: T$1[]): T$1 | null;
   /**
    * Check if array is empty.
    *
    * @param arr
    * @returns
    */
-  static isEmpty<T>(arr: T[]): boolean;
+  static isEmpty<T$1>(arr: T$1[]): boolean;
   /**
    * Check if array is empty.
    *
    * @param arr
    * @returns
    */
-  static isNotEmpty<T>(arr: T[]): boolean;
+  static isNotEmpty<T$1>(arr: T$1[]): boolean;
   /**
    * Pop the element off the end of array.
    *
    * @param arr
    * @returns
    */
-  static pop<T>(arr: T[]): T[];
+  static pop<T$1>(arr: T$1[]): T$1[];
   /**
    * Create a new array in reverse order.
    *
    * @param arr
    * @returns
    */
-  static reverse<T>(arr: T[]): T[];
+  static reverse<T$1>(arr: T$1[]): T$1[];
   /**
    * Return the first element of an array that satisfies the predicate,
    * or the first element if no predicate is provided, otherwise the defaultValue.
@@ -833,6 +835,13 @@ declare class DateTime extends TimeClass {
    * @returns
    */
   start(unit?: OpUnitType): dayjs.Dayjs;
+  /**
+   * Set the timezone for the instance
+   *
+   * @param timezone
+   * @returns
+   */
+  setTimezone(timezone?: string | undefined, keepLocalTime?: boolean | undefined): DateTime;
   /**
    * End time of a specific unit.
    *
@@ -869,7 +878,7 @@ declare class DateTime extends TimeClass {
    *
    * @return {Date} object
    */
-  static fromTimestamp(timestamp: number): Date;
+  static fromTimestamp(timestamp: number): DateTime;
   /**
    * Get current time instance.
    *

package/dist/index.js

@@ -1517,6 +1517,15 @@ var DateTime = class DateTime extends TimeClass {
 		return this.startOf(unit);
 	}
 	/**
+	* Set the timezone for the instance
+	* 
+	* @param timezone 
+	* @returns 
+	*/
+	setTimezone(timezone$1, keepLocalTime) {
+		return new DateTime(this.tz(timezone$1, keepLocalTime));
+	}
+	/**
 	* End time of a specific unit.
 	* 
 	* @returns 
@@ -1571,7 +1580,7 @@ var DateTime = class DateTime extends TimeClass {
 	* @return {Date} object
 	*/
 	static fromTimestamp(timestamp) {
-		return /* @__PURE__ */ new Date(timestamp * 1e3);
+		return new DateTime(timestamp * 1e3);
 	}
 	/**
 	* Get current time instance.

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@h3ravel/support",
-  "version": "0.14.4",
+  "version": "0.14.5",
   "description": "Shared helpers, facades and utilities for H3ravel.",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
-    }
+    },
+    "./*": "./*"
   },
   "files": [
     "dist"
@@ -38,7 +38,7 @@
   "devDependencies": {
     "@types/luxon": "^3.7.1",
     "typescript": "^5.4.0",
-    "@h3ravel/shared": "^0.25.0"
+    "@h3ravel/shared": "^0.26.1"
   },
   "dependencies": {
     "dayjs": "^1.11.18",