gamla - npm Package Compare versions

Comparing version 23.0.0 to 24.0.0

esm/src/conditional.js

 import { head, second } from "./array.js";
+import { pipe } from "./composition.js";
 import { filter } from "./filter.js";
-import { pipe } from "./composition.js";
 export const ifElse = (predicate, fTrue, fFalse) => (...x) => {
@@ -12,10 +12,6 @@ const result = predicate(...x);
 };
-export const unless = (predicate, fFalse) => ifElse(predicate, 
-// @ts-expect-error cannot infer
-(...x) => x[0], fFalse);
-export const when = (predicate, fTrue) => ifElse(predicate, fTrue, 
-// @ts-expect-error cannot infer
-(...x) => x[0]);
+export const unless = (predicate, fFalse) => ifElse(predicate, (...x) => x[0], fFalse);
+export const when = (predicate, fTrue) => ifElse(predicate, fTrue, (...x) => x[0]);
 export const cond = (predicatesAndResolvers) => (...x) => 
 // @ts-expect-error cannot infer
 pipe(filter(pipe(head, (predicate) => predicate(...x))), head, second, (f) => f(...x))(predicatesAndResolvers);

package.json

@@ -6,3 +6,3 @@ {
   "name": "gamla",
-  "version": "23.0.0",
+  "version": "24.0.0",
   "description": "Functional programming with async and type safety",
@@ -9,0 +9,0 @@ "license": "MIT",

script/src/conditional.js

@@ -5,4 +5,4 @@ "use strict";
 const array_js_1 = require("./array.js");
+const composition_js_1 = require("./composition.js");
 const filter_js_1 = require("./filter.js");
-const composition_js_1 = require("./composition.js");
 const ifElse = (predicate, fTrue, fFalse) => (...x) => {
@@ -17,9 +17,5 @@ const result = predicate(...x);
 exports.ifElse = ifElse;
-const unless = (predicate, fFalse) => (0, exports.ifElse)(predicate, 
-// @ts-expect-error cannot infer
-(...x) => x[0], fFalse);
+const unless = (predicate, fFalse) => (0, exports.ifElse)(predicate, (...x) => x[0], fFalse);
 exports.unless = unless;
-const when = (predicate, fTrue) => (0, exports.ifElse)(predicate, fTrue, 
-// @ts-expect-error cannot infer
-(...x) => x[0]);
+const when = (predicate, fTrue) => (0, exports.ifElse)(predicate, fTrue, (...x) => x[0]);
 exports.when = when;
@@ -26,0 +22,0 @@ const cond = (predicatesAndResolvers) => (...x) =>

types/src/conditional.d.ts

 import { AnyAsync, Func, ParamOf, ReturnTypeUnwrapped } from "./typing.js";
-export declare const ifElse: <F extends Func, If extends Func, Else extends Func>(predicate: F, fTrue: If, fFalse: Else) => (...x: Parameters<F>) => Promise<Awaited<ReturnType<If>> | Awaited<ReturnType<Else>>>;
-type WhenUnless<Functions extends Func[]> = (..._: Parameters<Functions[0]>) => Functions extends AnyAsync<Functions> ? Promise<ParamOf<Functions[0]> | ReturnTypeUnwrapped<Functions[1]>> : ParamOf<Functions[0]> | ReturnType<Functions[1]>;
-export declare const unless: <F extends Func, G extends Func>(predicate: F, fFalse: G) => WhenUnless<[F, G]>;
-export declare const when: <F extends Func, G extends Func>(predicate: F, fTrue: G) => WhenUnless<[F, G]>;
+export declare const ifElse: <Predicate extends Func, If extends Func, Else extends Func>(predicate: Predicate, fTrue: If, fFalse: Else) => (...x: Parameters<Predicate>) => [Predicate, If, Else] extends (Predicate extends import("./typing.js").AsyncFunction ? any : If extends import("./typing.js").AsyncFunction ? any : Else extends import("./typing.js").AsyncFunction ? any : never) ? Promise<ReturnTypeUnwrapped<If> | ReturnTypeUnwrapped<Else>> : ReturnType<If> | ReturnType<Else>;
+type WhenUnless<Predicate extends Func, Resolver extends Func> = (...params: Parameters<Predicate>) => true extends AnyAsync<[Predicate, Resolver]> ? Promise<ParamOf<Predicate> | ReturnTypeUnwrapped<Resolver>> : ParamOf<Predicate> | ReturnType<Resolver>;
+export declare const unless: <F extends Func, G extends Func>(predicate: F, fFalse: G) => WhenUnless<F, G>;
+export declare const when: <F extends Func, G extends Func>(predicate: F, fTrue: G) => WhenUnless<F, G>;
 type ReturnTypeOfSecondOfElements<Fs extends [Func, Func][]> = {
@@ -7,0 +7,0 @@ [K in keyof Fs]: ReturnType<Fs[K][1]>;

types/src/filter.d.ts

 import { AsyncFunction, Func, ParamOf } from "./typing.js";
 export declare const filter: <F extends Func>(f: F) => (_: ParamOf<F>[]) => F extends AsyncFunction ? Promise<ParamOf<F>[]> : ParamOf<F>[];
-export declare const find: <Fn extends Func>(predicate: Fn) => (_: ParamOf<Fn>[]) => Promise<any>;
+export declare const find: <Fn extends Func>(predicate: Fn) => (_: ParamOf<Fn>[]) => [(_: ParamOf<Fn>[]) => Fn extends AsyncFunction ? Promise<ParamOf<Fn>[]> : ParamOf<Fn>[], <T extends string | any[]>(x: T) => T[0]] extends infer T_1 ? T_1 extends [(_: ParamOf<Fn>[]) => Fn extends AsyncFunction ? Promise<ParamOf<Fn>[]> : ParamOf<Fn>[], <T extends string | any[]>(x: T) => T[0]] ? T_1 extends import("./typing.js").AnyAsync<T_1> ? Promise<import("./typing.js").ReturnTypeUnwrapped<import("./typing.js").Last<T_1>>> : ReturnType<import("./typing.js").Last<T_1>> : never : never;
 export declare const remove: <F extends Func>(f: F) => F extends AsyncFunction ? (x: Parameters<F>[0][]) => Promise<Parameters<F>[0][]> : (x: Parameters<F>[0][]) => Parameters<F>[0][];
@@ -5,0 +5,0 @@ type Primitive = string | number | boolean | null | undefined;

types/src/juxt.d.ts

@@ -13,3 +13,3 @@ import { AnyAsync, Func, ReturnTypeUnwrapped, Union } from "./typing.js";
 export declare const juxt: <Functions extends Func[]>(...fs: Functions) => (...x: Parameters<Functions[0]>) => JuxtOutput<Functions>;
-export declare const pairRight: <Function_1 extends Func>(f: Function_1) => (x: Parameters<Function_1>[0]) => Promise<[ReturnTypeUnwrapped<(x: Parameters<Function_1>[0]) => Parameters<Function_1>[0]>, ReturnTypeUnwrapped<Function_1>]>;
+export declare const pairRight: <Function_1 extends Func>(f: Function_1) => (x: Parameters<Function_1>[0]) => JuxtOutput<[(x: Parameters<Function_1>[0]) => Parameters<Function_1>[0], Function_1]>;
 export declare const stack: <Functions extends Func[]>(...functions: Functions) => (_: { [i in keyof Functions]: Parameters<Functions[i]>[0]; }) => JuxtOutput<Functions>;
@@ -16,0 +16,0 @@ export declare const juxtCat: <Functions extends Func[]>(...fs: Functions) => (..._: Parameters<Functions[0]>) => juxtCatOutput<Functions>;

types/src/typing.d.ts

 export type Union<T extends any[]> = T[number];
 export type AsyncFunction = (...args: any[]) => Promise<any>;
-export type AnyAsync<Functions> = Functions extends [] ? never : Functions extends [infer _1 extends AsyncFunction, ...infer _2] ? any : Functions extends [infer _, ...infer rest] ? AnyAsync<rest> : never;
+export type AnyAsync<Functions> = Functions extends [infer f, ...infer rest] ? f extends AsyncFunction ? any : AnyAsync<rest> : never;
 export type Unary<Input, Output> = (_: Input) => Output;
@@ -5,0 +5,0 @@ export type Func = (..._: any[]) => any;

No alert changes

Improved metrics

Total package byte prevSize

189838

increased by0.28%

Worsened metrics

Lines of code

1635

decreased by-0.3%

No dependency changes