@eyeseetea/d2-logger 0.1.0-beta.1

package/domain/entities/generic/Collection.js

@@ -0,0 +1,287 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+var HashMap_1 = require("./HashMap");
+/**
+ * Wrap a collection of values, expanding methods for Javascript Arrays. An example:
+ *
+ * ```
+ * import _ from "./Collection";
+ *
+ * const values = _(["1", "2", "3", "3", "4"])
+ *     .map(x => parseInt(x))
+ *     .filter(x => x > 1)
+ *     .uniq()
+ *     .reverse()
+ *     .value(); // [4, 3, 2]
+ * ```
+ */
+var Collection = /** @class */ (function () {
+    function Collection(values) {
+        this.toArray = this.value;
+        this.filter = this.select;
+        this.all = this.every;
+        this.any = this.some;
+        this.keyBy = this.indexBy;
+        this.xs = values;
+    }
+    /* Builders */
+    Collection.from = function (xs) {
+        return new Collection(xs);
+    };
+    Collection.range = function (start, end, step) {
+        if (step === void 0) { step = 1; }
+        var output = [];
+        for (var idx = start; idx < end; idx = idx + step)
+            output.push(idx);
+        return Collection.from(output);
+    };
+    /* Unwrappers */
+    Collection.prototype.value = function () {
+        return this.xs;
+    };
+    Object.defineProperty(Collection.prototype, "size", {
+        get: function () {
+            return this.xs.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /* Methods that return a Collection */
+    Collection.prototype.map = function (fn) {
+        return _c(this.xs.map(fn));
+    };
+    Collection.prototype.flatten = function () {
+        return _c(this.xs.flat());
+    };
+    Collection.prototype.flatMap = function (fn) {
+        return _c(this.xs.flatMap(function (x) { return fn(x).toArray(); }));
+    };
+    Collection.prototype.select = function (pred) {
+        return _c(this.xs.filter(pred));
+    };
+    Collection.prototype.reject = function (pred) {
+        return _c(this.xs.filter(function (x) { return !pred(x); }));
+    };
+    Collection.prototype.enumerate = function () {
+        return _c(this.xs.map(function (x, idx) { return [idx, x]; }));
+    };
+    Collection.prototype.compact = function () {
+        return this.reject(function (x) { return x === undefined || x === null; });
+    };
+    Collection.prototype.compactMap = function (fn) {
+        return this.map(fn).compact();
+    };
+    Collection.prototype.append = function (x) {
+        return _c(this.xs.concat([x]));
+    };
+    Collection.prototype.includes = function (x) {
+        return this.xs.includes(x);
+    };
+    Collection.prototype.every = function (pred) {
+        return this.xs.every(pred);
+    };
+    Collection.prototype.some = function (pred) {
+        return this.xs.some(pred);
+    };
+    Collection.prototype.find = function (pred, options) {
+        if (options === void 0) { options = {}; }
+        return this.xs.find(pred) || (options === null || options === void 0 ? void 0 : options.or);
+    };
+    Collection.prototype.sort = function () {
+        return this.sortWith(defaultCompareFn);
+    };
+    Collection.prototype.reverse = function () {
+        return _c(__spreadArray([], this.xs, true).reverse());
+    };
+    Collection.prototype.sortWith = function (compareFn) {
+        return _c(this.xs.slice().sort(compareFn));
+    };
+    Collection.prototype.sortBy = function (fn, options) {
+        if (options === void 0) { options = {}; }
+        var compareFn = options.compareFn || defaultCompareFn;
+        // TODO: Schwartzian transform: decorate + sort tuple + undecorate
+        return this.sortWith(function (a, b) { return compareFn(fn(a), fn(b)); });
+    };
+    Collection.prototype.orderBy = function (items) {
+        return this.sortWith(function (a, b) {
+            return compareArray(a, b, items);
+        });
+    };
+    Collection.prototype.first = function () {
+        return this.xs[0];
+    };
+    Collection.prototype.last = function () {
+        return this.xs[this.xs.length - 1];
+    };
+    Collection.prototype.sum = function () {
+        return this.xs.reduce(function (acc, x) { return acc + Number(x); }, 0);
+    };
+    Collection.prototype.take = function (n) {
+        return _c(this.xs.slice(0, n));
+    };
+    Collection.prototype.drop = function (n) {
+        return _c(this.xs.slice(n));
+    };
+    Collection.prototype.pairwise = function () {
+        var _this = this;
+        var n = 2;
+        return _c(this.xs
+            .slice(0, this.xs.length - n + 1)
+            .map(function (_x, idx) { return [_this.xs[idx], _this.xs[idx + 1]]; }));
+    };
+    Collection.prototype.prepend = function (x) {
+        return _c(__spreadArray([x], this.xs, true));
+    };
+    Collection.prototype.tap = function (fn) {
+        fn(this);
+        return this;
+    };
+    Collection.prototype.splitAt = function (indexes) {
+        var _this = this;
+        return _c(indexes)
+            .prepend(0)
+            .append(this.xs.length)
+            .pairwise()
+            .map(function (_a) {
+            var i1 = _a[0], i2 = _a[1];
+            return _c(_this.xs.slice(i1, i2));
+        });
+    };
+    Collection.prototype.thru = function (fn) {
+        return fn(this);
+    };
+    Collection.prototype.join = function (char) {
+        return this.xs.join(char);
+    };
+    Collection.prototype.get = function (idx) {
+        return this.xs[idx];
+    };
+    Collection.prototype.getMany = function (idxs) {
+        var _this = this;
+        return _c(idxs.map(function (idx) { return _this.xs[idx]; }));
+    };
+    Collection.prototype.intersperse = function (value) {
+        return this.flatMap(function (x) { return _c([x, value]); }).thru(function (cs) { return cs.take(cs.size - 1); });
+    };
+    Collection.prototype.uniq = function () {
+        return this.uniqBy(function (x) { return x; });
+    };
+    Collection.prototype.uniqBy = function (mapper) {
+        var seen = new Set();
+        var output = [];
+        for (var _i = 0, _a = this.xs; _i < _a.length; _i++) {
+            var item = _a[_i];
+            var mapped = mapper(item);
+            if (!seen.has(mapped)) {
+                output.push(item);
+                seen.add(mapped);
+            }
+        }
+        return _c(output);
+    };
+    Collection.prototype.reduce = function (mapper, initialAcc) {
+        return this.xs.reduce(mapper, initialAcc);
+    };
+    Collection.prototype.chunk = function (size) {
+        var _this = this;
+        return Collection.range(0, this.xs.length, size).map(function (index) {
+            return _this.xs.slice(index, index + size);
+        });
+    };
+    Collection.prototype.cartesian = function () {
+        var _a = this.xs, ys = _a[0], zss = _a.slice(1);
+        if (!ys) {
+            return _c([[]]);
+        }
+        else {
+            return _c(ys).flatMap(function (x) {
+                return _c(zss)
+                    .cartesian()
+                    .map(function (zs) { return __spreadArray([x], zs, true); });
+            });
+        }
+    };
+    // forEach(fn: (value: T) => void): void
+    Collection.prototype.zipLongest = function (xs) {
+        var _this = this;
+        var max = Math.max(this.size, xs.size);
+        var pairs = Collection.range(0, max)
+            .map(function (i) { return [_this.xs[i], xs.xs[i]]; })
+            .value();
+        return _c(pairs);
+    };
+    Collection.prototype.zip = function (xs) {
+        var _this = this;
+        var min = Math.min(this.size, xs.size);
+        var pairs = Collection.range(0, min)
+            .map(function (i) { return [_this.xs[i], xs.xs[i]]; })
+            .value();
+        return _c(pairs);
+    };
+    /* Methods that return HashMap */
+    Collection.prototype.indexBy = function (grouperFn) {
+        var initialValue = HashMap_1.HashMap.empty();
+        return this.reduce(function (acc, x) {
+            var key = grouperFn(x);
+            return acc.set(key, x);
+        }, initialValue);
+    };
+    Collection.prototype.groupBy = function (grouperFn) {
+        var map = this.reduce(function (acc, value) {
+            var key = grouperFn(value);
+            var valuesForKey = acc.get(key) || [];
+            valuesForKey.push(value);
+            return acc.set(key, valuesForKey);
+        }, new Map());
+        return HashMap_1.HashMap.fromPairs(Array.from(map.entries()));
+    };
+    Collection.prototype.groupFromMap = function (pairGrouperFn) {
+        var map = this.reduce(function (acc, x) {
+            var _a = pairGrouperFn(x), key = _a[0], value = _a[1];
+            var valuesForKey = acc.get(key) || [];
+            valuesForKey.push(value);
+            return acc.set(key, valuesForKey);
+        }, new Map());
+        return HashMap_1.HashMap.fromPairs(Array.from(map.entries()));
+    };
+    Collection.prototype.toHashMap = function (toPairFn) {
+        var pairs = this.map(toPairFn).toArray();
+        return HashMap_1.HashMap.fromPairs(pairs);
+    };
+    /* Predicates */
+    Collection.prototype.isEmpty = function () {
+        return this.xs.length === 0;
+    };
+    Collection.prototype.isNotEmpty = function () {
+        return !this.isEmpty();
+    };
+    return Collection;
+}());
+exports.Collection = Collection;
+function defaultCompareFn(a, b, direction) {
+    if (direction === void 0) { direction = "asc"; }
+    var _a = direction === "asc" ? [1, -1] : [-1, 1], value1 = _a[0], value2 = _a[1];
+    return a > b ? value1 : b > a ? value2 : 0;
+}
+function compareArray(a, b, items) {
+    var item = items[0];
+    if (!item)
+        return 0;
+    var mapper = item[0], direction = item[1];
+    var res = defaultCompareFn(mapper(a), mapper(b), direction);
+    return res !== 0 ? res : compareArray(a, b, items.slice(1));
+}
+function _c(xs) {
+    return Collection.from(xs);
+}
+exports.default = _c;

package/domain/entities/generic/Either.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Either a success value or an error. Example:
+ *
+ * ```
+ * Either.success<{ message: string }, string>("9")
+ *     .map(s => parseInt(s))
+ *     .flatMap(x => {
+ *         return x > 0 ? Either.success(Math.sqrt(x)) : Either.error({ message: "negative!" });
+ *     })
+ *     .match({
+ *         success: x => console.log(`Value is ${x}`),
+ *         error: error => console.error(`Some error: ${error.message}`),
+ *     }); // prints `Value is 3`
+ * ```
+ */
+export declare class Either<Error, Data> {
+    value: EitherValue<Error, Data>;
+    constructor(value: EitherValue<Error, Data>);
+    match<Res>(matchObj: MatchObject<Error, Data, Res>): Res;
+    isError(): this is this & {
+        value: EitherValueError<Error>;
+    };
+    isSuccess(): this is this & {
+        value: EitherValueSuccess<Data>;
+    };
+    map<Data1>(fn: (data: Data) => Data1): Either<Error, Data1>;
+    mapError<Error1>(fn: (error: Error) => Error1): Either<Error1, Data>;
+    flatMap<Data1>(fn: (data: Data) => Either<Error, Data1>): Either<Error, Data1>;
+    flatMapError<Error1>(fn: (error: Error) => Either<Error1, Data>): Either<Error1, Data>;
+    static error<Error>(error: Error): Either<Error, never>;
+    static success<Error, Data>(data: Data): Either<Error, Data>;
+    static map2<Error, Res, Data1, Data2>([either1, either2]: [Either<Error, Data1>, Either<Error, Data2>], fn: (data1: Data1, data2: Data2) => Res): Either<Error, Res>;
+}
+type EitherValueError<Error> = {
+    type: "error";
+    error: Error;
+    data?: never;
+};
+type EitherValueSuccess<Data> = {
+    type: "success";
+    error?: never;
+    data: Data;
+};
+type EitherValue<Error, Data> = EitherValueError<Error> | EitherValueSuccess<Data>;
+type MatchObject<Error, Data, Res> = {
+    success: (data: Data) => Res;
+    error: (error: Error) => Res;
+};
+export {};

package/domain/entities/generic/Either.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Either a success value or an error. Example:
+ *
+ * ```
+ * Either.success<{ message: string }, string>("9")
+ *     .map(s => parseInt(s))
+ *     .flatMap(x => {
+ *         return x > 0 ? Either.success(Math.sqrt(x)) : Either.error({ message: "negative!" });
+ *     })
+ *     .match({
+ *         success: x => console.log(`Value is ${x}`),
+ *         error: error => console.error(`Some error: ${error.message}`),
+ *     }); // prints `Value is 3`
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Either = void 0;
+var Either = /** @class */ (function () {
+    function Either(value) {
+        this.value = value;
+    }
+    Either.prototype.match = function (matchObj) {
+        switch (this.value.type) {
+            case "success":
+                return matchObj.success(this.value.data);
+            case "error":
+                return matchObj.error(this.value.error);
+        }
+    };
+    Either.prototype.isError = function () {
+        return this.value.type === "error";
+    };
+    Either.prototype.isSuccess = function () {
+        return this.value.type === "success";
+    };
+    Either.prototype.map = function (fn) {
+        return this.flatMap(function (data) { return new Either({ type: "success", data: fn(data) }); });
+    };
+    Either.prototype.mapError = function (fn) {
+        return this.flatMapError(function (error) { return new Either({ type: "error", error: fn(error) }); });
+    };
+    Either.prototype.flatMap = function (fn) {
+        var _this = this;
+        return this.match({
+            success: function (data) { return fn(data); },
+            error: function () { return _this; },
+        });
+    };
+    Either.prototype.flatMapError = function (fn) {
+        var _this = this;
+        return this.match({
+            success: function () { return _this; },
+            error: function (error) { return fn(error); },
+        });
+    };
+    Either.error = function (error) {
+        return new Either({ type: "error", error: error });
+    };
+    Either.success = function (data) {
+        return new Either({ type: "success", data: data });
+    };
+    Either.map2 = function (_a, fn) {
+        var either1 = _a[0], either2 = _a[1];
+        return either1.flatMap(function (data1) {
+            return either2.map(function (data2) { return fn(data1, data2); });
+        });
+    };
+    return Either;
+}());
+exports.Either = Either;

package/domain/entities/generic/Future.d.ts

@@ -0,0 +1,45 @@
+import { FutureData } from "../../../data/api-futures";
+/**
+ * Futures are async values similar to promises, with some differences:
+ *   - Futures are only executed when their method `run` is called.
+ *   - Futures are cancellable (thus, they can be easily used in a `React.useEffect`, for example).
+ *   - Futures have fully typed errors. Subclass Error if you need full stack traces.
+ *   - You may still use async/await monad-style blocks (check Future.block).
+ *
+ * More info: https://github.com/EyeSeeTea/know-how/wiki/Async-futures
+ */
+export declare class Future<E, D> {
+    private _promise;
+    private constructor();
+    static success<E, D>(data: D): Future<E, D>;
+    static error<E, D>(error: E): Future<E, D>;
+    static fromPromise<Data>(promise: Promise<Data>): FutureData<Data>;
+    static fromComputation<E, D>(computation: (resolve: (value: D) => void, reject: (error: E) => void) => Cancel): Future<E, D>;
+    run(onSuccess: (data: D) => void, onError: (error: E) => void): Cancel;
+    map<U>(fn: (data: D) => U): Future<E, U>;
+    mapError<E2>(fn: (error: E) => E2): Future<E2, D>;
+    flatMap<U, E>(fn: (data: D) => Future<U, E>): Future<U, E>;
+    flatMapError<E2>(fn: (error: E) => Future<E2, D>): Future<E2, D>;
+    chain<U, E>(fn: (data: D) => Future<U, E>): Future<U, E>;
+    toPromise(): Promise<D>;
+    static join2<E, T, S>(async1: Future<E, T>, async2: Future<E, S>): Future<E, [T, S]>;
+    static joinObj<Obj extends Record<string, Future<any, any>>>(obj: Obj, options?: ParallelOptions): Future<Obj[keyof Obj] extends Future<infer E, any> ? E : never, {
+        [K in keyof Obj]: Obj[K] extends Future<any, infer U> ? U : never;
+    }>;
+    static sequential<E, D>(asyncs: Future<E, D>[]): Future<E, D[]>;
+    static parallel<E, D>(asyncs: Future<E, D>[], options: ParallelOptions): Future<E, D[]>;
+    static sleep(ms: number): Future<any, number>;
+    static void(): Future<unknown, undefined>;
+    static block<E, U>(blockFn: (capture: CaptureAsync<E>) => Promise<U>): Future<E, U>;
+    static block_<E>(): <U>(blockFn: (capture: CaptureAsync<E>) => Promise<U>) => Future<E, U>;
+}
+export type Cancel = (() => void) | undefined;
+interface CaptureAsync<E> {
+    <D>(async: Future<E, D>): Promise<D>;
+    throw: (error: E) => never;
+}
+type ParallelOptions = {
+    concurrency: number;
+};
+export declare function getJSON<U>(url: string): Future<TypeError | SyntaxError, U>;
+export {};