feat(arr,fn,null,num,obj,prom,str,url,err,http,json,pat,ts,value):

import utils from Graffle

Author: jasonkuhrt

src/domains/arr/arr.ts

@@ -12,6 +12,50 @@ export type Any = readonly any[]
 
 export type Empty = readonly []
 
+// Note: UnionToTuple is exported from Union namespace as Union.ToTuple
+
+/**
+ * Check if all booleans in a tuple are true.
+ *
+ * @example
+ * ```ts
+ * type T1 = All<[true, true, true]>  // true
+ * type T2 = All<[true, false, true]>  // false
+ * ```
+ */
+export type All<$Tuple extends [...boolean[]]> = $Tuple[number] extends true ? true : false
+
+/**
+ * Check if a tuple has multiple elements.
+ *
+ * @example
+ * ```ts
+ * type T1 = IsTupleMultiple<[1, 2]>  // true
+ * type T2 = IsTupleMultiple<[1]>  // false
+ * ```
+ */
+export type IsTupleMultiple<$T> = $T extends [unknown, unknown, ...unknown[]] ? true : false
+
+/**
+ * Push a value onto a tuple.
+ *
+ * @example
+ * ```ts
+ * type T = Push<[1, 2], 3>  // [1, 2, 3]
+ * ```
+ */
+export type Push<$T extends any[], $V> = [...$T, $V]
+
+/**
+ * Get the first non-unknown, non-never element from a tuple.
+ */
+export type FirstNonUnknownNever<$T extends any[]> = $T extends [infer __first__, ...infer __rest__]
+  ? unknown extends __first__ ? 0 extends 1 & __first__ ? FirstNonUnknownNever<__rest__> // is any
+    : FirstNonUnknownNever<__rest__> // is unknown
+  : __first__ extends never ? FirstNonUnknownNever<__rest__>
+  : __first__
+  : never
+
 /**
  * Empty array constant.
  * @deprecated Use `Array.empty` from Effect instead
@@ -26,6 +70,22 @@ export type Empty = readonly []
  */
 export const empty: Empty = []
 
+/**
+ * Empty array constant (frozen).
+ * Useful as a default value or sentinel.
+ *
+ * @example
+ * ```ts
+ * const arr = items ?? Arr.emptyArray
+ * ```
+ */
+export const emptyArray = Object.freeze([] as const)
+
+/**
+ * Type for the empty array constant.
+ */
+export type EmptyArray = typeof emptyArray
+
 //
 //
 //
@@ -34,4 +94,67 @@ export const empty: Empty = []
 //
 //
 
+/**
+ * Assert that a value is an array.
+ * Throws a TypeError if the value is not an array.
+ *
+ * @param value - The value to check
+ * @throws {TypeError} If the value is not an array
+ *
+ * @example
+ * ```ts
+ * function process(value: unknown) {
+ *   Arr.assert(value)
+ *   // value is now typed as unknown[]
+ *   value.forEach(item => console.log(item))
+ * }
+ * ```
+ */
+export function assert(value: unknown): asserts value is unknown[] {
+  if (!Array.isArray(value)) {
+    throw new TypeError(`Expected array but got ${typeof value}`)
+  }
+}
+
+/**
+ * Type-safe array includes check that narrows the type of the value.
+ * Unlike the standard `includes`, this provides proper type narrowing.
+ *
+ * @param array - The array to search in
+ * @param value - The unknown value to search for
+ * @returns True if the value is in the array, with type narrowing
+ * @example
+ * ```ts
+ * const fruits = ['apple', 'banana', 'orange'] as const
+ * const value: unknown = 'apple'
+ *
+ * if (Arr.includes(fruits, value)) {
+ *   // value is now typed as 'apple' | 'banana' | 'orange'
+ * }
+ * ```
+ */
+export const includes = <$T>(array: $T[], value: unknown): value is $T => {
+  return array.includes(value as any)
+}
+
+// Note: partitionErrors is exported from ArrMut module (creates new arrays)
+
+/**
+ * Ensure a value is an array.
+ * If the value is already an array, return it as-is.
+ * Otherwise, wrap it in an array.
+ *
+ * @param value - The value to ensure as array
+ * @returns An array containing the value(s)
+ * @example
+ * ```ts
+ * Arr.ensure('hello')  // ['hello']
+ * Arr.ensure(['a', 'b'])  // ['a', 'b']
+ * Arr.ensure(42)  // [42]
+ * ```
+ */
+export const ensure = <$T>(value: $T | $T[]): $T[] => {
+  return Array.isArray(value) ? value : [value]
+}
+
 // TODO: Add immutable array operations that wrap ArrMut with copy semantics

src/domains/fn/base.ts

@@ -16,6 +16,17 @@ export const is = Lang.typeGuard<AnyAny>(value => typeof value === Lang.TypeofTy
 
 export type AnyAnyAsync = (...args: any[]) => Prom.AnyAny
 
+/**
+ * Extract the guarded type from a type guard function.
+ *
+ * @example
+ * ```ts
+ * const isString = (x: any): x is string => typeof x === 'string'
+ * type T = GuardedType<typeof isString>  // string
+ * ```
+ */
+export type GuardedType<$T> = $T extends (x: any) => x is infer __u__ ? __u__ : never
+
 /**
  * Modify function such that it only returns the given type.
  * Assumes that the given type is among the possible return types of the function.

src/domains/null/$$.ts

@@ -1,2 +1,3 @@
+export * from './null.js'
 export { Eq } from './traits/eq.js'
 export { Type } from './traits/type.js'

src/domains/null/null.ts

@@ -0,0 +1,83 @@
+/**
+ * Makes a type nullable by adding `null` to it.
+ *
+ * @template $T - The type to make nullable
+ *
+ * @example
+ * ```ts
+ * type RequiredString = string
+ * type NullableString = Maybe<RequiredString>  // string | null
+ *
+ * // Useful for database-like values
+ * function findUser(id: string): Maybe<User> {
+ *   // Returns User | null
+ *   return users.find(u => u.id === id) ?? null
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using with object properties
+ * interface DatabaseRecord {
+ *   deletedAt: Maybe<Date>
+ *   updatedBy: Maybe<string>
+ * }
+ *
+ * const record: DatabaseRecord = {
+ *   deletedAt: null,
+ *   updatedBy: 'admin'
+ * }
+ * ```
+ */
+export type Maybe<$T> = $T | null
+
+/**
+ * Excludes `null` from a type.
+ *
+ * This utility type removes `null` from a union type, leaving all other types intact.
+ * Useful for creating stricter type definitions or working with required values.
+ *
+ * @template T - The type to exclude `null` from
+ *
+ * @example
+ * ```ts
+ * type MaybeString = string | null
+ * type DefinitelyString = Exclude<MaybeString>  // string
+ *
+ * type Complex = string | number | null | undefined
+ * type WithoutNull = Exclude<Complex>  // string | number | undefined
+ *
+ * // Only null becomes never
+ * type JustNull = Exclude<null>  // never
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using with function parameters
+ * function requireValue<T>(value: T): Exclude<T> {
+ *   if (value === null) {
+ *     throw new Error('Value cannot be null')
+ *   }
+ *   return value as Exclude<T>
+ * }
+ *
+ * const result = requireValue('hello' as string | null)
+ * // result: string
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using with object properties
+ * interface User {
+ *   id: string
+ *   name: string | null
+ *   email: string | null | undefined
+ * }
+ *
+ * type RequiredUser = {
+ *   [K in keyof User]: Exclude<User[K]>
+ * }
+ * // RequiredUser: { id: string; name: string; email: string | undefined }
+ * ```
+ */
+export type Exclude<T> = T extends null ? never : T

src/domains/num/operations.ts

@@ -162,3 +162,66 @@ export const modOn = <T extends number>(dividend: T) => <U extends NonZero>(divi
 export const modWith = <U extends NonZero>(divisor: U) => <T extends number>(dividend: T): Mod<T, U> => {
   return mod(dividend, divisor)
 }
+
+/**
+ * Number literal type.
+ */
+export type NumberLiteral = number
+
+/**
+ * Add one to a number literal type.
+ */
+export type PlusOne<$n extends NumberLiteral> = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+][
+  $n
+]
+
+/**
+ * Subtract one from a number literal type.
+ */
+export type MinusOne<$n extends NumberLiteral> = [
+  -1,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+][
+  $n
+]

src/domains/num/range.test.ts

@@ -288,8 +288,8 @@ describe('interpolation', () => {
               return
             }
 
-            // Use relative tolerance for large numbers
-            const tolerance = Math.max(1e-7, Math.abs(avgValue) * 1e-10)
+            // Use relative tolerance for large numbers (1e-6 to account for floating point precision)
+            const tolerance = Math.max(1e-6, Math.abs(avgValue) * 1e-10)
             expect(Math.abs(midValue - avgValue)).toBeLessThan(tolerance)
           },
         ),

src/domains/obj/$$.ts

@@ -1,5 +1,10 @@
+export * from './filter.js'
+export * from './get.js'
+export * from './merge.js'
 export * from './obj.js'
+export * from './predicates.js'
 export * from './property-signature.js'
 export { Eq } from './traits/eq.js'
 export { Type } from './traits/type.js'
-export * from './type-utils.js'
+export * from './type.js'
+export * from './update.js'