@pol-studios/utils 1.0.0

package/dist/index-CZbs1QQN.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Create a new object with specified keys omitted
+ * @param obj - The source object
+ * @param keys - The key(s) to omit
+ * @returns A new object without the specified keys
+ * @example omit({a: 1, b: 2, c: 3}, ['a', 'b']) // {c: 3}
+ */
+declare function omit<T extends Record<string, any>, K extends (keyof T & string) | string>(obj: T, keys: K | K[]): Omit<T, K>;
+
+/**
+ * Create a new object with only the specified keys
+ * @param obj - The source object
+ * @param keys - The keys to include
+ * @returns A new object with only the specified keys
+ * @example pick({a: 1, b: 2, c: 3}, ['a', 'b']) // {a: 1, b: 2}
+ */
+declare function pick<T extends {}, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * @deprecated Use `pick` instead
+ * Create a new object with only the specified keys
+ * @param obj - The source object
+ * @param keys - The keys to include
+ * @returns A new object with only the specified keys
+ */
+declare const includeOnly: typeof pick;
+
+/**
+ * Get the difference between two objects
+ * @param oldValue - The original object
+ * @param newValue - The new object to compare against
+ * @returns An object containing only the changed values
+ * @example diff({a: 1, b: 2}, {a: 1, b: 3}) // {b: 3}
+ */
+declare function diff(oldValue: Record<string, any>, newValue: Record<string, any>): Record<string, any>;
+
+/**
+ * Get a value from an object using a dot-notation path
+ * @param obj - The object to get the value from
+ * @param path - The dot-notation path (e.g., "user.address.city")
+ * @returns The value at the path, or undefined if not found
+ * @example getPath({user: {name: 'John'}}, 'user.name') // 'John'
+ */
+declare function getPath(obj: any, path: string): any;
+/**
+ * @deprecated Use `getPath` instead
+ * Get a value from an object using a dot-notation path
+ * @param obj - The object to get the value from
+ * @param path - The dot-notation path
+ * @returns The value at the path, or undefined if not found
+ */
+declare const getValueByPath: typeof getPath;
+
+/**
+ * Set a value in an object using a dot-notation path
+ * Creates intermediate objects if they don't exist
+ * @param obj - The object to modify
+ * @param path - The dot-notation path (e.g., "user.address.city")
+ * @param value - The value to set
+ * @example setPath({}, 'user.name', 'John') // mutates obj to {user: {name: 'John'}}
+ */
+declare function setPath(obj: any, path: string, value: any): void;
+/**
+ * @deprecated Use `setPath` instead
+ * Set a value in an object using a dot-notation path
+ * @param obj - The object to modify
+ * @param path - The dot-notation path
+ * @param value - The value to set
+ */
+declare const setValueByPath: typeof setPath;
+
+/**
+ * Perform a shallow deep equality check on two objects
+ * Compares object keys and their values at one level
+ * @param obj1 - First object to compare
+ * @param obj2 - Second object to compare
+ * @returns true if objects have the same keys with equal values
+ * @example deepEquals({a: 1, b: 2}, {a: 1, b: 2}) // true
+ */
+declare function deepEquals<T extends Record<string, any>>(obj1: T, obj2: T): boolean;
+/**
+ * Alias for deepEquals - check if two objects are equal
+ * @param obj1 - First object to compare
+ * @param obj2 - Second object to compare
+ * @returns true if objects are equal
+ */
+declare const isDeepEqual: typeof deepEquals;
+
+declare const index_deepEquals: typeof deepEquals;
+declare const index_diff: typeof diff;
+declare const index_getPath: typeof getPath;
+declare const index_getValueByPath: typeof getValueByPath;
+declare const index_includeOnly: typeof includeOnly;
+declare const index_isDeepEqual: typeof isDeepEqual;
+declare const index_omit: typeof omit;
+declare const index_pick: typeof pick;
+declare const index_setPath: typeof setPath;
+declare const index_setValueByPath: typeof setValueByPath;
+declare namespace index {
+  export { index_deepEquals as deepEquals, index_diff as diff, index_getPath as getPath, index_getValueByPath as getValueByPath, index_includeOnly as includeOnly, index_isDeepEqual as isDeepEqual, index_omit as omit, index_pick as pick, index_setPath as setPath, index_setValueByPath as setValueByPath };
+}
+
+export { includeOnly as a, getValueByPath as b, setValueByPath as c, diff as d, deepEquals as e, isDeepEqual as f, getPath as g, index as i, omit as o, pick as p, setPath as s };

package/dist/index-Cp7KyTeB.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Extracts all string values from a TypeScript enum.
+ * Filters out numeric keys that TypeScript adds for reverse mapping in numeric enums.
+ * @param enumObject - The enum object to extract values from
+ * @returns An array of enum values (excluding numeric reverse-mapping keys)
+ */
+declare function getEnumValues<T extends Record<string, unknown>>(enumObject: T): Array<T[keyof T]>;
+/**
+ * Parses a string value into an enum member.
+ * Supports both string enum keys and numeric enum values.
+ * @param enumType - The enum type to parse into
+ * @param value - The string value to parse
+ * @returns The matching enum member, or undefined if no match found
+ */
+declare function parseStringToEnum<T extends object>(enumType: T, value: string): T[keyof T] | undefined;
+
+declare const index_getEnumValues: typeof getEnumValues;
+declare const index_parseStringToEnum: typeof parseStringToEnum;
+declare namespace index {
+  export { index_getEnumValues as getEnumValues, index_parseStringToEnum as parseStringToEnum };
+}
+
+export { getEnumValues as g, index as i, parseStringToEnum as p };

package/dist/index-CrplC0qf.d.ts

@@ -0,0 +1,29 @@
+type AsyncFunction<T> = () => Promise<T>;
+/**
+ * Caches the result of an asynchronous function based on a key and duration.
+ * Ensures only one execution occurs at a time for the same key.
+ *
+ * @param key - Unique identifier for the cached data.
+ * @param fn - The asynchronous function to execute and cache.
+ * @param duration - Cache duration in milliseconds.
+ * @returns A promise resolving to the function's result.
+ */
+declare function cacheFunction<T>(key: string, fn: AsyncFunction<T>, duration: number): Promise<T>;
+/**
+ * Clears a specific cache entry by key.
+ * @param key - The cache key to clear.
+ */
+declare function clearCache(key: string): void;
+/**
+ * Clears all cache entries.
+ */
+declare function clearAllCache(): void;
+
+declare const index_cacheFunction: typeof cacheFunction;
+declare const index_clearAllCache: typeof clearAllCache;
+declare const index_clearCache: typeof clearCache;
+declare namespace index {
+  export { index_cacheFunction as cacheFunction, index_clearAllCache as clearAllCache, index_clearCache as clearCache };
+}
+
+export { clearCache as a, clearAllCache as b, cacheFunction as c, index as i };

package/dist/index-Cvl_0aDq.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Determines if a hex color is dark based on its luminance.
+ * Uses the ITU-R BT.709 formula for calculating relative luminance.
+ * @param c - A hex color string (e.g., "#000000" or "#fff")
+ * @returns true if the color is considered dark (luma < 70)
+ */
+declare function isDarkColor(c: string): boolean;
+
+declare const index_isDarkColor: typeof isDarkColor;
+declare namespace index {
+  export { index_isDarkColor as isDarkColor };
+}
+
+export { isDarkColor as a, index as i };

package/dist/index-D_IvPWYI.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Convert a string to camelCase
+ * @param str - The string to convert
+ * @returns The camelCased string
+ * @example camelize("hello world") // "helloWorld"
+ */
+declare function camelize(str: string): string;
+
+/**
+ * Convert a string to PascalCase
+ * @param str - The string to convert
+ * @returns The PascalCased string
+ * @example pascalize("hello world") // "Hello World"
+ */
+declare function pascalize(str: string): string;
+/**
+ * Convert a string to PascalCase with spaces between words
+ * Handles camelCase, snake_case, kebab-case, and other delimiters
+ * @param input - The string to convert
+ * @returns The PascalCased string with spaces
+ * @example pascalizeWithSpaces("bazQux") // "Baz Qux"
+ * @example pascalizeWithSpaces("hello_world") // "Hello World"
+ */
+declare function pascalizeWithSpaces(input: string): string;
+
+/**
+ * Generate a URL-friendly slug from a string
+ * @param text - Input text to convert to slug
+ * @returns URL-safe slug (lowercase, hyphens, no special chars)
+ * @example slugify("Version 2.0") // "version-2-0"
+ */
+declare function slugify(text: string): string;
+/**
+ * @deprecated Use `slugify` instead
+ * Generate a URL-friendly slug from a string
+ * @param text - Input text to convert to slug
+ * @returns URL-safe slug (lowercase, hyphens, no special chars)
+ */
+declare const generateSlug: typeof slugify;
+
+/**
+ * Sanitize a string by escaping quotes for safe use in queries
+ * @param value - The string to sanitize
+ * @returns The sanitized string with escaped quotes
+ * @example sanitizeInput('O"Brien') // 'O""Brien'
+ */
+declare function sanitizeInput(value: string): string;
+
+/**
+ * Check if a string is blank (null, undefined, or only whitespace)
+ * @param value - The string to check
+ * @returns true if the string is null, undefined, or only whitespace
+ * @example isBlank("  ") // true
+ * @example isBlank("hello") // false
+ */
+declare function isBlank(value: string | undefined | null): boolean;
+/**
+ * @deprecated Use `isBlank` instead
+ * Check if a string is null, undefined, or only whitespace
+ * @param value - The string to check
+ * @returns true if the string is null, undefined, or only whitespace
+ */
+declare const isNullOrWhitespace: typeof isBlank;
+
+declare const index_camelize: typeof camelize;
+declare const index_generateSlug: typeof generateSlug;
+declare const index_isBlank: typeof isBlank;
+declare const index_isNullOrWhitespace: typeof isNullOrWhitespace;
+declare const index_pascalize: typeof pascalize;
+declare const index_pascalizeWithSpaces: typeof pascalizeWithSpaces;
+declare const index_sanitizeInput: typeof sanitizeInput;
+declare const index_slugify: typeof slugify;
+declare namespace index {
+  export { index_camelize as camelize, index_generateSlug as generateSlug, index_isBlank as isBlank, index_isNullOrWhitespace as isNullOrWhitespace, index_pascalize as pascalize, index_pascalizeWithSpaces as pascalizeWithSpaces, index_sanitizeInput as sanitizeInput, index_slugify as slugify };
+}
+
+export { pascalizeWithSpaces as a, sanitizeInput as b, camelize as c, isBlank as d, isNullOrWhitespace as e, generateSlug as g, index as i, pascalize as p, slugify as s };

package/dist/index-DdaZnk7j.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Formats a number as a USD currency string
+ */
+declare function formatCurrency(value: number | bigint): string;
+/**
+ * @deprecated Use `formatCurrency` instead
+ * Formats a number as a USD currency string
+ */
+declare const toUsdString: typeof formatCurrency;
+/**
+ * Formats a number with up to 2 decimal places
+ */
+declare function toNumberString(value: number | bigint): string;
+
+/**
+ * Formats a number as a decimal string with the specified number of decimal places
+ */
+declare function toDecimalString(num: number, decimalPlaces?: number | undefined): string;
+
+declare const index_formatCurrency: typeof formatCurrency;
+declare const index_toDecimalString: typeof toDecimalString;
+declare const index_toNumberString: typeof toNumberString;
+declare const index_toUsdString: typeof toUsdString;
+declare namespace index {
+  export { index_formatCurrency as formatCurrency, index_toDecimalString as toDecimalString, index_toNumberString as toNumberString, index_toUsdString as toUsdString };
+}
+
+export { toNumberString as a, toDecimalString as b, formatCurrency as f, index as i, toUsdString as t };

package/dist/index-vLuR45Km.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Checks if the current environment is development mode.
+ * @returns true if WITH_MODE environment variable is set to "development"
+ */
+declare function isDevEnvironment(): boolean;
+/**
+ * Alias for isDevEnvironment.
+ * Checks if the current environment is development mode.
+ * @returns true if WITH_MODE environment variable is set to "development"
+ */
+declare function isDev(): boolean;
+/**
+ * Logs messages to the console only in development environment.
+ * Useful for debug logging that should not appear in production.
+ * @param message - The primary message to log
+ * @param optionalParams - Additional parameters to log
+ */
+declare function debugLog(message?: any, ...optionalParams: any[]): void;
+
+declare const index_debugLog: typeof debugLog;
+declare const index_isDev: typeof isDev;
+declare const index_isDevEnvironment: typeof isDevEnvironment;
+declare namespace index {
+  export { index_debugLog as debugLog, index_isDev as isDev, index_isDevEnvironment as isDevEnvironment };
+}
+
+export { isDevEnvironment as a, isDev as b, debugLog as d, index as i };

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+export { c as camelize, g as generateSlug, d as isBlank, e as isNullOrWhitespace, p as pascalize, a as pascalizeWithSpaces, b as sanitizeInput, s as slugify, i as string } from './index-D_IvPWYI.js';
+export { G as GroupedItems, i as array, 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';
+export { e as deepEquals, d as diff, g as getPath, b as getValueByPath, a as includeOnly, f as isDeepEqual, i as object, o as omit, p as pick, s as setPath, c as setValueByPath } from './index-CZbs1QQN.js';
+export { e as addDates, f as addDays, b as areDatesEqual, i as date, d as dateReviver, g as getUtcDate, a as getUtcMoment, c as isValidDate, p as parseWithDate, t as toUtcDate } from './index-BDWEMkWa.js';
+export { S as Semaphore, i as async, c as concurrent, a as debounce, d as delay, p as promiseAllWithConcurrencyLimit } from './index-C-YwC08Y.js';
+export { i as format, f as formatCurrency, b as toDecimalString, a as toNumberString, t as toUsdString } from './index-DdaZnk7j.js';
+export { c as cn, i as tailwind } from './index-BSNY-QEc.js';
+export { i as cache, c as cacheFunction, b as clearAllCache, a as clearCache } from './index-CrplC0qf.js';
+export { d as EntityAccessRecord, b as EntityAction, c as EntityPermissionCheck, a as EntityPermissionLevel, E as EntityType, I as ItemType, K as KeyOfStringOrNumber, P as PermissionEffect, S as StorageObjectMetadata, g as getContentType, e as isImageType, h as isPdfType, j as isRenderableType, f as isVideoType, i as types } from './index-BaA8cg0E.js';
+export { i as color, a as isDarkColor } from './index-Cvl_0aDq.js';
+export { P as PasswordStrength, g as PasswordStrengthResult, a as ValidationResult, V as ValidationRule, h as calculatePasswordStrength, b as validateEmail, e as validateMaxLength, d as validateMinLength, f as validatePattern, c as validateRequired, v as validateValue, i as validation } from './index-BxUoIlv_.js';
+export { E as ErrorMapping, P as PostgrestError, U as UserFriendlyError, V as ValidationErrorMapping, i as error, e as extractFieldName, c as getFormFieldError, g as getUserFriendlyError, b as isNetworkError, a as isPostgrestError } from './index-B2oAfh_i.js';
+export { i as device, h as hasCameraAsync, b as isIphone, c as isPwaLaunched, a as isSmallDevice } from './index-C062CkPL.js';
+export { n as newUuid, i as uuid } from './index-Btn_GVfm.js';
+export { g as getObjectChanges, i as state, w as withUpdate } from './index-C8CxeaqZ.js';
+export { i as enumUtils, g as getEnumValues, p as parseStringToEnum } from './index-Cp7KyTeB.js';
+export { d as debugLog, i as dev, b as isDev, a as isDevEnvironment } from './index-vLuR45Km.js';
+export { ClassValue } from 'clsx';
+import 'moment';
+
+declare const AccessKeys: {
+    readonly Timesheet: "timesheet";
+    readonly TimesheetAdmin: "admin_timesheet";
+    readonly InternalAdmin: "internal";
+    readonly Invoicing: "invoicing";
+    readonly ExpenseReport: "expense_report";
+    readonly ExpenseReportAdmin: "admin_expense_report";
+    readonly ProjectAdmin: "admin_project";
+    readonly FixtureCatalog: "fixture_catalog";
+    readonly ProjectDatabase: "project_database";
+    readonly Owner: "owner";
+    readonly User: "user";
+};
+
+declare const index$2_AccessKeys: typeof AccessKeys;
+declare namespace index$2 {
+  export { index$2_AccessKeys as AccessKeys };
+}
+
+/**
+ * Downloads a file from a URL and triggers a browser download.
+ * @param url - The URL to fetch the file from
+ * @param fileName - The name to save the file as
+ */
+declare function getFile(url: string | Request, fileName: string): Promise<void>;
+/**
+ * Downloads text content as a file.
+ * @param text - The text content to download
+ */
+declare function downloadFile(text: string): Promise<void>;
+/**
+ * Downloads a file using a POST request.
+ * @param url - The URL to POST to
+ * @param fileName - The name to save the file as
+ * @param queryParams - The query parameters to send in the POST body
+ */
+declare function getFilePost(url: string, fileName: string, queryParams: string): Promise<void>;
+
+declare const index$1_downloadFile: typeof downloadFile;
+declare const index$1_getFile: typeof getFile;
+declare const index$1_getFilePost: typeof getFilePost;
+declare namespace index$1 {
+  export { index$1_downloadFile as downloadFile, index$1_getFile as getFile, index$1_getFilePost as getFilePost };
+}
+
+/**
+ * Gets a unique key based on the call stack, useful for caching and deduplication.
+ * Filters out React-related stack frames to get a stable key.
+ * @returns A string key derived from the filtered call stack
+ */
+declare function getCallerUniqueKey(): string;
+
+declare const index_getCallerUniqueKey: typeof getCallerUniqueKey;
+declare namespace index {
+  export { index_getCallerUniqueKey as getCallerUniqueKey };
+}
+
+/**
+ * Check if a value is usable (not null, not undefined, and if a number, not NaN)
+ * @internal
+ */
+declare function isUsable(value: any): value is {};
+
+export { AccessKeys, index$2 as constants, index$1 as download, downloadFile, getCallerUniqueKey, getFile, getFilePost, isUsable, index as meta };