@nicolastoulemont/std 0.1.0

package/dist/predicate-B6-EdVgW.mjs

@@ -0,0 +1,293 @@
+//#region src/predicate/predicate.ts
+/**
+* Negate a predicate.
+* Returns true when the original predicate returns false, and vice versa.
+*
+* @template T - The type being tested
+* @param predicate - The predicate to negate
+* @returns A new predicate that returns the opposite boolean
+*
+* @example
+* ```ts
+* const isEven = (n: number) => n % 2 === 0
+* const isOdd = Predicate.not(isEven)
+*
+* isOdd(3) // true
+* isOdd(4) // false
+*
+* // Works in filter
+* [1, 2, 3, 4].filter(Predicate.not(isEven)) // [1, 3]
+* ```
+*/
+const not = (predicate) => {
+	return (value) => !predicate(value);
+};
+/**
+* Combine predicates with logical AND.
+* Returns true only when ALL predicates return true.
+* Short-circuits on first false (lazy evaluation).
+*
+* @template T - The type being tested
+* @param predicates - The predicates to combine
+* @returns A new predicate that returns true if all predicates pass
+*
+* @example
+* ```ts
+* const isPositive = (n: number) => n > 0
+* const isEven = (n: number) => n % 2 === 0
+* const isLessThan100 = (n: number) => n < 100
+*
+* const isValidNumber = Predicate.and(isPositive, isEven, isLessThan100)
+*
+* isValidNumber(42) // true
+* isValidNumber(-2) // false (not positive)
+* isValidNumber(101) // false (not less than 100)
+* ```
+*/
+const and = (...predicates) => {
+	return (value) => {
+		for (const predicate of predicates) if (!predicate(value)) return false;
+		return true;
+	};
+};
+/**
+* Combine predicates with logical OR.
+* Returns true when ANY predicate returns true.
+* Short-circuits on first true (lazy evaluation).
+*
+* @template T - The type being tested
+* @param predicates - The predicates to combine
+* @returns A new predicate that returns true if any predicate passes
+*
+* @example
+* ```ts
+* const isZero = (n: number) => n === 0
+* const isNegative = (n: number) => n < 0
+*
+* const isNotPositive = Predicate.or(isZero, isNegative)
+*
+* isNotPositive(0) // true
+* isNotPositive(-5) // true
+* isNotPositive(5) // false
+* ```
+*/
+const or = (...predicates) => {
+	return (value) => {
+		for (const predicate of predicates) if (predicate(value)) return true;
+		return false;
+	};
+};
+/**
+* Create a predicate that tests if ALL elements in an array match.
+* Returns true for empty arrays (vacuous truth).
+*
+* @template T - The element type
+* @param predicate - The predicate to test each element
+* @returns A predicate that takes an array and returns true if all match
+*
+* @example
+* ```ts
+* const isPositive = (n: number) => n > 0
+* const allPositive = Predicate.every(isPositive)
+*
+* allPositive([1, 2, 3]) // true
+* allPositive([1, -2, 3]) // false
+* allPositive([]) // true (vacuous truth)
+*
+* // Useful for validation
+* const areAllAdults = Predicate.every((u: User) => u.age >= 18)
+* ```
+*/
+const every = (predicate) => {
+	return (arr) => arr.every(predicate);
+};
+/**
+* Create a predicate that tests if ANY element in an array matches.
+* Returns false for empty arrays.
+*
+* @template T - The element type
+* @param predicate - The predicate to test each element
+* @returns A predicate that takes an array and returns true if any match
+*
+* @example
+* ```ts
+* const isNegative = (n: number) => n < 0
+* const hasNegative = Predicate.some(isNegative)
+*
+* hasNegative([1, -2, 3]) // true
+* hasNegative([1, 2, 3]) // false
+* hasNegative([]) // false
+* ```
+*/
+const some = (predicate) => {
+	return (arr) => arr.some(predicate);
+};
+/**
+* Create a predicate that tests if NO elements in an array match.
+* Returns true for empty arrays (vacuous truth).
+* Equivalent to `not(some(predicate))`.
+*
+* @template T - The element type
+* @param predicate - The predicate that should NOT match any element
+* @returns A predicate that takes an array and returns true if none match
+*
+* @example
+* ```ts
+* const isNegative = (n: number) => n < 0
+* const noNegatives = Predicate.none(isNegative)
+*
+* noNegatives([1, 2, 3]) // true
+* noNegatives([1, -2, 3]) // false
+* noNegatives([]) // true (vacuous truth)
+* ```
+*/
+const none = (predicate) => {
+	return (arr) => !arr.some(predicate);
+};
+/**
+* Combine refinements with logical AND, preserving type narrowing.
+* Use this instead of `and` when you need to preserve type guard behavior.
+*
+* @template T - The base type
+* @template U - The narrowed type (must extend T)
+* @param refinements - The refinements to combine
+* @returns A refinement that narrows to U if all refinements pass
+*
+* @example
+* ```ts
+* type User = { name: string; age: number; verified?: boolean }
+* type Adult = User & { age: number } // age >= 18
+* type VerifiedAdult = Adult & { verified: true }
+*
+* const isAdult = (u: User): u is Adult => u.age >= 18
+* const isVerified = (u: User): u is User & { verified: true } => u.verified === true
+*
+* // Combined refinement preserves type narrowing
+* const isVerifiedAdult = Predicate.andRefinement<User, VerifiedAdult>(isAdult, isVerified)
+*
+* if (isVerifiedAdult(user)) {
+*   user.verified // TypeScript knows this is true
+* }
+* ```
+*/
+const andRefinement = (...refinements) => {
+	return (value) => {
+		for (const refinement of refinements) if (!refinement(value)) return false;
+		return true;
+	};
+};
+/**
+* Combine refinements with logical OR, preserving type narrowing.
+* Use this instead of `or` when you need to preserve type guard behavior.
+*
+* @template T - The base type
+* @template U - The narrowed type (must extend T)
+* @param refinements - The refinements to combine
+* @returns A refinement that narrows to U if any refinement passes
+*
+* @example
+* ```ts
+* const isString = (v: unknown): v is string => typeof v === "string"
+* const isNumber = (v: unknown): v is number => typeof v === "number"
+*
+* const isStringOrNumber = Predicate.orRefinement<unknown, string | number>(isString, isNumber)
+*
+* if (isStringOrNumber(value)) {
+*   // value is string | number
+* }
+* ```
+*/
+const orRefinement = (...refinements) => {
+	return (value) => {
+		for (const refinement of refinements) if (refinement(value)) return true;
+		return false;
+	};
+};
+/**
+* Create a predicate from a constant boolean value.
+* Useful for testing or as a placeholder.
+*
+* @template T - The type (can be anything)
+* @param value - The constant boolean to return
+* @returns A predicate that always returns the given value
+*
+* @example
+* ```ts
+* const alwaysTrue = Predicate.constant(true)
+* const alwaysFalse = Predicate.constant(false)
+*
+* alwaysTrue("anything") // true
+* alwaysFalse(42) // false
+* ```
+*/
+const constant = (value) => {
+	return () => value;
+};
+/**
+* Create a predicate that checks strict equality.
+*
+* @template T - The type being compared
+* @param expected - The value to compare against
+* @returns A predicate that returns true if value === expected
+*
+* @example
+* ```ts
+* const isZero = Predicate.equals(0)
+* const isHello = Predicate.equals("hello")
+*
+* isZero(0) // true
+* isZero(1) // false
+*
+* // Works with references too
+* const obj = { a: 1 }
+* const isObj = Predicate.equals(obj)
+* isObj(obj) // true
+* isObj({ a: 1 }) // false (different reference)
+* ```
+*/
+const equals = (expected) => {
+	return (value) => value === expected;
+};
+/**
+* Predicate namespace containing composable boolean functions.
+*
+* Predicates are functions that test values and return booleans.
+* This namespace provides combinators to build complex predicates
+* from simple ones, with support for type guards (refinements).
+*
+* @example
+* ```ts
+* import { Predicate, pipe } from "@repo/std"
+*
+* // Basic predicates
+* const isPositive = (n: number) => n > 0
+* const isEven = (n: number) => n % 2 === 0
+*
+* // Combine with and/or
+* const isPositiveEven = Predicate.and(isPositive, isEven)
+* const isZeroOrNegative = Predicate.or(Predicate.equals(0), Predicate.not(isPositive))
+*
+* // Array predicates
+* const allPositive = Predicate.every(isPositive)
+* const hasNegative = Predicate.some(Predicate.not(isPositive))
+*
+* // Use with filter
+* [1, 2, 3, 4, 5].filter(isPositiveEven) // [2, 4]
+* ```
+*/
+const Predicate = {
+	not,
+	and,
+	or,
+	every,
+	some,
+	none,
+	andRefinement,
+	orRefinement,
+	constant,
+	equals
+};
+
+//#endregion
+export { Predicate as t };
+//# sourceMappingURL=predicate-B6-EdVgW.mjs.map

package/dist/predicate-B6-EdVgW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-B6-EdVgW.mjs","names":[],"sources":["../src/predicate/predicate.ts"],"sourcesContent":["import type { Predicate as PredicateType, Refinement } from \"./predicate.types\"\n\n/**\n * Negate a predicate.\n * Returns true when the original predicate returns false, and vice versa.\n *\n * @template T - The type being tested\n * @param predicate - The predicate to negate\n * @returns A new predicate that returns the opposite boolean\n *\n * @example\n * ```ts\n * const isEven = (n: number) => n % 2 === 0\n * const isOdd = Predicate.not(isEven)\n *\n * isOdd(3) // true\n * isOdd(4) // false\n *\n * // Works in filter\n * [1, 2, 3, 4].filter(Predicate.not(isEven)) // [1, 3]\n * ```\n */\nexport const not = <T>(predicate: PredicateType<T>): PredicateType<T> => {\n  return (value: T): boolean => !predicate(value)\n}\n\n/**\n * Combine predicates with logical AND.\n * Returns true only when ALL predicates return true.\n * Short-circuits on first false (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if all predicates pass\n *\n * @example\n * ```ts\n * const isPositive = (n: number) => n > 0\n * const isEven = (n: number) => n % 2 === 0\n * const isLessThan100 = (n: number) => n < 100\n *\n * const isValidNumber = Predicate.and(isPositive, isEven, isLessThan100)\n *\n * isValidNumber(42) // true\n * isValidNumber(-2) // false (not positive)\n * isValidNumber(101) // false (not less than 100)\n * ```\n */\nexport const and = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (!predicate(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine predicates with logical OR.\n * Returns true when ANY predicate returns true.\n * Short-circuits on first true (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if any predicate passes\n *\n * @example\n * ```ts\n * const isZero = (n: number) => n === 0\n * const isNegative = (n: number) => n < 0\n *\n * const isNotPositive = Predicate.or(isZero, isNegative)\n *\n * isNotPositive(0) // true\n * isNotPositive(-5) // true\n * isNotPositive(5) // false\n * ```\n */\nexport const or = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (predicate(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate that tests if ALL elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if all match\n *\n * @example\n * ```ts\n * const isPositive = (n: number) => n > 0\n * const allPositive = Predicate.every(isPositive)\n *\n * allPositive([1, 2, 3]) // true\n * allPositive([1, -2, 3]) // false\n * allPositive([]) // true (vacuous truth)\n *\n * // Useful for validation\n * const areAllAdults = Predicate.every((u: User) => u.age >= 18)\n * ```\n */\nexport const every = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.every(predicate)\n}\n\n/**\n * Create a predicate that tests if ANY element in an array matches.\n * Returns false for empty arrays.\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if any match\n *\n * @example\n * ```ts\n * const isNegative = (n: number) => n < 0\n * const hasNegative = Predicate.some(isNegative)\n *\n * hasNegative([1, -2, 3]) // true\n * hasNegative([1, 2, 3]) // false\n * hasNegative([]) // false\n * ```\n */\nexport const some = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.some(predicate)\n}\n\n/**\n * Create a predicate that tests if NO elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n * Equivalent to `not(some(predicate))`.\n *\n * @template T - The element type\n * @param predicate - The predicate that should NOT match any element\n * @returns A predicate that takes an array and returns true if none match\n *\n * @example\n * ```ts\n * const isNegative = (n: number) => n < 0\n * const noNegatives = Predicate.none(isNegative)\n *\n * noNegatives([1, 2, 3]) // true\n * noNegatives([1, -2, 3]) // false\n * noNegatives([]) // true (vacuous truth)\n * ```\n */\nexport const none = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => !arr.some(predicate)\n}\n\n/**\n * Combine refinements with logical AND, preserving type narrowing.\n * Use this instead of `and` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if all refinements pass\n *\n * @example\n * ```ts\n * type User = { name: string; age: number; verified?: boolean }\n * type Adult = User & { age: number } // age >= 18\n * type VerifiedAdult = Adult & { verified: true }\n *\n * const isAdult = (u: User): u is Adult => u.age >= 18\n * const isVerified = (u: User): u is User & { verified: true } => u.verified === true\n *\n * // Combined refinement preserves type narrowing\n * const isVerifiedAdult = Predicate.andRefinement<User, VerifiedAdult>(isAdult, isVerified)\n *\n * if (isVerifiedAdult(user)) {\n *   user.verified // TypeScript knows this is true\n * }\n * ```\n */\nexport const andRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (!refinement(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine refinements with logical OR, preserving type narrowing.\n * Use this instead of `or` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if any refinement passes\n *\n * @example\n * ```ts\n * const isString = (v: unknown): v is string => typeof v === \"string\"\n * const isNumber = (v: unknown): v is number => typeof v === \"number\"\n *\n * const isStringOrNumber = Predicate.orRefinement<unknown, string | number>(isString, isNumber)\n *\n * if (isStringOrNumber(value)) {\n *   // value is string | number\n * }\n * ```\n */\nexport const orRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (refinement(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate from a constant boolean value.\n * Useful for testing or as a placeholder.\n *\n * @template T - The type (can be anything)\n * @param value - The constant boolean to return\n * @returns A predicate that always returns the given value\n *\n * @example\n * ```ts\n * const alwaysTrue = Predicate.constant(true)\n * const alwaysFalse = Predicate.constant(false)\n *\n * alwaysTrue(\"anything\") // true\n * alwaysFalse(42) // false\n * ```\n */\nexport const constant = <T>(value: boolean): PredicateType<T> => {\n  return (): boolean => value\n}\n\n/**\n * Create a predicate that checks strict equality.\n *\n * @template T - The type being compared\n * @param expected - The value to compare against\n * @returns A predicate that returns true if value === expected\n *\n * @example\n * ```ts\n * const isZero = Predicate.equals(0)\n * const isHello = Predicate.equals(\"hello\")\n *\n * isZero(0) // true\n * isZero(1) // false\n *\n * // Works with references too\n * const obj = { a: 1 }\n * const isObj = Predicate.equals(obj)\n * isObj(obj) // true\n * isObj({ a: 1 }) // false (different reference)\n * ```\n */\nexport const equals = <T>(expected: T): PredicateType<T> => {\n  return (value: T): boolean => value === expected\n}\n\n/**\n * Predicate namespace containing composable boolean functions.\n *\n * Predicates are functions that test values and return booleans.\n * This namespace provides combinators to build complex predicates\n * from simple ones, with support for type guards (refinements).\n *\n * @example\n * ```ts\n * import { Predicate, pipe } from \"@repo/std\"\n *\n * // Basic predicates\n * const isPositive = (n: number) => n > 0\n * const isEven = (n: number) => n % 2 === 0\n *\n * // Combine with and/or\n * const isPositiveEven = Predicate.and(isPositive, isEven)\n * const isZeroOrNegative = Predicate.or(Predicate.equals(0), Predicate.not(isPositive))\n *\n * // Array predicates\n * const allPositive = Predicate.every(isPositive)\n * const hasNegative = Predicate.some(Predicate.not(isPositive))\n *\n * // Use with filter\n * [1, 2, 3, 4, 5].filter(isPositiveEven) // [2, 4]\n * ```\n */\nexport const Predicate = {\n  not,\n  and,\n  or,\n  every,\n  some,\n  none,\n  andRefinement,\n  orRefinement,\n  constant,\n  equals,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,OAAU,cAAkD;AACvE,SAAQ,UAAsB,CAAC,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;AAyBjD,MAAa,OAAU,GAAG,eAA8D;AACtF,SAAQ,UAAsB;AAC5B,OAAK,MAAM,aAAa,WACtB,KAAI,CAAC,UAAU,MAAM,CAAE,QAAO;AAEhC,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,MAAS,GAAG,eAA8D;AACrF,SAAQ,UAAsB;AAC5B,OAAK,MAAM,aAAa,WACtB,KAAI,UAAU,MAAM,CAAE,QAAO;AAE/B,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,SAAY,cAA6D;AACpF,SAAQ,QAA+B,IAAI,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;AAqB7D,MAAa,QAAW,cAA6D;AACnF,SAAQ,QAA+B,IAAI,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;AAsB5D,MAAa,QAAW,cAA6D;AACnF,SAAQ,QAA+B,CAAC,IAAI,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B7D,MAAa,iBAAiC,GAAG,gBAA+D;AAC9G,SAAQ,UAAyB;AAC/B,OAAK,MAAM,cAAc,YACvB,KAAI,CAAC,WAAW,MAAM,CAAE,QAAO;AAEjC,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,gBAAgC,GAAG,gBAA+D;AAC7G,SAAQ,UAAyB;AAC/B,OAAK,MAAM,cAAc,YACvB,KAAI,WAAW,MAAM,CAAE,QAAO;AAEhC,SAAO;;;;;;;;;;;;;;;;;;;;AAqBX,MAAa,YAAe,UAAqC;AAC/D,cAAsB;;;;;;;;;;;;;;;;;;;;;;;;AAyBxB,MAAa,UAAa,aAAkC;AAC1D,SAAQ,UAAsB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B1C,MAAa,YAAY;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/dist/result/index.d.mts

@@ -0,0 +1,3 @@
+import { i as Result$1 } from "../result.types-Ce7AEOzj.mjs";
+import { t as Result } from "../index-DgOAEEpu.mjs";
+export { Result, Result$1 as ResultType };

package/dist/result/index.mjs

@@ -0,0 +1,3 @@
+import { t as Result } from "../result-C5tPWR60.mjs";
+
+export { Result };