Merge pull request #4 from finleap-connect/chore/bundle-size

chore: fix issues related to bundle size convert from cjs to esm to enable tree shaking

.babelrc

@@ -1,3 +1,8 @@
 {
-  "presets": ["@babel/preset-env"]
+  "presets": [
+    "@babel/preset-env",
+    {
+      "modules": false
+    }
+  ]
 }

README.md

@@ -5,7 +5,7 @@
 [![version][version-badge]][changelog]
 
 [changelog]: CHANGELOG.md
-[version-badge]: https://img.shields.io/badge/version-0.1.5-blue.svg
+[version-badge]: https://img.shields.io/badge/version-0.1.6-blue.svg
 
 # LJSP: Embrace the Lisp in JavaScript!
 Whether you agree that JavaScript is a Lisp or not, you can still harness the Lisp-inspired power of LJSP in your app. LJSP derives most of its functions from Clojure libraries. Clojurians will notice the extent to which we treated the Clojure docs not only as our requirements' specification, but as a great place to copy and paste text for our docs! For this, we offer heart-felt, tremendous thanks to the Clojure community.

lib/conditional/and.d.ts

@@ -0,0 +1 @@
+export declare function and(...rest: Array<any>): any;

lib/conditional/cases.d.ts

@@ -0,0 +1,17 @@
+import { TPrimitive } from "../types/TPrimitive";
+/**
+ * Takes an expression, and a set of clauses.
+ * Each clause can take the form of either:
+ * test-constant result-expr
+ * (test-constant1 ... test-constantN)  result-expr
+ * The test-constants are not evaluated. They must be compile-time
+ * literals.  If the expression is equal to a
+ * test-constant, the corresponding result-expr is returned. A single
+ * default expression can follow the clauses, and its value will be
+ * returned if no clause matches. If no default expression is provided
+ * and no clause matches, undefined is returned.
+ * All manner of constant expressions are acceptable in `cases`,
+ * including numbers, strings, booleans, and Symbols. The
+ * test-constants need not be all of the same type.
+ */
+export declare function cases(expression: TPrimitive, ...rest: any[]): any;

lib/conditional/cond.d.ts

@@ -0,0 +1,2 @@
+export declare const ELSE = "else";
+export declare function cond(...rest: Array<any>): any;

lib/conditional/condp.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Takes a binary predicate, an expression, and a set of clauses.
+ * Each clause can take the form of either:
+ * test-expr, result-expr
+ * test-expr, result-fn
+ * For each clause, (pred test-expr expr) is evaluated. If it returns
+ * logical true, the clause is a match. If a binary clause matches, the
+ * result-expr is returned, if a ternary clause matches, its result-fn,
+ * which must be a unary function, is called with the result of the
+ * predicate as its argument, the result of that call being the return
+ * value of condp. A single default expression can follow the clauses,
+ * and its value will be returned if no clause matches. If no default
+ * expression is provided and no clause matches, undefined is returned.
+ * @param {function} pred
+ * @param {*} expr
+ * @param {*} rest
+ * @returns {*}
+ */
+export declare function condp(pred: any, expr: any, ...rest: any[]): any;

lib/conditional/every-pred.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param rest
+ * @returns {function(...[*]): boolean}
+ */
+export declare function everyPred(...rest: any[]): (...args: any[]) => boolean;

lib/conditional/if-array.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns either the value or an empty Array
+ * @param {boolean} pred
+ * @param {*} value
+ * @returns {*|*[]}
+ */
+export declare function ifArray(pred: boolean, value: any): any;

lib/conditional/if-blank.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {boolean | Function} condition
+ * @param {*} consequent
+ * @returns {*|string}
+ */
+export declare function ifBlank(condition: any, consequent: any): any;

lib/conditional/if-class.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {boolean | Function} condition
+ * @param {string} className
+ * @returns {*|string}
+ */
+export declare function ifClass(condition: any, className: any): any;

lib/conditional/if-not.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param condition
+ * @param expression
+ * @returns {*|undefined}
+ */
+export declare function ifNot(condition: any, expression: any): any;

lib/conditional/if-obj.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {boolean | Function} condition
+ * @param {{}} consequent
+ * @returns {*|string}
+ */
+export declare function ifObj(condition: any, consequent: any): any;

lib/conditional/if-some.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param value
+ * @param ifTrue
+ * @param ifFalse
+ * @returns {*}
+ */
+export declare function ifSome(value: any, ifTrue: any, ifFalse: any): any;

lib/conditional/if-yes.d.ts

@@ -0,0 +1 @@
+export declare function ifYes(condition: any, expression: any): any;

lib/conditional/iff.d.ts

@@ -0,0 +1 @@
+export declare function iff(condition: any, ifTrue: any, ifFalse: any): any;

lib/conditional/index.d.ts

@@ -0,0 +1,18 @@
+export { and } from "./and";
+export { cases } from "./cases";
+export { cond, ELSE } from "./cond";
+export { condp } from "./condp";
+export { everyPred } from "./every-pred";
+export { ifArray } from "./if-array";
+export { ifBlank } from "./if-blank";
+export { ifClass } from "./if-class";
+export { ifNot } from "./if-not";
+export { ifObj } from "./if-obj";
+export { ifSome } from "./if-some";
+export { ifYes } from "./if-yes";
+export { iff } from "./iff";
+export { or } from "./or";
+export { some$ } from "./some$";
+export { when } from "./when";
+export { whenFirst } from "./when-first";
+export { whenNot } from "./when-not";

lib/conditional/internal/_return-last.d.ts

@@ -0,0 +1 @@
+export declare function _returnLast(body: Array<any>, arg?: any): any;

lib/conditional/internal/run-fn-or-get-value.d.ts

@@ -0,0 +1,3 @@
+declare type IsBoolean = any | ((arg: any) => any);
+export declare function runFnOrGetValue(ifTrue: IsBoolean, value?: any): any;
+export {};

lib/conditional/or.d.ts

@@ -0,0 +1 @@
+export declare function or(...rest: Array<any>): any;

lib/conditional/some$.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param expression
+ * @returns {boolean}
+ */
+export declare function some$(expression: any): boolean;

lib/conditional/when-first.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Obtains the first item in a set. If that item is truthy, then the body is run and the last
+ * computed value or expression is returned. The first item in the list is passed as an argument
+ * to any functions in the function body.
+ * Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once
+ */
+export declare function whenFirst(set: Array<any>, ...rest: any): any;

lib/conditional/when-not.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param condition
+ * @param rest
+ */
+export declare function whenNot(condition: any, ...rest: Array<any>): any;

lib/conditional/when.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param condition
+ * @param rest
+ */
+export declare function when(condition: any, ...rest: Array<any>): any;

lib/enums/base-types.d.ts

@@ -0,0 +1,15 @@
+export declare enum BaseTypes {
+    Function = "function",
+    String = "string",
+    Object = "object",
+    Array = "array",
+    Map = "map",
+    Set = "set",
+    Boolean = "boolean",
+    Number = "number",
+    Null = "null",
+    Undefined = "undefined",
+    Promise = "promise",
+    Date = "date",
+    Symbol = "symbol"
+}

lib/function/apply.d.ts

@@ -0,0 +1 @@
+export declare function apply(fn: Function, ...rest: Array<any>): any;

lib/function/comp.d.ts

@@ -0,0 +1 @@
+export declare function comp(...fns: Array<Function>): (...args: Array<any>) => any[];

lib/function/complement.d.ts

@@ -0,0 +1 @@
+export declare function complement(fn: any): (...rest: any[]) => boolean;

lib/function/constantly.d.ts

@@ -0,0 +1 @@
+export declare const constantly: (value: any) => () => any;

lib/function/f-nil.d.ts

@@ -0,0 +1,3 @@
+declare type FnType = (args?: Array<any>) => any;
+export declare function fNil(fn: FnType, ...template: Array<any>): FnType;
+export {};

lib/function/identity.d.ts

@@ -0,0 +1 @@
+export declare function identity(value: any): any;

lib/function/index.d.ts

@@ -0,0 +1,12 @@
+export { apply } from "./apply";
+export { comp } from "./comp";
+export { complement } from "./complement";
+export { constantly } from "./constantly";
+export { fNil } from "./f-nil";
+export { identity } from "./identity";
+export { juxt } from "./juxt";
+export { memoize } from "./memoize";
+export { partial } from "./partial";
+export { repeatedly } from "./repeatedly";
+export { tf } from "./tf";
+export { trampoline } from "./trampoline";

lib/function/juxt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {*} rest
+ * @returns {function(...[*]=): unknown}
+ */
+export declare function juxt(...rest: any[]): (...args: any[]) => any;

lib/function/memoize.d.ts

@@ -0,0 +1,4 @@
+declare type Function = (...args: any) => any;
+declare type ResolverFn = (...args: any) => string;
+export declare function memoize(fn: Function, cacheKey?: ResolverFn): any;
+export {};

lib/function/partial.d.ts

@@ -0,0 +1 @@
+export declare function partial(fn: Function, ...rest: any[]): (...args: any[]) => any;

lib/function/repeatedly.d.ts

@@ -0,0 +1 @@
+export declare function repeatedly(fn: Function, n: number): any;

lib/function/tf.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Used to flatten nested function calls. `tf` allows value transformations to be
+ * expressed as “pipelines” of values, similar to Unix pipes.
+ */
+export declare function tf(val: any, ...fns: Function[]): any;

lib/function/trampoline.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `trampoline` can be used to convert recursive algorithms
+ * without stack consumption. Calls `fn` with supplied args, if
+ * any. If `fn` returns a function, calls that function with no
+ * arguments, and continues to repeat, until the return value is
+ * not a function, then returns that non-fn value. Note that if
+ * you want to return a function as a final value, you must wrap
+ * it in some data structure and unpack it after `trampoline`
+ * returns.
+ * @param {Function} fn
+ * @param {*} rest
+ * @returns {function(...[*]): *}
+ */
+export declare function trampoline(fn: any, ...rest: any[]): any;

lib/generic/alike.d.ts

@@ -0,0 +1 @@
+export declare function alike(...rest: Array<any>): boolean;

lib/generic/array$.d.ts

@@ -0,0 +1 @@
+export declare function array$(item: any): boolean;

lib/generic/array-like$.d.ts

@@ -0,0 +1 @@
+export declare function arrayLike$(set: any): any;

lib/generic/array-set$.d.ts

@@ -0,0 +1 @@
+export declare function arraySet$(set: Array<any>): boolean;

lib/generic/boolean$.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether a value is Boolean
+ * @param value
+ * @returns {boolean|*}
+ */
+export declare function boolean$(value: any): boolean;

lib/generic/clone-deep.d.ts

@@ -0,0 +1,2 @@
+export declare const cloneDeepNoCircularRefs: (o: any) => any;
+export declare const cloneDeep: (o: any) => any;

lib/generic/collection$.d.ts

@@ -0,0 +1 @@
+export declare function collection$(item: any): any;

lib/generic/compare.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a negative number, zero, or a positive number
+ * when x is logically 'less than', 'equal to', or 'greater than'
+ * y. Works with number, string, and boolean values---as well as Arrays
+ * of those values. Compares numbers and Arrays in a type-independent
+ * manner; however the types compared must always match.
+ *
+ * When comparing strings, a delta in a string returns the distance between
+ * the first two letters that don't match. See examples below for deta
+ * @param left
+ * @param right
+ */
+export declare function compare(left: any, right: any): number;

lib/generic/deep-eq.d.ts

@@ -0,0 +1 @@
+export declare function deepEq(...rest: Array<any>): boolean;

lib/generic/diff.d.ts

@@ -0,0 +1,16 @@
+import { TAnyObject } from "../types/t-any-object";
+/**
+ * Recursively compares a and b, returning a tuple of
+ * [things-only-in-a things-only-in-b things-in-both].
+ * Comparison rules:
+ * * For equal a and b, return [nil nil a].
+ * * Maps are subdiffed where keys match and values differ.
+ * * Sets are never subdiffed.
+ * * All sequential things are treated as associative collections
+ * by their indexes, with results returned as vectors.
+ * * Everything else (including strings!) is treated as
+ * an atom and compared for equality.
+ * @param a
+ * @param b
+ */
+export declare function diff(a: TAnyObject, b: TAnyObject): any;

lib/generic/distinct$.d.ts

@@ -0,0 +1,2 @@
+import { TPrimitive } from "../types/TPrimitive";
+export declare function distinct$(...rest: Array<TPrimitive>): boolean;

lib/generic/do-work.d.ts

@@ -0,0 +1 @@
+export declare function doWork(...rest: Array<any>): any;

lib/generic/dotimes.d.ts

@@ -0,0 +1 @@
+export declare function dotimes(times: number, fn: Function): void;

lib/generic/empty$.d.ts

@@ -0,0 +1,8 @@
+import { TCollection } from "../types/t-collection";
+/**
+ * Returns whether an Object, an Array, a Set, or a Map is empty.
+ * Modified slightly from Lodash
+ * @param value
+ * @returns {boolean}
+ */
+export declare function empty$(value: null | undefined | TCollection): boolean;

lib/generic/empty.d.ts

@@ -0,0 +1 @@
+export declare function empty(set: any): any;

lib/generic/eq.d.ts

@@ -0,0 +1 @@
+export declare function eq(...rest: Array<any>): boolean;

lib/generic/false$.d.ts

@@ -0,0 +1 @@
+export declare function false$(arg: any): boolean;

lib/generic/function$.d.ts

@@ -0,0 +1 @@
+export declare function function$(value: any): boolean;

lib/generic/function-set$.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {[]} set
+ * @returns {Boolean}
+ */
+export declare function functionSet$(set: any): boolean;

lib/generic/index.d.ts

@@ -0,0 +1,40 @@
+export { alike } from "./alike";
+export { array$ } from "./array$";
+export { arrayLike$ } from "./array-like$";
+export { arraySet$ } from "./array-set$";
+export { boolean$ } from "./boolean$";
+export { cloneDeep } from "./clone-deep";
+export { cloneDeepNoCircularRefs } from "./clone-deep";
+export { collection$ } from "./collection$";
+export { compare } from "./compare";
+export { deepEq } from "./deep-eq";
+export { diff } from "./diff";
+export { distinct$ } from "../generic/distinct$";
+export { doWork } from "./do-work";
+export { dotimes } from "./dotimes";
+export { empty$ } from "./empty$";
+export { empty } from "./empty";
+export { eq } from "./eq";
+export { false$ } from "./false$";
+export { function$ } from "./function$";
+export { functionSet$ } from "./function-set$";
+export { log } from "./log";
+export { maxKey } from "./max-key";
+export { not } from "./not";
+export { notEmpty$ } from "./not-empty$";
+export { notEmpty } from "./not-empty";
+export { notEq } from "./not-eq";
+export { number$ } from "./number$";
+export { numberSet$ } from "./number-set$";
+export { numeric$ } from "./numeric$";
+export { object$ } from "./object$";
+export { objectLike$ } from "./object-like$";
+export { objectSet$ } from "./object-set$";
+export { orEq } from "./or-eq";
+export { rand } from "./rand";
+export { regExp$ } from "./reg-exp$";
+export { string$ } from "./string$";
+export { stringSet$ } from "./string-set$";
+export { true$ } from "./true$";
+export { undefined$ } from "./undefined$";
+export { void$ } from "./void$";

lib/generic/internal/_eq.d.ts

@@ -0,0 +1 @@
+export declare function _eq(args: any, comparator: Function): boolean;

lib/generic/internal/is-multi-dim-arr.d.ts

@@ -0,0 +1 @@
+export declare function isMultiDimArr(arr: any): any;

lib/generic/internal/typed-set$.d.ts

@@ -0,0 +1,3 @@
+declare type TypeFn = (arg?: any) => boolean;
+export declare function typedSet$(set: Array<any>, fn: TypeFn): boolean;
+export {};

lib/generic/log.d.ts

@@ -0,0 +1 @@
+export declare function log(...rest: any): void;

lib/generic/max-key.d.ts

@@ -0,0 +1 @@
+export declare function maxKey(fn: any, ...rest: any[]): any;

lib/generic/not-empty$.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param item
+ * @returns {boolean}
+ */
+export declare function notEmpty$(item: any): boolean;

lib/generic/not-empty.d.ts

@@ -0,0 +1,2 @@
+import { TCollection } from "../types/t-collection";
+export declare function notEmpty(set: TCollection): string | object | undefined;

lib/generic/not-eq.d.ts

@@ -0,0 +1 @@
+export declare function notEq(...rest: Array<any>): boolean;