@duplojs/utils 1.4.33 → 1.4.34

package/dist/pattern/index.mjs

@@ -5,6 +5,7 @@ export { match } from './match/index.mjs';
 export { isMatch } from './isMatch.mjs';
 export { union } from './union.mjs';
 export { when } from './when.mjs';
+export { whenNot } from './whenNot.mjs';
 export { InvalidExhaustivePatternError, matchBuilder } from './match/builder.mjs';
 export { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
 

package/dist/pattern/whenNot.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var result = require('./result.cjs');
+
+function whenNot(...args) {
+    if (args.length === 2) {
+        const [predicate, theFunction] = args;
+        return (input) => whenNot(input, predicate, theFunction);
+    }
+    const [input, predicate, theFunction] = args;
+    if (!result.isResult(input) && !predicate(input)) {
+        return result.result(theFunction(input));
+    }
+    return input;
+}
+
+exports.whenNot = whenNot;

package/dist/pattern/whenNot.d.ts

@@ -0,0 +1,49 @@
+import { type AnyValue, type BreakGenericLink, type IsEqual, type EscapeVoid } from "../common";
+import { type PatternResult } from "./result";
+/**
+ * Applies a handler when a predicate fails.
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenNot(input, predicate, handler)` -> returns a result or the input
+ * - Curried: `whenNot(predicate, handler)` -> returns a function waiting for the input
+ * - Classic predicate: `whenNot(input, isType, handler)` -> narrows input types
+ * - Curried predicate: `whenNot(isType, handler)` -> narrows input types
+ * 
+ * If the predicate fails, the handler runs and the result is wrapped for chaining.
+ * The input is not mutated.
+ * 
+ * ```ts
+ * pipe(
+ * 	2,
+ * 	P.whenNot(
+ * 		(value) => value > 3,
+ * 		(value) => value * 2,
+ * 	),
+ * 	P.otherwise((value) => value),
+ * ); // 4
+ * 
+ * A.map(
+ * 	<const>["alpha", 2],
+ * 	innerPipe(
+ * 		P.whenNot(
+ * 			isType("string"),
+ * 			(value) => value + 1,
+ * 		),
+ * 		P.otherwise((value) => value),
+ * 	),
+ * ); // ["alpha", 3]
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads (type guards) narrow the output type
+ * 
+ * @see [`P.otherwise`](https://utils.duplojs.dev/en/v1/api/pattern/otherwise) For fallbacks
+ * @see https://utils.duplojs.dev/en/v1/api/pattern/whenNot
+ * 
+ * @namespace P
+ * 
+ */
+export declare function whenNot<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue | EscapeVoid>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInputValue, GenericPredicatedInput>) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<BreakGenericLink<GenericInput>, Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult> | PatternResult<GenericOutput>);
+export declare function whenNot<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue | EscapeVoid>(predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);
+export declare function whenNot<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue | EscapeVoid>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInputValue, GenericPredicatedInput>) => GenericOutput): (GenericInputPatternResult | Exclude<BreakGenericLink<GenericInput>, Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult> | PatternResult<GenericOutput>);
+export declare function whenNot<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue | EscapeVoid>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);

package/dist/pattern/whenNot.mjs

@@ -0,0 +1,15 @@
+import { isResult, result } from './result.mjs';
+
+function whenNot(...args) {
+    if (args.length === 2) {
+        const [predicate, theFunction] = args;
+        return (input) => whenNot(input, predicate, theFunction);
+    }
+    const [input, predicate, theFunction] = args;
+    if (!isResult(input) && !predicate(input)) {
+        return result(theFunction(input));
+    }
+    return input;
+}
+
+export { whenNot };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.33",
+  "version": "1.4.34",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"