@koine/utils 2.0.0-beta.183 → 2.0.0-beta.185

package/index.d.ts

@@ -155,7 +155,7 @@ export { uppercase } from "./uppercase";
 export { uuid } from "./uuid";
 export { uuidNumeric } from "./uuidNumeric";
 export { wait } from "./wait";
-export type { AnythingFalsy, FlatObjectFirstLevel, KeysStartsWith, KeysTailsStartsWith, PickStartsWith, PickStartsWithTails, Reverse, TestType, } from "./types";
+export type { AnythingFalsy, FlatObjectFirstLevel, KeysStartsWith, KeysTailsStartsWith, NonNullableObjectDeep, NullableObjectDeep, OmitNever, PickStartsWith, PickStartsWithTails, RequiredNonNullableObjectDeep, RequiredObjectDeep, Reverse, TestType, } from "./types";
 /**
  * These types should not be documented by using [`excludeExternals` TypeDoc flag](https://typedoc.org/options/input/#excludeexternals)
  */

package/objectMergeWithDefaults.cjs.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var isObject = require('./isObject.cjs.js');
 
-let objectMergeWithDefaults=(t,o)=>o?Object.keys(o).reduce((r,l)=>(isObject.isObject(o[l])?(t[l]||(t[l]={}),r[l]=objectMergeWithDefaults(t[l],o[l])):r[l]=void 0===o[l]||null===o[l]?t[l]:o[l],r),{...t}):t;
+let objectMergeWithDefaults=(t,l,r)=>l?Object.keys(l).reduce((u,o)=>{if(isObject.isObject(l[o]))t[o]||(t[o]={}),u[o]=objectMergeWithDefaults(t[o],l[o]);else {let e=l[o];null===e&&r?delete u[o]:u[o]=null==e?t[o]:e;}return u},{...t}):t;
 
 exports.default = objectMergeWithDefaults;
 exports.objectMergeWithDefaults = objectMergeWithDefaults;

package/objectMergeWithDefaults.d.ts

@@ -1,6 +1,12 @@
-import type { MergeDeep, RequiredDeep, Simplify } from "type-fest";
+import type { MergeDeep, SimplifyDeep } from "type-fest";
 import type { PlainObject } from "./getType";
-export type ObjectMergeWithDefaults<Defaults, Overrides, DeleteIfNull extends boolean = false> = Simplify<RequiredDeep<MergeDeep<Overrides, Defaults>>>;
+type PrepareMergeableObject<Source extends PlainObject, WhereToCheckValues extends PlainObject, ExcludeType = never> = {
+    [K in Extract<keyof Source, string> as NonNullable<Source[K]> extends never ? never : K extends keyof WhereToCheckValues ? WhereToCheckValues[K] extends ExcludeType | never ? never : K : K]-?: Exclude<Source[K], undefined> extends infer NewSource ? NewSource extends Array<any> | Readonly<Array<any>> ? NewSource : NewSource extends PlainObject ? NonNullable<WhereToCheckValues[K]> extends PlainObject ? PrepareMergeableObject<NewSource, WhereToCheckValues[K], ExcludeType> : PrepareMergeableObject<NewSource, {}> : NewSource : never;
+} extends infer O ? O : never;
+/**
+ * Type representation of {@link objectMergeWithDefaults}
+ */
+export type ObjectMergeWithDefaults<Defaults extends PlainObject, Overrides extends PlainObject, DeleteIfNull extends boolean = false> = SimplifyDeep<MergeDeep<DeleteIfNull extends true ? PrepareMergeableObject<Defaults, Overrides, null> : Defaults, PrepareMergeableObject<Overrides, Overrides, null | undefined>>>;
 /**
  * Merge object _overrides_ onto object _defaults_, immutably
  *
@@ -10,8 +16,9 @@ export type ObjectMergeWithDefaults<Defaults, Overrides, DeleteIfNull extends bo
  * makes it harder to remove a property defined on the defaults
  *
  * @category object
- * @param defaults
- * @param overrides
+ * @param defaults The default values
+ * @param overrides The values to override and/or extend the defaults
+ * @param deleteIfNull When `true` the overrides' object keys whose value is an explicit `null` will delete the keys of the output merge object
  */
-export declare let objectMergeWithDefaults: <D extends PlainObject, O extends PlainObject, DeleteIfNull extends boolean>(defaults: D, overrides?: O) => ObjectMergeWithDefaults<D, O, DeleteIfNull>;
+export declare let objectMergeWithDefaults: <D extends PlainObject, O extends PlainObject, DeleteIfNull extends boolean = false>(defaults: D, overrides?: O, deleteIfNull?: DeleteIfNull) => ObjectMergeWithDefaults<D, O, DeleteIfNull>;
 export default objectMergeWithDefaults;

package/objectMergeWithDefaults.esm.js

@@ -1,5 +1,5 @@
 import { isObject } from './isObject.esm.js';
 
-let objectMergeWithDefaults=(t,o)=>o?Object.keys(o).reduce((r,l)=>(isObject(o[l])?(t[l]||(t[l]={}),r[l]=objectMergeWithDefaults(t[l],o[l])):r[l]=void 0===o[l]||null===o[l]?t[l]:o[l],r),{...t}):t;
+let objectMergeWithDefaults=(t,l,r)=>l?Object.keys(l).reduce((u,o)=>{if(isObject(l[o]))t[o]||(t[o]={}),u[o]=objectMergeWithDefaults(t[o],l[o]);else {let e=l[o];null===e&&r?delete u[o]:u[o]=null==e?t[o]:e;}return u},{...t}):t;
 
 export { objectMergeWithDefaults as default, objectMergeWithDefaults };

package/package.json

@@ -1015,5 +1015,5 @@
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
   "types": "./index.esm.d.ts",
-  "version": "2.0.0-beta.183"
+  "version": "2.0.0-beta.185"
 }

package/types.d.ts

@@ -1,7 +1,8 @@
-import type { Replace } from "type-fest";
+import type { Replace, Simplify } from "type-fest";
 /**
  * Type to test types
  *
+ * @category type
  * @example
  *
  * ```ts
@@ -16,6 +17,8 @@ import type { Replace } from "type-fest";
 export type TestType<RightImplementation extends true, WrongImplementation extends true = true> = RightImplementation | WrongImplementation;
 /**
  * Whatever that in javascript returns `false` when checked in an `if` condition
+ *
+ * @category type
  */
 export type AnythingFalsy = null | undefined | 0 | "";
 /**
@@ -23,6 +26,7 @@ export type AnythingFalsy = null | undefined | 0 | "";
  * root.
  *
  * @borrows [SO' answer by jcalz](https://stackoverflow.com/a/78779784/1938970)
+ * @category type
  */
 export type FlatObjectFirstLevel<T extends object> = {
     [K in keyof T]: (x: T[K]) => void;
@@ -32,17 +36,23 @@ export type FlatObjectFirstLevel<T extends object> = {
 /**
  * Pick the keys of an object `T` that starts with `S`. It produces a mapped type
  * with a subset of `T` whose keys start with `S`.
+ *
+ * @category type
  */
 export type PickStartsWith<T extends object, S extends string> = {
     [K in keyof T as K extends `${S}${string}` ? K : never]: T[K];
 };
 /**
  * Returns a union of all the keys of an object `T` which starts with `S`.
+ *
+ * @category type
  */
 export type KeysStartsWith<T extends object, S extends string> = keyof PickStartsWith<T, S>;
 /**
  * Pick the keys of an object `T` that starts with `S`. It produces a mapped type
  * with a subset of `T` whose keys start with `S` *and have `S`* removed.
+ *
+ * @category type
  */
 export type PickStartsWithTails<T extends object, S extends string> = {
     [K in keyof T as K extends `${S}${string}` ? Replace<K, S, ""> : never]: T[K];
@@ -50,9 +60,61 @@ export type PickStartsWithTails<T extends object, S extends string> = {
 /**
  * Returns a union of all the keys of an object `T` which starts with `S`.
  * The strings in the produced union *have `S` removed*.
+ *
+ * @category type
  */
 export type KeysTailsStartsWith<T extends object, S extends string> = keyof PickStartsWithTails<T, S>;
 /**
  * @borrows [SO's answer by 钵钵鸡实力代购](https://stackoverflow.com/a/64994122/1938970)
  */
 export type Reverse<Tuple> = Tuple extends [infer Head, ...infer Rest] ? [...Reverse<Rest>, Head] : [];
+/**
+ * Make _nullable_ all properties of objec T (deeply)
+ * @use `{ key: $ | null }`
+ *
+ * @category type
+ */
+export type NullableObjectDeep<T extends object> = {
+    [K in keyof T]: T[K] extends object ? NullableObjectDeep<T[K]> | null : T[K] | null;
+};
+/**
+ * Make _non nullable_ all properties of objec T (deeply)
+ * @use `{ key: NonNullable<$> }`
+ *
+ * @category type
+ */
+export type NonNullableObjectDeep<T extends object> = {
+    [K in keyof T]: T[K] extends object ? NonNullableObjectDeep<NonNullable<T[K]>> : NonNullable<T[K]>;
+};
+/**
+ * Make _required_ all properties of objec T (deeply)
+ * @use `{ key-?: Exclude<$, undefined> }`
+ *
+ * @category type
+ */
+export type RequiredObjectDeep<T extends object> = Simplify<{
+    [K in keyof T]-?: T[K] extends object ? Exclude<RequiredObjectDeep<T[K]>, undefined> : Exclude<T[K], undefined>;
+}>;
+/**
+ * Make _required_ and _non nullable_ all properties of objec T (deeply)
+ * @use `{ key-?: NonNullable<$> }`
+ *
+ * @category type
+ */
+export type RequiredNonNullableObjectDeep<T extends object> = Simplify<{
+    [K in keyof T]-?: T[K] extends object ? NonNullable<RequiredNonNullableObjectDeep<T[K]>> : NonNullable<T[K]>;
+}>;
+/**
+ * Construct a type with the properties of T except for those whose value is `never`
+ *
+ * @category type
+ *
+@example
+```ts
+type A = OmitNever<"a" | never>; // A = "a"
+type B = OmitNever<{ a: never; b: 1 }> // B = { b: 1; }
+```
+ */
+export type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};