@dereekb/util 13.0.5 → 13.0.6

package/index.esm.js

@@ -5480,9 +5480,28 @@ function _unsupported_iterable_to_array$j(o, minLen) {
 }
 // MARK: Object Merging/Overriding
 /**
- * Assigns all undefined values from one or more objects into the target object.
- *
- * @param object
+ * Assigns all non-filtered values from one or more source objects into the target object.
+ *
+ * Builds a template from the source objects (in order, so later sources win) and applies it to the target.
+ * By default, undefined values in the source objects are excluded from the template, so they will not override existing target values.
+ *
+ * @param target - The object to override values on.
+ * @param config - Configuration for the override operation.
+ * @param config.copy - Whether to return a shallow copy instead of mutating the target. Defaults to `false`.
+ * @param config.from - One or more source objects whose values will be applied to the target.
+ * @param config.filter - Optional filter to control which key/value pairs from sources are included. Defaults to filtering out `undefined` values.
+ * @returns The modified target (or a copy if `copy` is `true`).
+ *
+ * @example
+ * ```typescript
+ * const target = { a: 1, b: 2 };
+ * overrideInObject(target, { from: [{ a: 10, c: 3 }] });
+ * // target is now { a: 10, b: 2, c: 3 }
+ *
+ * // undefined values in source are ignored by default:
+ * overrideInObject(target, { from: [{ a: undefined, b: 99 }] });
+ * // target.a remains 10, target.b becomes 99
+ * ```
  */ function overrideInObject(target, param) {
     var _param_copy = param.copy, copy = _param_copy === void 0 ? false : _param_copy, from = param.from, filter = param.filter;
     return overrideInObjectFunctionFactory({
@@ -5491,7 +5510,27 @@ function _unsupported_iterable_to_array$j(o, minLen) {
         dynamic: true // using only once, so no need to use the cache
     })(asArray(from))(target);
 }
-function overrideInObjectFunctionFactory(param) {
+/**
+ * Creates an {@link OverrideInObjectFunctionFactory} that merges source objects into a template,
+ * then applies that template to target objects.
+ *
+ * The template is built by iterating the source objects in order (later sources override earlier ones),
+ * filtering each through the configured filter. When applied to a target, the template's values overwrite
+ * corresponding keys on the target.
+ *
+ * By default, `undefined` values in sources are excluded from the template.
+ *
+ * @param config - Configuration controlling filtering, copying, and caching behavior.
+ * @returns A factory function that accepts source objects and returns an override function.
+ *
+ * @example
+ * ```typescript
+ * const factory = overrideInObjectFunctionFactory({ copy: true });
+ * const overrideFn = factory([{ color: 'red' }, { size: 10 }]);
+ * const result = overrideFn({ color: 'blue', size: 5 });
+ * // result is { color: 'red', size: 10 } (a new copy)
+ * ```
+ */ function overrideInObjectFunctionFactory(param) {
     var filter = param.filter, copy = param.copy, _param_dynamic = param.dynamic, dynamic = _param_dynamic === void 0 ? false : _param_dynamic;
     var filterToRelevantValuesObject = filter != null ? filterFromPOJOFunction({
         filter: filter,
@@ -5518,15 +5557,49 @@ function overrideInObjectFunctionFactory(param) {
     };
 }
 /**
- * Merges all input objects into one.
+ * Merges all input objects into a single object.
+ *
+ * Objects are applied left-to-right, so the right-most (last) item in the array has the highest priority.
+ * `Maybe` values (null/undefined entries in the array) are silently ignored.
+ *
+ * By default, `undefined` values within each source object are excluded from the merge,
+ * meaning an `undefined` value will not overwrite a previously set value.
  *
- * The order of overrides is kept, so the right-most item in the array will have priority over all objects before it.
+ * @param objects - Array of objects (or null/undefined) to merge together.
+ * @param filter - Optional filter controlling which key/value pairs are included. Defaults to filtering out `undefined` values (`KeyValueTypleValueFilter.UNDEFINED`).
+ * @returns A new object containing the merged result.
  *
- * @param objects
+ * @example
+ * ```typescript
+ * const result = mergeObjects([{ a: 1, b: 2 }, { b: 3, c: 4 }]);
+ * // result is { a: 1, b: 3, c: 4 }
+ *
+ * // undefined values in sources do not override:
+ * const result2 = mergeObjects([{ a: 1 }, { a: undefined, b: 2 }]);
+ * // result2 is { a: 1, b: 2 }
+ * ```
  */ function mergeObjects(objects, filter) {
     return mergeObjectsFunction(filter)(objects);
 }
-function mergeObjectsFunction(filter) {
+/**
+ * Creates a reusable {@link MergeObjectsFunction} with a pre-configured filter.
+ *
+ * Useful when you need to merge objects multiple times with the same filter configuration.
+ * By default, `undefined` values are filtered out of the result (`KeyValueTypleValueFilter.UNDEFINED`).
+ *
+ * @param filter - Optional filter controlling which key/value pairs are included. Defaults to filtering out `undefined` values.
+ * @returns A reusable merge function.
+ *
+ * @example
+ * ```typescript
+ * const merge = mergeObjectsFunction();
+ * const result = merge([{ a: 1 }, { b: 2 }, { a: 3 }]);
+ * // result is { a: 3, b: 2 }
+ *
+ * // With null filter to also exclude null values:
+ * const mergeNoNulls = mergeObjectsFunction(KeyValueTypleValueFilter.NULL);
+ * ```
+ */ function mergeObjectsFunction(filter) {
     var overrideFn = overrideInObjectFunctionFactory({
         filter: filter,
         copy: false,
@@ -5538,20 +5611,37 @@ function mergeObjectsFunction(filter) {
 }
 // MARK: POJO
 /**
- * Returns a copy of the input object with all undefined (and null values if filterNull=true) values filtered/removed from it.
+ * Returns a copy of the input object with all `undefined` values removed.
+ * When `filterNull` is `true`, `null` values are also removed.
  *
- * @param obj
- * @returns
+ * This is a convenience wrapper around {@link filterOnlyUndefinedValues} and {@link filterNullAndUndefinedValues}.
+ *
+ * @param obj - The object to filter.
+ * @param filterNull - If `true`, both `null` and `undefined` values are removed. Defaults to `false`.
+ * @returns A shallow copy of the object with filtered values removed.
+ *
+ * @example
+ * ```typescript
+ * filterUndefinedValues({ a: 1, b: undefined, c: null });
+ * // { a: 1, c: null }
+ *
+ * filterUndefinedValues({ a: 1, b: undefined, c: null }, true);
+ * // { a: 1 }
+ * ```
  */ function filterUndefinedValues(obj) {
     var filterNull = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
     var filterFn = filterNull ? filterNullAndUndefinedValues : filterOnlyUndefinedValues;
     return filterFn(obj);
 }
 /**
- * Returns a copy of the input object with all undefined values filtered from it.
+ * Pre-built filter that returns a copy of the input object with all `undefined` values removed.
+ * Keys with `null` or other falsy values are retained.
  *
- * @param obj
- * @returns
+ * @example
+ * ```typescript
+ * filterOnlyUndefinedValues({ a: 1, b: undefined, c: null });
+ * // { a: 1, c: null }
+ * ```
  */ var filterOnlyUndefinedValues = filterFromPOJOFunction({
     copy: true,
     filter: {
@@ -5559,10 +5649,14 @@ function mergeObjectsFunction(filter) {
     }
 });
 /**
- * Returns a copy of the input object with all null and undefined values filtered from it.
+ * Pre-built filter that returns a copy of the input object with all `null` and `undefined` values removed.
+ * Keys with other falsy values (0, false, '') are retained.
  *
- * @param obj
- * @returns
+ * @example
+ * ```typescript
+ * filterNullAndUndefinedValues({ a: 1, b: undefined, c: null, d: 0 });
+ * // { a: 1, d: 0 }
+ * ```
  */ var filterNullAndUndefinedValues = filterFromPOJOFunction({
     copy: true,
     filter: {
@@ -5570,10 +5664,14 @@ function mergeObjectsFunction(filter) {
     }
 });
 /**
- * Returns a copy of the input object with all empty values filtered from it.
+ * Pre-built filter that returns a copy of the input object with all empty values removed.
+ * Empty values include `null`, `undefined`, empty strings (`''`), empty arrays (`[]`), and empty objects (`{}`).
  *
- * @param obj
- * @returns
+ * @example
+ * ```typescript
+ * filterEmptyPojoValues({ a: 1, b: '', c: [], d: null, e: 'hello' });
+ * // { a: 1, e: 'hello' }
+ * ```
  */ var filterEmptyPojoValues = filterFromPOJOFunction({
     copy: true,
     filter: {
@@ -5581,10 +5679,14 @@ function mergeObjectsFunction(filter) {
     }
 });
 /**
- * Returns a copy of the input object with all falsy and empty filtered from it.
+ * Pre-built filter that returns a copy of the input object with all falsy and empty values removed.
+ * Removes `null`, `undefined`, `0`, `false`, `''`, empty arrays, and empty objects.
  *
- * @param obj
- * @returns
+ * @example
+ * ```typescript
+ * filterFalsyAndEmptyValues({ a: 1, b: false, c: 0, d: '', e: 'hello' });
+ * // { a: 1, e: 'hello' }
+ * ```
  */ var filterFalsyAndEmptyValues = filterFromPOJOFunction({
     copy: true,
     filter: {
@@ -5592,40 +5694,76 @@ function mergeObjectsFunction(filter) {
     }
 });
 /**
- * Returns all keys that are not associated with an undefined value.
+ * Pre-built function that returns all keys from a POJO whose values are not `undefined`.
+ * Keys with `null` or other falsy values are included in the result.
  *
- * @param obj
- * @returns
+ * @example
+ * ```typescript
+ * allNonUndefinedKeys({ a: 'test', b: undefined, c: null, d: 0 });
+ * // ['a', 'c', 'd']
+ * ```
  */ var allNonUndefinedKeys = findPOJOKeysFunction({
     valueFilter: KeyValueTypleValueFilter.UNDEFINED
 });
 /**
- * Returns all keys that are not associated with a falsy or empty value.
+ * Pre-built function that returns all keys from a POJO whose values are not falsy or empty.
+ * Excludes keys with `null`, `undefined`, `0`, `false`, `''`, empty arrays, or empty objects.
  *
- * @param obj
- * @returns
+ * @example
+ * ```typescript
+ * allFalsyOrEmptyKeys({ a: 'test', b: false, c: 0, d: null });
+ * // ['a']
+ * ```
  */ var allFalsyOrEmptyKeys = findPOJOKeysFunction({
     valueFilter: KeyValueTypleValueFilter.FALSY_AND_EMPTY
 });
 /**
- * Returns all keys that are not associated with a null/undefined value.
+ * Pre-built function that returns all keys from a POJO whose values are not `null` or `undefined`.
+ * Keys with other falsy values (0, false, '') are included.
  *
- * @param obj
- * @returns
+ * @example
+ * ```typescript
+ * allMaybeSoKeys({ a: 'test', b: undefined, c: null, d: 0 });
+ * // ['a', 'd']
+ * ```
  */ var allMaybeSoKeys = findPOJOKeysFunction({
     valueFilter: KeyValueTypleValueFilter.NULL
 });
 // MARK: FindPOJOKeys
 /**
- * Finds keys from the POJO that meet the filter.
+ * Finds and returns keys from the POJO whose values pass the given filter.
  *
- * @param obj
- * @param filter
- * @returns
+ * The filter determines which values are considered "matching" — matched values have their keys included in the result.
+ * For example, using `KeyValueTypleValueFilter.UNDEFINED` returns all keys whose values are NOT `undefined`.
+ *
+ * @param obj - The object to inspect.
+ * @param filter - A {@link FilterKeyValueTuplesInput} controlling which key/value pairs match. Required (no default).
+ * @returns Array of keys whose values pass the filter.
+ *
+ * @example
+ * ```typescript
+ * findPOJOKeys({ a: 1, b: undefined, c: null }, KeyValueTypleValueFilter.NULL);
+ * // ['a'] — only 'a' has a non-null, non-undefined value
+ * ```
  */ function findPOJOKeys(obj, filter) {
     return findPOJOKeysFunction(filter)(obj);
 }
-function findPOJOKeysFunction(filter) {
+/**
+ * Creates a reusable {@link FindPOJOKeysFunction} with a pre-configured filter.
+ *
+ * The returned function inspects each key/value pair on the input object and collects keys
+ * whose values pass the filter.
+ *
+ * @param filter - A {@link FilterKeyValueTuplesInput} controlling which values match. Required (no default).
+ * @returns A reusable function that returns matching keys from any input object.
+ *
+ * @example
+ * ```typescript
+ * const findDefinedKeys = findPOJOKeysFunction(KeyValueTypleValueFilter.UNDEFINED);
+ * findDefinedKeys({ a: 1, b: undefined, c: 'hello' });
+ * // ['a', 'c']
+ * ```
+ */ function findPOJOKeysFunction(filter) {
     var findEachMatchingKeyOnTarget = forEachKeyValueOnPOJOFunction({
         filter: filter,
         forEach: function forEach(param, i, obj, context) {
@@ -5643,16 +5781,41 @@ function findPOJOKeysFunction(filter) {
 }
 // MARK: CountPOJOKeys
 /**
- * Finds and counts the number of keys from the POJO that meet the filter.
+ * Counts the number of keys on the POJO whose values pass the given filter.
  *
- * @param obj
- * @param filter
- * @returns
+ * By default, counts all keys whose values are not `undefined` (`KeyValueTypleValueFilter.UNDEFINED`).
+ *
+ * @param obj - The object to inspect.
+ * @param filter - A {@link FilterKeyValueTuplesInput} controlling which values are counted. Defaults to `KeyValueTypleValueFilter.UNDEFINED`.
+ * @returns The number of keys whose values pass the filter.
+ *
+ * @example
+ * ```typescript
+ * countPOJOKeys({ a: 1, b: undefined, c: null });
+ * // 2 — 'a' and 'c' are not undefined
+ *
+ * countPOJOKeys({ a: 1, b: undefined, c: null }, KeyValueTypleValueFilter.NULL);
+ * // 1 — only 'a' is not null or undefined
+ * ```
  */ function countPOJOKeys(obj) {
     var filter = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : KeyValueTypleValueFilter.UNDEFINED;
     return countPOJOKeysFunction(filter)(obj);
 }
-function countPOJOKeysFunction() {
+/**
+ * Creates a reusable {@link CountPOJOKeysFunction} with a pre-configured filter.
+ *
+ * By default, counts all keys whose values are not `undefined` (`KeyValueTypleValueFilter.UNDEFINED`).
+ *
+ * @param filter - A {@link FilterKeyValueTuplesInput} controlling which values are counted. Defaults to `KeyValueTypleValueFilter.UNDEFINED`.
+ * @returns A reusable function that counts matching keys on any input object.
+ *
+ * @example
+ * ```typescript
+ * const countDefined = countPOJOKeysFunction();
+ * countDefined({ a: 1, b: undefined, c: 'test' });
+ * // 2
+ * ```
+ */ function countPOJOKeysFunction() {
     var filter = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KeyValueTypleValueFilter.UNDEFINED;
     var countEachMatchingKeyOnTarget = forEachKeyValueOnPOJOFunction({
         filter: filter,
@@ -5669,15 +5832,53 @@ function countPOJOKeysFunction() {
     };
 }
 /**
- * Removes values, per the the filter config, from the input object.
+ * Removes values from the input object based on the filter configuration.
+ *
+ * By default, removes `undefined` values and does NOT copy the object (mutates in place).
+ * Pass `{ copy: true }` to get a new object without modifying the original.
  *
- * @param obj POJO to remove undefined values from.
- * @param copy Whether or not to return a copy of the input object. Default is true.
+ * @param obj - The POJO to filter values from.
+ * @param config - Configuration for filtering and copying behavior. Defaults to removing `undefined` values without copying.
+ * @returns The filtered object (either the mutated original or a shallow copy, depending on `config.copy`).
+ *
+ * @example
+ * ```typescript
+ * // Remove undefined values (default):
+ * filterFromPOJO({ a: 1, b: undefined, c: 'hello' });
+ * // { a: 1, c: 'hello' }
+ *
+ * // Remove null and undefined values:
+ * filterFromPOJO({ a: 1, b: null, c: undefined }, { filter: { valueFilter: KeyValueTypleValueFilter.NULL } });
+ * // { a: 1 }
+ * ```
  */ function filterFromPOJO(obj) {
     var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
     return filterFromPOJOFunction(config)(obj);
 }
-function filterFromPOJOFunction() {
+/**
+ * Creates a reusable {@link FilterFromPOJOFunction} with a pre-configured filter and copy behavior.
+ *
+ * The returned function removes key/value pairs that match the filter from the input object.
+ * Internally, the filter is inverted so that matching values are deleted while non-matching values are retained.
+ *
+ * By default, removes `undefined` values (`KeyValueTypleValueFilter.UNDEFINED`) and does not copy (`copy: false`).
+ *
+ * @param config - Configuration for filtering and copying. Defaults to `{ copy: false, filter: { valueFilter: KeyValueTypleValueFilter.UNDEFINED } }`.
+ * @returns A reusable filter function. The returned function also accepts a `copyOverride` argument to override the copy behavior per-call.
+ *
+ * @example
+ * ```typescript
+ * // Default: removes undefined values, mutates in place
+ * const filterUndef = filterFromPOJOFunction();
+ * const obj = { a: 1, b: undefined };
+ * filterUndef(obj); // obj is now { a: 1 }
+ *
+ * // With copy and null filter:
+ * const filterNulls = filterFromPOJOFunction({ copy: true, filter: { valueFilter: KeyValueTypleValueFilter.NULL } });
+ * const result = filterNulls({ a: 1, b: null, c: undefined });
+ * // result is { a: 1 }, original is unchanged
+ * ```
+ */ function filterFromPOJOFunction() {
     var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_copy = _ref.copy, copy = _ref_copy === void 0 ? false : _ref_copy, tmp = _ref.filter, inputFilter = tmp === void 0 ? {
         valueFilter: KeyValueTypleValueFilter.UNDEFINED
     } : tmp;
@@ -5700,19 +5901,60 @@ function filterFromPOJOFunction() {
     };
 }
 /**
- * Convenience function from filterFromPOJOFunction with copy set to false and using the default filter.
+ * Pre-built {@link FilterFromPOJOFunction} that removes `undefined` values by mutating the input object (no copy).
+ *
+ * Used internally as the default filter for {@link overrideInObjectFunctionFactory} when no filter is provided.
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1, b: undefined };
+ * defaultFilterFromPOJOFunctionNoCopy(obj);
+ * // obj is now { a: 1 }
+ * ```
  */ var defaultFilterFromPOJOFunctionNoCopy = filterFromPOJOFunction({
     copy: false
 });
 // MARK: AssignValuesToPOJO
-function assignValuesToPOJO(target, obj, input) {
+/**
+ * Assigns filtered values from `obj` onto `target`.
+ *
+ * By default, only non-`undefined` values from `obj` are assigned, and a copy of `target` is returned (the original is not mutated).
+ *
+ * @param target - The object to assign values onto.
+ * @param obj - The source object whose matching values will be assigned.
+ * @param input - Optional filter/copy configuration. Defaults to `KeyValueTypleValueFilter.UNDEFINED` with `copy: true`.
+ * @returns The target with values assigned (either a copy or the original, depending on configuration).
+ *
+ * @example
+ * ```typescript
+ * const target = { a: 1, b: 2 };
+ * const result = assignValuesToPOJO(target, { a: 10, b: undefined });
+ * // result is { a: 10, b: 2 } (copy), target unchanged
+ * ```
+ */ function assignValuesToPOJO(target, obj, input) {
     return assignValuesToPOJOFunction(input)(target, obj);
 }
 /**
- * Creates a AssignValuesToPOJOFunction from the input values.
+ * Creates a reusable {@link AssignValuesToPOJOFunction} with a pre-configured filter and copy behavior.
  *
- * @param input
- * @returns
+ * The returned function assigns key/value pairs from a source object onto a target, skipping pairs
+ * that are filtered out. By default, `undefined` values are filtered out (`KeyValueTypleValueFilter.UNDEFINED`)
+ * and the target is copied before assignment (`copy: true`).
+ *
+ * @param input - Filter and copy configuration. Defaults to `KeyValueTypleValueFilter.UNDEFINED` (filter undefined, copy target).
+ * @returns A reusable assign function with a `_returnCopyByDefault` property indicating the configured copy behavior.
+ *
+ * @example
+ * ```typescript
+ * // Default: filters undefined, returns a copy
+ * const assign = assignValuesToPOJOFunction();
+ * const target = { a: 1, b: 2 };
+ * const result = assign(target, { a: 10, b: undefined });
+ * // result is { a: 10, b: 2 }, target is unchanged
+ *
+ * // With NULL filter and no copy:
+ * const assignNoNulls = assignValuesToPOJOFunction({ valueFilter: KeyValueTypleValueFilter.NULL, copy: false });
+ * ```
  */ function assignValuesToPOJOFunction() {
     var input = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KeyValueTypleValueFilter.UNDEFINED;
     var _ref;
@@ -5736,12 +5978,48 @@ function assignValuesToPOJO(target, obj, input) {
 }
 // MARK: ValuesFromPOJO
 /**
- * Reads values from matching keys based on the filter and puts them into an array.
+ * Extracts values from the POJO whose key/value pairs pass the given filter, returning them as an array.
+ *
+ * By default, only non-`undefined` values are included (`KeyValueTypleValueFilter.UNDEFINED`).
+ *
+ * @param target - The object to extract values from.
+ * @param filter - A {@link FilterKeyValueTuplesInput} controlling which values are included. Defaults to `KeyValueTypleValueFilter.UNDEFINED`.
+ * @returns Array of values whose key/value pairs passed the filter.
+ *
+ * @example
+ * ```typescript
+ * valuesFromPOJO({ a: 1, b: undefined, c: 'hello' });
+ * // [1, 'hello']
+ *
+ * valuesFromPOJO({ a: 1, b: null, c: 'hello' }, KeyValueTypleValueFilter.NULL);
+ * // [1, 'hello']  — null excluded
+ * ```
  */ function valuesFromPOJO(target) {
     var filter = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : KeyValueTypleValueFilter.UNDEFINED;
     return valuesFromPOJOFunction(filter)(target);
 }
-function valuesFromPOJOFunction() {
+/**
+ * Creates a reusable {@link ValuesFromPOJOFunction} with a pre-configured filter.
+ *
+ * The returned function iterates each key/value pair on the input object, collects values
+ * from pairs that pass the filter, and returns them as an array.
+ *
+ * By default, only non-`undefined` values are included (`KeyValueTypleValueFilter.UNDEFINED`).
+ *
+ * @param filter - A {@link FilterKeyValueTuplesInput} controlling which values are included. Defaults to `KeyValueTypleValueFilter.UNDEFINED`.
+ * @returns A reusable function that extracts matching values from any input object.
+ *
+ * @example
+ * ```typescript
+ * const getDefinedValues = valuesFromPOJOFunction();
+ * getDefinedValues({ a: 1, b: undefined, c: 'test' });
+ * // [1, 'test']
+ *
+ * const getNonNullValues = valuesFromPOJOFunction(KeyValueTypleValueFilter.NULL);
+ * getNonNullValues({ a: 1, b: null, c: undefined });
+ * // [1]
+ * ```
+ */ function valuesFromPOJOFunction() {
     var filter = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KeyValueTypleValueFilter.UNDEFINED;
     var addValuesFromObjectToContext = forEachKeyValueOnPOJOFunction({
         filter: filter,
@@ -5760,10 +6038,25 @@ function valuesFromPOJOFunction() {
 }
 // MARK: Filter Keys
 /**
- * Returns a FilterTuplesOnPOJOFunction that returns an object that contains only the input keys, or does not contain the input keys if invertFilter is true.
+ * Creates a {@link FilterTuplesOnPOJOFunction} that retains only keys present in `keysToFilter`,
+ * or excludes them if `invertFilter` is `true`.
  *
- * @param keysToFilter
- * @returns
+ * Always returns a new object (never mutates the input).
+ *
+ * @param keysToFilter - The set of keys to include (or exclude when inverted).
+ * @param invertFilter - When `true`, keys in `keysToFilter` are excluded instead of included. Defaults to `false`.
+ * @returns A function that filters keys on any input POJO.
+ *
+ * @example
+ * ```typescript
+ * const pickAB = filterKeysOnPOJOFunction(['a', 'b']);
+ * pickAB({ a: 1, b: 2, c: 3 });
+ * // { a: 1, b: 2 }
+ *
+ * const omitAB = filterKeysOnPOJOFunction(['a', 'b'], true);
+ * omitAB({ a: 1, b: 2, c: 3 });
+ * // { c: 3 }
+ * ```
  */ function filterKeysOnPOJOFunction(keysToFilter) {
     var invertFilter = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
     var keysSet = new Set(keysToFilter);
@@ -5773,7 +6066,22 @@ function valuesFromPOJOFunction() {
     }, invertFilter);
     return filterTuplesOnPOJOFunction(filterFn);
 }
-function filterTuplesOnPOJOFunction(filterTupleOnObject) {
+/**
+ * Creates a {@link FilterTuplesOnPOJOFunction} from a raw entry filter predicate.
+ *
+ * The returned function iterates all entries of the input object, applies the predicate,
+ * and returns a new object containing only the entries that pass.
+ *
+ * @param filterTupleOnObject - Predicate applied to each `[key, value]` entry.
+ * @returns A function that filters entries on any input POJO.
+ *
+ * @example
+ * ```typescript
+ * const keepStrings = filterTuplesOnPOJOFunction(([, value]) => typeof value === 'string');
+ * keepStrings({ a: 'hello', b: 42, c: 'world' });
+ * // { a: 'hello', c: 'world' }
+ * ```
+ */ function filterTuplesOnPOJOFunction(filterTupleOnObject) {
     return function(input) {
         var result = {};
         Object.entries(input).filter(filterTupleOnObject).forEach(function(tuple) {
@@ -5782,7 +6090,28 @@ function filterTuplesOnPOJOFunction(filterTupleOnObject) {
         return result;
     };
 }
-function forEachKeyValueOnPOJOFunction(param) {
+/**
+ * Creates a reusable function that iterates over filtered key/value pairs of a POJO,
+ * invoking a callback for each matching pair.
+ *
+ * This is the low-level building block used by {@link filterFromPOJOFunction}, {@link findPOJOKeysFunction},
+ * {@link countPOJOKeysFunction}, {@link assignValuesToPOJOFunction}, and {@link valuesFromPOJOFunction}.
+ *
+ * When no filter is provided, all key/value pairs are iterated.
+ *
+ * @param config - The filter and forEach callback configuration.
+ * @returns A function that iterates matching key/value pairs on any input object.
+ *
+ * @example
+ * ```typescript
+ * const logDefined = forEachKeyValueOnPOJOFunction<Record<string, unknown>, void>({
+ *   filter: KeyValueTypleValueFilter.UNDEFINED,
+ *   forEach: ([key, value]) => console.log(key, value)
+ * });
+ * logDefined({ a: 1, b: undefined, c: 'test' });
+ * // logs: 'a' 1, 'c' 'test'
+ * ```
+ */ function forEachKeyValueOnPOJOFunction(param) {
     var forEach = param.forEach, filter = param.filter;
     var filterKeyValues = filterKeyValueTuplesFunction(filter);
     return function(obj, context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/util",
-  "version": "13.0.5",
+  "version": "13.0.6",
   "exports": {
     "./test": {
       "module": "./test/index.esm.js",