@dereekb/util 11.0.21 → 11.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/util",
-  "version": "11.0.21",
+  "version": "11.1.1",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",

package/src/lib/array/array.d.ts

@@ -1,3 +1,4 @@
+import { type IterableOrValue } from '../iterable/iterable';
 import { type Maybe } from '../value/maybe.type';
 export type EmptyArray = never[];
 export type ArrayOrValue<T> = T | T[];
@@ -118,3 +119,9 @@ export declare function forEachWithArray<T>(array: Maybe<ArrayOrValue<T>>, forEa
  * @returns
  */
 export declare function countAllInNestedArray<T>(array: T[][]): number;
+/**
+ * Creates a copy of the array with the items at the specified indexes removed.
+ *
+ * @param array
+ */
+export declare function removeValuesAtIndexesFromArrayCopy<T>(array: T[], removeIndexes: IterableOrValue<number>): T[];

package/src/lib/array/array.number.d.ts

@@ -8,13 +8,23 @@ export declare function reduceNumbersWithAddFn(emptyArrayValue?: number): (array
 export declare function reduceNumbers(reduceFn: (a: number, b: number) => number, array: number[], emptyArrayValue?: number): number | undefined;
 export declare function reduceNumbersFn(reduceFn: (a: number, b: number) => number): (array: number[]) => number | undefined;
 export declare function reduceNumbersFn<D extends number>(reduceFn: (a: number, b: number) => number, emptyArrayValue?: D): (array: number[]) => number | D;
+/**
+ * Exclusive end value used by range().
+ */
+export type RangeInputEndValue = number;
 /**
  * Input for range()
  */
-export type RangeInputObject = {
-    start?: number;
-    end: number;
-};
+export interface RangeInputObject {
+    /**
+     * Start value. Defaults to 0 if not defined.
+     */
+    readonly start?: number;
+    /**
+     * The exclusive end value.
+     */
+    readonly end: RangeInputEndValue;
+}
 export type RangeInput = number | RangeInputObject | IndexRange;
 /**
  * Generates an array containing the range of numbers specified.
@@ -24,4 +34,4 @@ export type RangeInput = number | RangeInputObject | IndexRange;
  * @param param0
  * @returns
  */
-export declare function range(input: RangeInput, inputEnd?: number): number[];
+export declare function range(input: RangeInput, inputEnd?: RangeInputEndValue): number[];

package/src/lib/array/array.value.d.ts

@@ -1,18 +1,24 @@
 import { type Maybe, type MaybeNot } from '../value/maybe.type';
+/**
+ * Function that takes the input and returns an array with no Maybe values.
+ */
+export type FilterMaybeArrayFunction<T> = (value: Maybe<Maybe<T[]>>) => T[];
+export type UniversalFilterMaybeArrayFunction = <T>(values: Maybe<Maybe<T>[]>) => T[];
+export declare function filterMaybeArrayFunction<T>(filterFn: Parameters<Array<Maybe<T>>['filter']>[0]): FilterMaybeArrayFunction<T>;
 /**
  * Filters all maybe values from the input array. If a maybe value is input, returns an empty array.
  *
  * @param values
  * @returns
  */
-export declare function filterMaybeValues<T>(values: Maybe<Maybe<T>[]>): T[];
+export declare const filterMaybeArrayValues: UniversalFilterMaybeArrayFunction;
 /**
  * Filters all empty and maybe values from the input array. If a maybe value is input, returns an empty array.
  *
  * @param values
  * @returns
  */
-export declare function filterEmptyValues<T>(values: Maybe<Maybe<T>[]>): T[];
+export declare const filterEmptyArrayValues: UniversalFilterMaybeArrayFunction;
 /**
  * Checks whether or not all values are MaybeNot values.
  *
@@ -27,3 +33,21 @@ export declare function allValuesAreMaybeNot<T>(values: Maybe<T>[]): values is M
  * @returns
  */
 export declare function allValuesAreNotMaybe<T>(values: Maybe<T>[]): values is T[];
+/**
+ * Filters all maybe values from the input array. If a maybe value is input, returns an empty array.
+ *
+ * @param values
+ * @returns
+ *
+ * @deprecated use filterMaybeArrayValues instead.
+ */
+export declare const filterMaybeValues: UniversalFilterMaybeArrayFunction;
+/**
+ * Filters all empty and maybe values from the input array. If a maybe value is input, returns an empty array.
+ *
+ * @param values
+ * @returns
+ *
+ * @deprecated use filterEmptyArrayValues instead.
+ */
+export declare const filterEmptyValues: UniversalFilterMaybeArrayFunction;

package/src/lib/number/bitwise.dencoder.d.ts

@@ -62,6 +62,9 @@ export type BitwiseObjectDencoder<T extends object> = BitwiseObjectEncoder<T> &
 export interface BitwiseObjectDencoderConfig<T extends object, D extends BitwiseEncodedSetIndex = BitwiseEncodedSetIndex> {
     readonly toSetFunction: BitwiseObjectToSetFunction<T, D>;
     readonly fromSetFunction: BitwiseObjectFromSetFunction<T, D>;
+    /**
+     * The max index, exclusive
+     */
     readonly maxIndex?: number;
 }
 export declare function bitwiseObjectDencoder<T extends object, D extends BitwiseEncodedSetIndex = BitwiseEncodedSetIndex>(config: BitwiseObjectDencoderConfig<T, D>): BitwiseObjectDencoder<T>;

package/src/lib/object/object.d.ts

@@ -2,7 +2,11 @@ import { type FieldOfType } from '../key';
 import { type SetIncludesMode } from '../set/set.mode';
 import { type KeyAsString } from '../type';
 /**
- * Key of an object.
+ * Any valid Plain-old Javascript Object key.
+ */
+export type POJOKey = string | number | symbol;
+/**
+ * String key of an object.
  */
 export type ObjectKey = string;
 export type EmptyObject = Record<string, never>;

package/src/lib/object/object.equal.d.ts

@@ -1,11 +1,18 @@
 import { type FieldOfType } from '../key';
 import { type EqualityComparatorFunction } from '../value/comparator';
+import { type FilterFromPOJOFunction } from './object.filter.pojo';
 /**
  * Performs a deep comparison to check if all values on the input filters are equal.
  *
  * Recursively compares Arrays, Objects, Maps, Sets, Primatives, and Dates.
  */
 export declare function areEqualPOJOValues<F>(a: F, b: F): boolean;
+/**
+ * Performs a deep comparison to check if all values on the input filters are equal. Each input is run through the pojo filter
+ *
+ * Recursively compares Arrays, Objects, Maps, Sets, Primatives, and Dates.
+ */
+export declare function areEqualPOJOValuesUsingPojoFilter<F>(a: F, b: F, pojoFilter: FilterFromPOJOFunction<F>): boolean;
 /**
  * Configuration for an ObjectFieldEqualityChecker.
  */

package/src/lib/object/object.filter.pojo.d.ts

@@ -139,7 +139,7 @@ export declare function filterFromPOJO<T extends object>(obj: T, config?: Filter
  * @param obj POJO to remove undefined values from.
  * @param copy Whether or not to return a copy of the input object. Default is true.
  */
-export type FilterFromPOJOFunction<T> = (input: T) => T;
+export type FilterFromPOJOFunction<T> = (input: T, copyOverride?: Maybe<boolean>) => T;
 export type GeneralFilterFromPOJOFunction<X = object> = <T extends X>(input: T) => T;
 export declare function filterFromPOJOFunction<T extends object>({ copy, filter: inputFilter }?: FilterFromPOJO<T>): FilterFromPOJOFunction<T>;
 /**
@@ -181,6 +181,19 @@ export declare function valuesFromPOJO<O = unknown, I extends object = object>(t
  */
 export type ValuesFromPOJOFunction<O = unknown, I extends object = object> = (obj: I) => O[];
 export declare function valuesFromPOJOFunction<O = unknown, I extends object = object>(filter?: FilterKeyValueTuplesInput<I>): ValuesFromPOJOFunction<O, I>;
+/**
+ * Returns a FilterTuplesOnPOJOFunction that returns an object that contains only the input keys, or does not contain the input keys if invertFilter is true.
+ *
+ * @param keysToFilter
+ * @returns
+ */
+export declare function filterKeysOnPOJOFunction<T extends object>(keysToFilter: Iterable<string>, invertFilter?: boolean): FilterTuplesOnPOJOFunction<T>;
+export type FilterTuplesOnPOJOFilter<T extends object> = Parameters<ReturnType<typeof Object.entries<T>>['filter']>['0'];
+/**
+ * Function that filters keys/values on a POJO using the pre-configured function.
+ */
+export type FilterTuplesOnPOJOFunction<T extends object> = T extends Record<string, infer I> ? (input: T) => Record<string, I> : (input: T) => Partial<T>;
+export declare function filterTuplesOnPOJOFunction<T extends object>(filterTupleOnObject: FilterTuplesOnPOJOFilter<T>): FilterTuplesOnPOJOFunction<T>;
 export type ForEachKeyValueOnPOJOTupleFunction<T extends object, C = unknown, K extends keyof T = keyof T> = (tuple: KeyValueTuple<T, K>, index: number, object: T, context: C) => void;
 export type ForEachKeyValueOnPOJOFunction<T extends object, C = unknown> = C extends void ? ForEachKeyValueOnPOJOFunctionWithoutContext<T> : ForEachKeyValueOnPOJOFunctionWithContext<T, C>;
 export type ForEachKeyValueOnPOJOFunctionWithoutContext<T extends object> = (object: T) => void;

package/src/lib/object/object.map.d.ts

@@ -1,4 +1,5 @@
 import { type MapFunction } from '../value/map';
+import { type POJOKey } from './object';
 /**
  * An object with values of a specific type keyed by either string or number or symbols.
  */
@@ -21,13 +22,6 @@ export type MappedObjectMap<M extends object, O> = {
  * @returns
  */
 export declare function objectToMap<T>(object: ObjectMap<T>): Map<string, T>;
-/**
- * Converts an ObjectMap into tuples.
- *
- * @param object
- * @returns
- */
-export declare function objectToTuples<T>(object: ObjectMap<T>): [string, T][];
 /**
  * Maps an ObjectMap of one type to another ObjectMap with the mapped values.
  */
@@ -55,3 +49,37 @@ export declare function mapObjectMap<M extends ObjectMap<I>, I = unknown, O = un
  * @returns
  */
 export declare function mapObjectToTargetObject<M extends ObjectMap<I>, I = unknown, O = unknown>(object: M, target: MappedObjectMap<M, O>, mapFn: MapObjectMapValueFunction<M, I, O>): MappedObjectMap<M, O>;
+/**
+ * Maps each key of the input object to a new object using the pre-configured function.
+ */
+export type MapObjectKeysFunction<M> = (object: M) => any;
+/**
+ * Map function that returns the new POJOKey using the input key/value pair.
+ */
+export type MapObjectKeyFunction<M> = <K extends keyof M>(key: K, value: M[K]) => POJOKey;
+/**
+ * Maps the keys of the input object to a new object with the mapped keys.
+ *
+ * @param object
+ */
+export declare function mapObjectKeysFunction<M extends object>(mapKeyFn: MapObjectKeyFunction<M>): MapObjectKeysFunction<M>;
+export type MappedKeysToLowercaseObjectMap<M extends object> = {
+    [K in keyof M as K extends string ? Lowercase<K> : K]: M[K];
+};
+/**
+ * Maps all the keys of an object to a new object with keys of the object mapped to lowercase.
+ *
+ * @param object
+ * @param target
+ * @param mapFn
+ */
+export declare const mapObjectKeysToLowercase: <M extends object>(object: M) => MappedKeysToLowercaseObjectMap<M>;
+/**
+ * Converts an ObjectMap into tuples.
+ *
+ * @deprecated use Object.entries instead.
+ *
+ * @param object
+ * @returns
+ */
+export declare const objectToTuples: <T>(object: ObjectMap<T>) => [string, T][];

package/src/lib/string/string.d.ts

@@ -71,3 +71,25 @@ export declare function joinStringsWithSpaces(input: Maybe<string>[]): string;
  * @returns
  */
 export declare function repeatString(string: string, reapeat: number): string;
+export interface CutStringFunctionConfig {
+    /**
+     * Max length of the string.
+     */
+    readonly maxLength: number;
+    /**
+     * Whether or not the end text addition should be included in the max length computation.
+     *
+     * If false, then the input string will be cut at the max length.
+     */
+    readonly maxLengthIncludesEndText?: Maybe<boolean>;
+    /**
+     * The end text to add to the cut string.
+     *
+     * Defaults to "...".
+     */
+    readonly endText?: Maybe<string>;
+}
+export declare const DEFAULT_CUT_STRING_END_TEXT = "...";
+export type CutStringFunction = ((input: string) => string) & ((input: Maybe<string>) => Maybe<string>);
+export declare function cutStringFunction(config: CutStringFunctionConfig): CutStringFunction;
+export declare function cutString(input: Maybe<string>, maxLength: number, endText?: Maybe<string>): Maybe<string>;

package/src/lib/value/indexed.d.ts

@@ -7,9 +7,18 @@ import { type Maybe } from './maybe.type';
 import { type WrapNumberFunction } from '../number';
 import { type FilterUniqueFunctionExcludeKeysInput } from '../array/array.unique';
 /**
- * A number that denotes which index an item is at.
+ * An integer that denotes which index an item is at.
+ *
+ * Is typically non-negative only.
  */
 export type IndexNumber = number;
+/**
+ * The default index number when no index is set.
+ *
+ * Only applicable for non-negative indexes.
+ */
+export declare const UNSET_INDEX_NUMBER = -1;
+export type UnsetIndexNumber = typeof UNSET_INDEX_NUMBER;
 /**
  * Item that references an IndexNumber.
  */
@@ -80,12 +89,18 @@ export declare function indexDeltaGroup<T>(readIndex: ReadMaybeIndexFunction<T>,
 export declare function sortByIndexAscendingCompareFunction<T>(readIndex: ReadIndexFunction<T>): SortCompareFunction<T>;
 /**
  * Computes the next free index given the input values.
+ *
+ * Returns 0 if no values are present.
  */
 export type ComputeNextFreeIndexFunction<T> = (values: T[]) => IndexNumber;
 /**
  * Creates a new ComputeNextFreeIndexFunction.
  */
 export declare function computeNextFreeIndexFunction<T>(readIndex: ReadIndexFunction<T>, nextIndex?: (value: T) => IndexNumber): ComputeNextFreeIndexFunction<T>;
+/**
+ * Creates a new ComputeNextFreeIndexFunction that assumes that the input values are sorted in ascending order, with the latest index at the end.
+ */
+export declare function computeNextFreeIndexOnSortedValuesFunction<T>(readIndex: ReadIndexFunction<T>, nextIndex?: (value: T) => IndexNumber): ComputeNextFreeIndexFunction<T>;
 /**
  * Reads the min and max index from the input values.
  */

package/src/lib/value/maybe.d.ts

@@ -87,3 +87,14 @@ export declare function isSameNonNullValue<T>(a: Maybe<T>, b: Maybe<T>): a is No
  * @returns
  */
 export declare function valuesAreBothNullishOrEquivalent<T>(a: Maybe<T>, b: Maybe<T>): boolean;
+/**
+ * Updates "a" with "b".
+ *
+ * - If b is defined, then returns b
+ * - If b is undefined, then returns a
+ * - If b is null, then returns null
+ *
+ * @param a
+ * @param b
+ */
+export declare function updateMaybeValue<T>(a: Maybe<T>, b: Maybe<T>): Maybe<T>;

package/test/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [11.1.1](https://github.com/dereekb/dbx-components/compare/v11.1.0-dev...v11.1.1) (2025-03-03)
+
+
+
+# [11.1.0](https://github.com/dereekb/dbx-components/compare/v11.0.21-dev...v11.1.0) (2025-02-28)
+
+
+
 ## [11.0.21](https://github.com/dereekb/dbx-components/compare/v11.0.20-dev...v11.0.21) (2025-01-28)
 
 

package/test/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/util/test",
-  "version": "11.0.21",
+  "version": "11.1.1",
   "type": "commonjs",
   "peerDependencies": {
     "@dereekb/util": "*"