angus-c/just

Features

• JavaScript Utility Libraries - A general-purpose utility library for performing complex data transformations, cloning, and filtering in JavaScript.
• Deep Object Manipulations - Implements deep cloning of objects and arrays to prevent accidental mutation of original data.
• Safe Property Accessors - Allows retrieving or setting values at deep property paths without risking runtime errors from undefined parents.
• Safe Path Assignments - Safely assigns values to nested paths, creating intermediate objects automatically if they are missing.
• Execution Throttling - Limits function execution frequency using throttling mechanisms to reduce processing load.
• Performance Optimization Tools - Provides performance optimization utilities to regulate function execution frequency via memoization and throttling.
• Function Argument Pre-setting - Allows creating new functions with predefined initial arguments to reduce the function signature.
• Functional Programming Logic - Provides a toolkit for functional programming patterns including immutable bindings, partial application, and pipe chaining.
• Functional Programming Toolkits - A zero-dependency toolkit implementing pure functional programming patterns like currying and partial application.
• Higher-Order Function Toolkits - Provides a comprehensive toolkit for creating and composing higher-order functions through currying and piping.
• Object Merging - Implements shallow assignment of properties from source objects into a target object.
• Function Currying - Transforms functions that take multiple arguments into a series of single-argument functions.
• String Manipulation Utilities - Offers functions for altering string casing, padding, and trimming to format text for user interfaces.
• Pure Functional Logic Implementations - Designs data transformations as pure functional implementations that avoid observable side effects.
• Execution Frequency Control - Regulates function invocation frequency through built-in debouncing and throttling mechanisms.
• Function Execution Utilities - Implements utilities for controlling function execution timing, including debouncing and throttling to optimize performance.
• Execution Debouncing - Implements function debouncing to delay execution until a period of inactivity has passed.
• Higher-Order Function Wrapping - Implements functional wrapping to modify existing function behaviors via composition and partial application.
• Memoization Caches - Provides memoization caches to store expensive function results and avoid redundant computations.
• Function Composition - Provides tools for merging multiple small functions into a single composite operation.
• Function Piping - Implements a pipeline mechanism to pass values through a sequence of functions for linear data flow.
• String Manipulators - Provides utilities for formatting and transforming text strings through case conversion, padding, and pruning.
• Zero-Dependency Libraries - Architecture designed as a collection of zero-dependency libraries to minimize bundle size.
• Pure Function Patterns - Implements pure function patterns that return new copies of data to prevent unintended mutation.
• Array Chunking - Divides arrays into smaller, fixed-size groups for structured batch processing.
• Array Intersections - Returns a new array containing only the elements common to two source arrays.
• Array Element Modifiers - Implements operations to remove elements from arrays based on membership in another array.
• Array Grouping - Transforms arrays into objects grouped by keys generated via a predicate function.
• Array Zipping - Groups the n-th element from multiple arrays into a single array of tuples.
• Collection Comparisons - Checks if two arrays or objects are identical by comparing lengths, sequences, and values.
• Collection Property Plucking - Provides a utility to extract a specific property from every member of a collection into a new array.
• Last-Result Caches - Caches the most recent evaluation of a function to speed up repeated calls with identical inputs.
• Falsy Value Filtering - Removes null, undefined, or falsy values from arrays and objects to produce a clean copy.
• Emptiness Checks - Determines if a collection or string contains no enumerable values.
• Last Element Accessors - Provides a direct way to retrieve the final element of an array.
• JSON Patching - Implements standard JSON patch operations to calculate and apply object state changes.
• Recursive Value Mappers - Recursively traverses objects to apply transformations to values at all nesting depths.
• Nullish Value Removal - Removes all null and undefined members from arrays and objects.
• Object Differencing - Calculates structural differences between two objects and applies changes using the JSON Patch standard.
• Object Entry Converters - Converts object structures into arrays of key-value pairs for easier processing.
• Object Key Picking - Provides utilities for creating shallow copies of objects containing only a specified subset of keys.
• Object Key Transformers - Allows creating a new object by applying a transformation function to the keys of a source object.
• Predicate Property Filtering - Removes object properties based on a custom boolean predicate function.
• Object Property Omission - Creates shallow copies of objects while excluding specific keys.
• Object Reducers - Provides functional utilities to reduce an object to a single value using an accumulator.
• Object Value Extractors - Extracts all property values from an object or array into a flat collection.
• Object Value Transformers - Creates new objects by applying functions to the values of a source object.
• Property-Based Indexing - Transforms collections into maps where elements are keyed by a specific object property.
• Existence Verifications - Provides a mechanism to check for the presence of keys at specific nested paths within data structures.
• String Case Transformers - Transforms strings into camelCase format by removing delimiters and capitalizing words.
• String Padding Utilities - Adds characters to the start of a string until it reaches a specified total length.
• Statistical Mode Calculators - Implements the calculation of the most frequently occurring value within a numerical set.
• Array Flattening Utilities - Collapses nested arrays into a single level with configurable depth.
• Array Sorting - Produces new arrays sorted in ascending order or by a custom comparison function.
• Variance Calculation - Computes the statistical variance of elements within a numeric array.
• Array Insertion Methods - Provides methods for injecting values or subarrays into specific array positions.
• Array Compacting - Returns a copy of an array with all falsy values removed.
• Array Deduplication - Removes duplicate elements from arrays using optimized algorithms for strings or sorted data.
• Array Splitting - Divides an array into two separate arrays at a specified index position.
• Predicate-Based Array Partitioning - Implements predicate-based partitioning to split an array into two groups based on a logical condition.
• Tail Extractions - Extracts all elements of an array except for the first one.
• Unique Array Merging - Creates a new array containing all unique elements from two source arrays.
• Arithmetic Mean Calculators - Implements functions to compute the arithmetic mean of numeric arrays or argument lists.
• Standard Deviation Calculators - Calculates the standard deviation of a numeric array to measure data dispersion.
• Cartesian Product Generation - Generates all possible combinations of elements from an array of arrays using Cartesian product logic.
• Statistical Interpolations - Calculates dataset percentiles using linear interpolation methods.
• Median Calculators - Provides algorithms for finding the median value of a numeric dataset.
• Numeric Range Generations - Creates an array of numbers spanning a range with a specified step.
• Combinatorial Generators - Generates all possible permutations and Cartesian products for complex data sampling.
• Skewness Calculators - Computes the skewness of a numeric set using Pearson's second skewness coefficient.
• Statistical Analysis Libraries - Ships a comprehensive toolset for calculating descriptive statistics like mean, median, variance, and standard deviation.
• Circular Reference Detection - Detects if an object contains a circular reference to itself to prevent infinite loops.
• Collection Shuffling - Provides a utility to randomly rearrange the elements of an array.
• Unique Element Extractions - Creates a new array containing only unique elements from a source collection.
• Permutation Generation Algorithms - Generates all possible orderings of the elements in a given array.
• Random Element Selections - Selects a single random member from a collection.
• Object Traversal Utilities - Includes utilities for recursively walking nested object structures to perform deep cloning and mapping.
• State Difference Calculations - Generates standardized patches between two arbitrary state values to perform object updates.
• Substring Replacements - Provides a utility to substitute every instance of a specific substring with another string.
• Text Truncation Strategies - Shortens a string to a specific length and appends a custom suffix.
• Generic Utilities - Modular utility library with individual package imports.

Star history