type-plus 5.2.0 → 5.4.0

package/ts/functional/compose.ts

@@ -2,7 +2,11 @@ import type { Head, Last } from '../array/index.js'
 import type { AnyFunction } from '../function/AnyFunction.js'
 
 /**
- * compose functions
+ * Compose functions to produce a new function.
+ * @params args functions to be composed.
+ * Each function will receive the return value of the previous function as its parameters.
+ * @return The composed function will expect the parameters of the first function,
+ * and return the result of the last function.
  */
 export function compose<FS extends AnyFunction[]>(...fns: FS): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return

package/ts/functional/context.ts

@@ -0,0 +1,69 @@
+import type { LeftJoin } from '../object/index.js'
+
+export type ContextBaseShape = Record<string | symbol, any>
+
+/**
+ * Extends the context with new props.
+ * @param context the current context.
+ * @return an additional context with new properties.
+ */
+export type ContextExtender<
+  Current,
+  Additional
+> = (context: Current) => Additional
+
+export type ContextBuilder<
+  Init extends ContextBaseShape,
+  Ctx extends ContextBaseShape
+> = {
+  /**
+   * Extends the context using an extender.
+   * @param extender function that add new props to the context.
+   *
+   * The extender only need to return a new object with new properties.
+   *
+   * Do not need to merge the existing context with the new props.
+   * The builder will do that for you.
+   */
+  extend<
+    Current extends ContextBaseShape = Ctx,
+    Additional extends ContextBaseShape = ContextBaseShape
+  >(extender: ContextExtender<Current, Additional>)
+    : ContextBuilder<Init, LeftJoin<Current, Additional>>,
+  /**
+   * Build and return the context.
+   */
+  build(): Ctx
+}
+
+/**
+ * A fluent context builder.
+ *
+ * The initializer and transformer
+ *
+ * @param init The initial context or an context initializer.
+ * @return the context builder where you can
+ * use `extend()` to add context, and
+ * use `build()` to build the context.
+ */
+export function context<
+  Init extends ContextBaseShape,
+  Ctx extends ContextBaseShape = Init
+>(init?: Init | (() => Init)): ContextBuilder<Init, Ctx> {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return typeof init === 'function'
+    ? contextBuilder({}, [init])
+    : contextBuilder(init ?? {}, []) as any
+}
+
+function contextBuilder(init: ContextBaseShape, transformers: ContextExtender<any, any>[]) {
+  return {
+    extend(transformer: ContextExtender<any, any>) {
+      return contextBuilder(init, transformers.concat(transformer))
+    },
+    build() {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return transformers.reduce((p, t) => ({ ...p, ...t(p) }), init)
+    }
+  }
+}

package/ts/functional/index.ts

@@ -1,3 +1,4 @@
 // export * from './Maybe.js'
 export type { ChainFn, EndoFn } from './ChainFn.js'
 export * from './compose.js'
+export * from './context.js'

package/ts/predicates/Equal.ts

@@ -1,30 +1,26 @@
+import type { IsAny } from './IsAny.js'
+import type { And, Or } from './logical.js'
+
 /**
- * `<T>() => T extends A ? 1 : 2` idea originate from `typepark`
- * But it does not work with union types.
- *
- * `<T>() => T extends A` is a trick to create an inferred type `T`.
- * This is needed for `boolean`, `string`, and `number`,
- * as they supports literal types.
+ * Checks if the two types are equal.
  */
-
-import { IsNever } from '../PrimitiveTypes.js'
+export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
+  ? And<IsAny<A>, IsAny<B>,
+    Then,
+    Or<IsAny<A>, IsAny<B>, Else, Then>>
+  : Else
 
 /**
- * Checks if two types are equal.
+ * Checks if the two types are equal.
  */
-export type Equal<A, B, Then = true, Else = false> =
-  [A, B] extends [object, object]
-  ? (IsNever<A> extends true
-    ? (IsNever<B> extends true ? Then : Else)
-    : (A extends B ? B extends A ? Then : Else : Else))
-  : (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Then : Else
-export type IsEqual<A, B> = Equal<A, B>
+export type IsEqual<A, B, Then = true, Else = false> = Equal<A, B, Then, Else>
 
-export type NotEqual<A, B, Then = true, Else = false> =
-  [A, B] extends [object, object]
-  ? (IsNever<A> extends true
-    ? (IsNever<B> extends true ? Else : Then)
-    : (A extends B ? B extends A ? Else : Then : Then))
-  : (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Else : Then
+/**
+ * Check if the two types are not equal
+ */
+export type NotEqual<A, B, Then = true, Else = false> = Equal<A, B, Else, Then>
 
-export type IsNotEqual<A, B> = NotEqual<A, B>
+/**
+ * Check if the two types are not equal
+ */
+export type IsNotEqual<A, B, Then = true, Else = false> = NotEqual<A, B, Then, Else>

package/ts/predicates/IsAny.ts

@@ -0,0 +1,3 @@
+import type { IsExtend } from './Extends.js'
+
+export type IsAny<T, Then = true, Else = false> = boolean extends IsExtend<T, string> ? Then : Else

package/ts/predicates/index.ts

@@ -2,16 +2,13 @@ export * from './CanAssign.js'
 export type { Equal, IsEqual, IsNotEqual, NotEqual } from './Equal.js'
 export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends.js'
 export type { If } from './If.js'
+export type { IsAny } from './IsAny.js'
+export type { IsEmptyObject } from './IsEmptyObject.js'
 export * from './isType.js'
 export type { And, Not, Or, Xor } from './logical.js'
-export type { IsEmptyObject } from './IsEmptyObject.js'
-
-import type { IsExtend } from './Extends.js'
 
 export type IsLiteral<T extends number | string, Then = true, Else = false> = number extends T ?
   Else :
   string extends T ? Else : Then
 
 export type IsBoolean<T, Then = true, Else = false> = boolean extends T ? Then : Else
-
-export type IsAny<T, Then = true, Else = false> = boolean extends IsExtend<T, string> ? Then : Else

package/ts/predicates/isType.ts

@@ -21,7 +21,7 @@ isType.f = function <T extends false>(subject?: T) {
 
 /**
  * Are types A and B equals/not equals.
- * Easier to use then `isType.t<>()` and `isType.f<>()`,
+ * Easier to use than `isType.t<>()` and `isType.f<>()`,
  * when doing type level only equality comparison as you don't have to import `Equal<>`.
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/ts/predicates/logical.ts

@@ -1,4 +1,26 @@
-export type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false
-export type Or<A extends boolean, B extends boolean> = A extends true ? true : B extends true ? true : false
-export type Not<X extends boolean> = X extends true ? false : true
-export type Xor<A extends boolean, B extends boolean> = A extends true ? Not<B> : B extends true ? true : false
+export type And<
+  A extends boolean,
+  B extends boolean,
+  Then = true,
+  Else = false
+> = A extends true ? B extends true ? Then : Else : Else
+
+export type Or<
+  A extends boolean,
+  B extends boolean,
+  Then = true,
+  Else = false
+> = A extends true ? Then : B extends true ? Then : Else
+
+export type Not<
+  X extends boolean,
+  Then = true,
+  Else = false
+> = X extends true ? Else : Then
+
+export type Xor<
+  A extends boolean,
+  B extends boolean,
+  Then = true,
+  Else = false
+> = A extends Then ? Not<B> : B extends true ? Then : Else