CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-xe-utils

Comprehensive JavaScript utility library with 150+ functions for objects, arrays, dates, strings, numbers, and more

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

xe-utils

xe-utils is a comprehensive JavaScript utility library providing 150+ utility functions organized into 9 functional categories. It offers precise implementations for common programming tasks including object manipulation, array operations, string processing, date handling, number formatting, URL operations, and web-related functionality. The library is designed for maximum flexibility with tree-shaking support and works in both browser and Node.js environments.

Package Information

  • Package Name: xe-utils
  • Package Type: npm
  • Language: JavaScript with TypeScript definitions
  • Installation: npm install xe-utils

Core Imports

import XEUtils from 'xe-utils';

For CommonJS:

const XEUtils = require('xe-utils');

Individual function imports for tree-shaking:

import each from 'xe-utils/each';
import toDateString from 'xe-utils/toDateString';
import isArray from 'xe-utils/isArray';

Category-based imports:

import XEUtils from 'xe-utils/ctor';
import objectMethods from 'xe-utils/object';
import arrayMethods from 'xe-utils/array';
import baseMethods from 'xe-utils/base';

Basic Usage

import XEUtils from 'xe-utils';

// Object operations
const merged = XEUtils.merge({ a: 1 }, { b: 2 });
XEUtils.each(merged, (value, key) => console.log(key, value));

// Array operations
const users = [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }];
const names = XEUtils.pluck(users, 'name'); // ['Alice', 'Bob']
const adults = XEUtils.filter(users, user => user.age >= 18);

// Date formatting
const formatted = XEUtils.toDateString(new Date(), 'yyyy-MM-dd HH:mm:ss');

// Number operations with precision
const sum = XEUtils.add(0.1, 0.2); // Precise arithmetic: 0.3

// String operations
const camelCased = XEUtils.camelCase('hello-world'); // 'helloWorld'

Architecture

xe-utils is built around several key design principles:

  • Modular Design: Each function is a separate module that can be imported individually
  • Universal Compatibility: Works in browser (IE7+) and Node.js environments
  • Type Safety: Full TypeScript definitions with generic type preservation
  • Precision Arithmetic: Special handling for floating-point precision issues
  • Extensible Core: Mixin system allows adding custom utilities to the main object
  • Configuration: Global configuration system for customizing behavior

Capabilities

Object Operations

Core functionality for object manipulation including property copying, merging, and iteration. Essential for data transformation and object utilities.

function assign(target: any, ...sources: any[]): any;
function merge(target: any, ...sources: any[]): any;
function objectEach<T>(obj: T, iterate: (value: any, key: string) => void): void;
function objectMap<T, U>(obj: T, iterate: (value: any, key: string) => U): { [key: string]: U };

Object Operations

Array Operations

Comprehensive array manipulation including functional programming methods, sorting, grouping, and tree operations. Perfect for data processing pipelines.

function map<T, U>(array: T[], iterate: (item: T, index: number) => U): U[];
function filter<T>(array: T[], iterate: (item: T, index: number) => boolean): T[];
function uniq<T>(array: T[]): T[];
function sortBy<T>(array: T[], iterate: (item: T) => any): T[];
function chunk<T>(array: T[], size: number): T[][];
function flatten<T>(array: any[], deep?: boolean): T[];
function zip<T>(...arrays: T[][]): T[][];
function arrayEach<T>(array: T[], iterate: (item: T, index: number) => void): void;
function some<T>(array: T[], iterate: (item: T, index: number) => boolean): boolean;
function every<T>(array: T[], iterate: (item: T, index: number) => boolean): boolean;

Array Operations

Type Checking & Validation

Comprehensive type checking utilities for runtime validation and type guards. Includes checks for all JavaScript types plus DOM and web API types.

function isArray(val: any): val is any[];
function isObject(val: any): val is object;
function isString(val: any): val is string;
function isNumber(val: any): val is number;
function isFunction(val: any): val is Function;
function isEmpty(val: any): boolean;
function isEqual(val1: any, val2: any): boolean;

Type Checking & Validation

Base Utilities

Core utilities for iteration, property access, cloning, and general object/array operations. Foundation methods used throughout applications.

function each<T>(obj: T[] | T, iterate: (item: any, key: string | number) => void): void;
function clone<T>(obj: T, deep?: boolean): T;
function get(obj: any, path: string | string[], defaultValue?: any): any;
function set(obj: any, path: string | string[], value: any): void;
function keys(obj: any): string[];
function values(obj: any): any[];
function groupBy<T>(array: T[], iterate: (item: T) => string | number): { [key: string]: T[] };
function countBy<T>(array: T[], iterate: (item: T) => string | number): { [key: string]: number };

Base Utilities

Number Operations

Precise arithmetic operations and number formatting utilities. Solves JavaScript's floating-point precision issues and provides advanced number formatting.

function add(num1: number, num2: number): number;
function subtract(num1: number, num2: number): number;
function multiply(num1: number, num2: number): number;
function divide(num1: number, num2: number): number;
function round(num: number, digits?: number): number;
function commafy(num: number | string, options?: CommafyOptions): string;

Number Operations

Date & Time

Comprehensive date manipulation, formatting, and calculation utilities. Supports custom formats, internationalization, and complex date arithmetic.

function toDateString(date: Date | string | number, format?: string, options?: ToDateStringOptions): string;
function toStringDate(str: string, formats?: string[]): Date;
function getDateDiff(startDate: Date, endDate: Date, unit?: DateUnit): number;
function isValidDate(date: any): boolean;
function getWhatWeek(date: Date, startDay?: number): number;

Date & Time

String Processing

String manipulation utilities including case conversion, padding, trimming, templating, and HTML escaping. Essential for text processing and formatting.

function camelCase(str: string): string;
function kebabCase(str: string): string;
function padStart(str: string, targetLength: number, padString?: string): string;
function trim(str: string, chars?: string): string;
function template(str: string, obj: any, options?: TemplateOptions): string;

String Processing

Function Utilities

Function manipulation utilities including binding, throttling, debouncing, and execution control. Perfect for event handling and performance optimization.

function throttle<T extends (...args: any[]) => any>(fn: T, wait: number, options?: ThrottleOptions): T;
function debounce<T extends (...args: any[]) => any>(fn: T, wait: number, options?: DebounceOptions): T;
function once<T extends (...args: any[]) => any>(fn: T): T;
function bind(fn: Function, thisArg: any, ...args: any[]): Function;

Function Utilities

Web & Browser

Browser-specific utilities for URL parsing, cookie management, navigation, and browser detection. Essential for web development and browser compatibility.

function parseUrl(url: string): ParsedUrl;
function serialize(obj: any, options?: SerializeOptions): string;
function cookie(name?: string, value?: any, options?: CookieOptions): any;
function browse(): BrowserInfo;

Web & Browser

Core Types

interface XEUtilsMethods {
  version: string;
  mixin(...methods: { [key: string]: any }[]): void;
  setup(options: any): any;
  getConfig(): any;

  // All utility methods are available as properties
  [key: string]: any;
}

interface CommafyOptions {
  separator?: string;
  fixed?: number;
  rounding?: boolean;
}

interface ToDateStringOptions {
  firstDay?: number;
  formats?: {
    q?: string[] | ((value: any, match: string, date: Date) => string);
    E?: string[] | ((value: any, match: string, date: Date) => string);
  };
}

interface TemplateOptions {
  tmplRE?: RegExp;
  escape?: boolean;
}

interface ThrottleOptions {
  leading?: boolean;
  trailing?: boolean;
}

interface DebounceOptions {
  leading?: boolean;
  trailing?: boolean;
}
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/xe-utils@3.7.x
Publish Source
CLI
Badge
tessl/npm-xe-utils badge