fnts 1.1.1 → 1.3.2

package/maybe/operators/fold.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @module Maybe Operators
+ */
 import { Just } from '../just';
 import type { Maybe } from '../maybe';
 import { Nothing } from '../nothing';
@@ -8,5 +11,4 @@ export declare type Fold<Monad extends Maybe<any>> = Monad extends Just<infer Va
 /**
  * Returns the value of the provided `monad`.
  */
-export declare function fold<Monad extends Maybe<any>>(monad: Monad): Fold<Monad>;
-export default fold;
+export default function fold<Monad extends Maybe<any>>(monad: Monad): Fold<Monad>;

package/maybe/operators/fold.js

@@ -1 +1,17 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.fold=fold,exports.default=void 0;var _just=require("../just"),_nothing=require("../nothing"),_guards=require("./guards");function fold(a){return(0,_guards.isJust)(a)?a[_just.jid]:a[_nothing.nid]}var _default=fold;exports.default=_default;
+"use strict";
+/**
+ * @module Maybe Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var just_1 = require("../just");
+var nothing_1 = require("../nothing");
+var guards_1 = require("./guards");
+/**
+ * Returns the value of the provided `monad`.
+ */
+function fold(monad) {
+    return guards_1.isJust(monad)
+        ? monad[just_1.jid]
+        : monad[nothing_1.nid];
+}
+exports.default = fold;

package/maybe/operators/guards.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @module Maybe Operators
+ */
 import { Just } from '../just';
 import type { Maybe } from '../maybe';
 import { Nothing } from '../nothing';

package/maybe/operators/guards.js

@@ -1 +1,22 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.isJust=isJust,exports.isNothing=isNothing;var _just=require("../just"),_nothing=require("../nothing");function isJust(a){return Object.prototype.hasOwnProperty.call(a,_just.jid)}function isNothing(a){return Object.prototype.hasOwnProperty.call(a,_nothing.nid)}
+"use strict";
+/**
+ * @module Maybe Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNothing = exports.isJust = void 0;
+var just_1 = require("../just");
+var nothing_1 = require("../nothing");
+/**
+ * Type guard function to tell if the provided `monad` is `Just`.
+ */
+function isJust(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, just_1.jid);
+}
+exports.isJust = isJust;
+/**
+ * Type guard function to tell if the provided `monad` is `Nothing`.
+ */
+function isNothing(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, nothing_1.nid);
+}
+exports.isNothing = isNothing;

package/maybe/operators/index.d.ts

@@ -1,5 +1,5 @@
-export { fmap } from './fmap';
-export { bind } from './bind';
-export { fold } from './fold';
+export { default as fmap } from './fmap';
+export { default as bind } from './bind';
+export { default as fold } from './fold';
 export { isJust, isNothing } from './guards';
-export { foldMap, FoldMap } from './fold-map';
+export { default as foldMap, FoldMap } from './fold-map';

package/maybe/operators/index.js

@@ -1 +1,14 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"fmap",{enumerable:!0,get:function get(){return _fmap.fmap}}),Object.defineProperty(exports,"bind",{enumerable:!0,get:function get(){return _bind.bind}}),Object.defineProperty(exports,"fold",{enumerable:!0,get:function get(){return _fold.fold}}),Object.defineProperty(exports,"isJust",{enumerable:!0,get:function get(){return _guards.isJust}}),Object.defineProperty(exports,"isNothing",{enumerable:!0,get:function get(){return _guards.isNothing}}),Object.defineProperty(exports,"foldMap",{enumerable:!0,get:function get(){return _foldMap.foldMap}}),Object.defineProperty(exports,"FoldMap",{enumerable:!0,get:function get(){return _foldMap.FoldMap}});var _fmap=require("./fmap"),_bind=require("./bind"),_fold=require("./fold"),_guards=require("./guards"),_foldMap=require("./fold-map");
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foldMap = exports.isNothing = exports.isJust = exports.fold = exports.bind = exports.fmap = void 0;
+var fmap_1 = require("./fmap");
+Object.defineProperty(exports, "fmap", { enumerable: true, get: function () { return fmap_1.default; } });
+var bind_1 = require("./bind");
+Object.defineProperty(exports, "bind", { enumerable: true, get: function () { return bind_1.default; } });
+var fold_1 = require("./fold");
+Object.defineProperty(exports, "fold", { enumerable: true, get: function () { return fold_1.default; } });
+var guards_1 = require("./guards");
+Object.defineProperty(exports, "isJust", { enumerable: true, get: function () { return guards_1.isJust; } });
+Object.defineProperty(exports, "isNothing", { enumerable: true, get: function () { return guards_1.isNothing; } });
+var fold_map_1 = require("./fold-map");
+Object.defineProperty(exports, "foldMap", { enumerable: true, get: function () { return fold_map_1.default; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fnts",
-  "version": "1.1.1",
+  "version": "1.3.2",
   "license": "MIT",
   "author": "Dmytro Vasylkivskyi",
   "description": "TypeScript / JavaScript FP utilities",
@@ -12,9 +12,15 @@
     "typescript",
     "javascript"
   ],
-  "homepage": "https://github.com/drizzer14/fnts",
-  "repository": "github:drizzer14/fnts",
+  "homepage": "https://drizzer14.github.io/fnts",
+  "repository": "https://github.com/drizzer14/fnts",
   "peerDependencies": {
     "typescript": ">=4.2.2"
-  }
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "main": "index.js"
 }

package/permutation/index.d.ts

@@ -0,0 +1,2 @@
+export { default as permutation2 } from './permutation-2';
+export { default as permutation3 } from './permutation-3';

package/permutation/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permutation3 = exports.permutation2 = void 0;
+var permutation_2_1 = require("./permutation-2");
+Object.defineProperty(exports, "permutation2", { enumerable: true, get: function () { return permutation_2_1.default; } });
+var permutation_3_1 = require("./permutation-3");
+Object.defineProperty(exports, "permutation3", { enumerable: true, get: function () { return permutation_3_1.default; } });

package/permutation/permutation-2.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module Permutation
+ */
+import type { VariadicFunction } from './../types/function';
+export declare type BinaryFunction = (a: any, b: any) => any;
+export declare type FirstParameter<Function extends VariadicFunction> = Parameters<Function>[0];
+export declare type SecondParameter<Function extends VariadicFunction> = Parameters<Function>[1];
+export default function permutation2<Function extends BinaryFunction>(fn: Function, shouldCurry?: (a: FirstParameter<Function> | SecondParameter<Function>, b: SecondParameter<Function> | undefined) => boolean): VariadicFunction;

package/permutation/permutation-2.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @module Permutation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function permutation2(fn, shouldCurry) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var a1 = args[0], b = args[1];
+        return (shouldCurry === null || shouldCurry === void 0 ? void 0 : shouldCurry(a1, b)) || args.length < fn.length
+            ? function (a2) { return fn(a2, a1); }
+            : fn(a1, b);
+    };
+}
+exports.default = permutation2;

package/permutation/permutation-3.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module Permutation
+ */
+import type { VariadicFunction } from './../types/function';
+import type { FirstParameter, SecondParameter } from './permutation-2';
+export declare type TernaryFunction = (a: any, b: any, c: any) => any;
+export declare type ThirdParameter<Function extends VariadicFunction> = Parameters<Function>[2];
+export default function permutation3<Function extends TernaryFunction>(fn: Function, shouldCurry?: (a: FirstParameter<Function> | SecondParameter<Function>, b: SecondParameter<Function> | ThirdParameter<Function>, c: ThirdParameter<Function> | undefined) => boolean): VariadicFunction;

package/permutation/permutation-3.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @module Permutation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function permutation3(fn, shouldCurry) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var a1 = args[0], b = args[1], c = args[2];
+        return (shouldCurry === null || shouldCurry === void 0 ? void 0 : shouldCurry(a1, b, c)) || args.length < fn.length
+            ? function (a2) { return fn(a2, a1, b); }
+            : fn(a1, b, c);
+    };
+}
+exports.default = permutation3;

package/pipe.d.ts

@@ -1,4 +1,8 @@
-import type { Last } from './.internal/last';
+/**
+ * @module Composition
+ */
+import type { Last } from './types/last';
+import type { UnaryFunction } from './types/function';
 /**
  * Creates a `Pipeline` type which parses all of the provided functions' types.
  * Any function with either an incorrect argument or a return type will not fit
@@ -6,16 +10,12 @@ import type { Last } from './.internal/last';
  * type matches the return type of the previous function and its return type
  * matches the type of the next function's argument.
  */
-export declare type Pipeline<Functions extends Array<(...args: any[]) => any>, Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [infer First, infer Second, ...infer Rest] ? [
+export declare type Pipeline<Functions extends UnaryFunction[], Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [infer First, infer Second, ...infer Rest] ? [
     First,
-    ...Pipeline<[
-        (arg: ReturnType<First>) => ReturnType<Second>,
-        ...Rest
-    ]>
-] : any;
+    ...Pipeline<First extends UnaryFunction ? Second extends UnaryFunction ? Rest extends UnaryFunction[] ? [(arg: ReturnType<First>) => ReturnType<Second>, ...Rest] : never : never : never>
+] : Functions;
 /**
  * Applies all of the provided `functions` one-by-one in left-to-right order
  * starting from the `argument`.
  */
-export declare function pipe<Functions extends Array<(arg: any) => any>>(...functions: Pipeline<Functions>): (arg: Parameters<Functions[0]>[0]) => ReturnType<Last<Functions>>;
-export default pipe;
+export default function pipe<Functions extends Array<(arg: any) => any>>(...functions: Pipeline<Functions>): (arg: Parameters<Functions[0]>[0]) => ReturnType<Last<Functions>>;

package/pipe.js

@@ -1 +1,24 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.pipe=pipe,exports.default=void 0;function pipe(){for(var a=arguments.length,b=Array(a),c=0;c<a;c++)b[c]=arguments[c];return a=>{for(var c,d=b.length,e=a,f=0;f<d;f+=1)c=b[f],e=c(e);return e}}var _default=pipe;exports.default=_default;
+"use strict";
+/**
+ * @module Composition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Applies all of the provided `functions` one-by-one in left-to-right order
+ * starting from the `argument`.
+ */
+function pipe() {
+    var functions = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        functions[_i] = arguments[_i];
+    }
+    return function (arg) {
+        var length = functions.length;
+        var pipeline = arg;
+        for (var index = 0; index < length; index += 1) {
+            pipeline = functions[index](pipeline);
+        }
+        return pipeline;
+    };
+}
+exports.default = pipe;

package/rethrow.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module Side Effects
+ */
+import type { Effect } from './types/effect';
+/**
+ * Rethrows a received error
+ * performing an optional side effect.
+ */
+export default function rethrow<Error>(effect: Effect<(error: Error) => never>): (error: Error) => never;

package/rethrow.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @module Side Effects
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var inject_1 = require("./inject");
+/**
+ * Rethrows a received error
+ * performing an optional side effect.
+ */
+function rethrow(effect) {
+    return inject_1.default(function (error) {
+        throw error;
+    }, effect);
+}
+exports.default = rethrow;

package/tap.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module Side Effects
+ */
+import type { Map } from './types/map';
+import type { Identity } from './identity';
+import type { Effect } from './types/effect';
+/**
+ * Performs a side effect
+ * passing the received argument through itself.
+ */
+export default function tap<Value>(effect: Effect<Map<Value, any>>): Identity<Value>;

package/tap.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * @module Side Effects
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var inject_1 = require("./inject");
+var identity_1 = require("./identity");
+/**
+ * Performs a side effect
+ * passing the received argument through itself.
+ */
+function tap(effect) {
+    return inject_1.default(identity_1.default, effect);
+}
+exports.default = tap;

package/ternary.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module Ternary
+ */
+import type { Map } from './types/map';
+/**
+ * Functional alternative to the ternary operator.
+ * Enforces the same return type for both branches,
+ * the result is evaluated lazily.
+ */
+export default function ternary<Value, Return>(predicate: Map<Value, boolean>, left: Map<Value, Return>, right: Map<Value, Return>): Map<Value, Return>;

package/ternary.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @module Ternary
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Functional alternative to the ternary operator.
+ * Enforces the same return type for both branches,
+ * the result is evaluated lazily.
+ */
+function ternary(predicate, left, right) {
+    return function (value) {
+        return predicate(value) ? left(value) : right(value);
+    };
+}
+exports.default = ternary;

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es2019",
+    "target": "esnext",
     "module": "esnext",
     "moduleResolution": "node",
     "lib": [

package/types/effect.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module Types
+ */
+
+import type { VariadicFunction } from './function';
+
+/**
+ * A simple side effect function descriptor.
+ */
+export type Effect<Function extends VariadicFunction> =
+  (...args: Parameters<Function>) => void

package/types/function.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Types
+ */
+
+/**
+ * A type of a function accepting exactly one argument
+ */
+export type UnaryFunction = (arg: any) => any
+
+/**
+ * A type of a function accepting an arbitrary amount of arguments
+ */
+export type VariadicFunction = (...args: any[]) => any

package/types/gradual.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module Types
+ */
+
+/**
+ * Gradual defines a tuple type which accepts any amount
+ * of entries from the original one.
+ * 
+ * ```typescript
+ * Gradual<[1, 2, 3]> === [1] | [1, 2] | [1, 2, 3]
+ * ```
+ */
+export type Gradual<T extends any[] | readonly any[]> = T extends [...infer R, any]
+  ? R['length'] extends 0
+    ? T
+    : T | Gradual<R>
+  : T

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export type { Map } from './map';
+export type { Last } from './last';
+export type { Slice } from './slice';
+export type { Tuple } from './tuple';
+export type { Effect } from './effect';
+export type { Gradual } from './gradual';
+export type { UnaryFunction, VariadicFunction } from './function';

package/{.internal → types}/last.d.ts

@@ -1,3 +1,10 @@
+/**
+ * @module Types
+ */
+
+/**
+ * Picks the last entry from the tuple or array.
+ */
 export type Last<T extends any[]> =
   T extends [...any[], infer L]
     ? L

package/types/map.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module Types
+ */
+
+/**
+ * A type of a function which maps the original value type to another one.
+ */
+export type Map<From, To> = (value: From) => To

package/{.internal → types}/slice.d.ts

@@ -1,5 +1,12 @@
+/**
+ * @module Types
+ */
+
 import type { Tuple } from './tuple'
 
+/**
+ * Slices the tuple by `C` amount of entries from the **end**.
+ */
 export type Slice<
   T extends any[] | readonly any[],
   C extends number

package/{.internal → types}/tuple.d.ts

@@ -1,4 +1,10 @@
 /**
+ * @module Types
+ */
+
+/**
+ * Creates a tuple of specified length.
+ * 
  * {@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f Gracefully borrowed from here}
  */
 export type Tuple<L extends number, T extends any[] | readonly any[] = []> =

package/.internal/gradual.d.ts

@@ -1,5 +0,0 @@
-export type Gradual<T extends any[] | readonly any[]> = T extends [...infer R, any]
-  ? R['length'] extends 0
-    ? T
-    : T | Gradual<R>
-  : T

package/.internal/map.d.ts

@@ -1 +0,0 @@
-export type Map<From, To> = (value: From) => To

package/.internal/permutation-of-2.d.ts

@@ -1 +0,0 @@
-export {};

package/.internal/permutation-of-2.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=exports.permutationOf2=void 0;var permutationOf2=(a,c)=>function(){for(var d=arguments.length,e=Array(d),f=0;f<d;f++)e[f]=arguments[f];var[g,h]=e;return null!==c&&void 0!==c&&c(g,h)||e.length<a.length?b=>a(b,g):a(g,h)};exports.permutationOf2=permutationOf2;var _default=permutationOf2;exports.default=_default;

package/.internal/permutation-of-3.d.ts

@@ -1 +0,0 @@
-export {};

package/.internal/permutation-of-3.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=exports.permutationOf3=void 0;var permutationOf3=a=>function(){for(var d=arguments.length,e=Array(d),f=0;f<d;f++)e[f]=arguments[f];var[g,h,b]=e;return e.length<a.length?b=>a(b,g,h):a(g,h,b)};exports.permutationOf3=permutationOf3;var _default=permutationOf3;exports.default=_default;