@eyeseetea/d2-logger 0.1.0-beta.1

package/domain/entities/generic/Future.js

@@ -0,0 +1,276 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSON = exports.Future = void 0;
+var rcpromise = __importStar(require("real-cancellable-promise"));
+var real_cancellable_promise_1 = require("real-cancellable-promise");
+/**
+ * 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
+ */
+var Future = /** @class */ (function () {
+    function Future(_promise) {
+        this._promise = _promise;
+    }
+    Future.success = function (data) {
+        return new Future(function () { return rcpromise.CancellablePromise.resolve(data); });
+    };
+    Future.error = function (error) {
+        return new Future(function () { return rcpromise.CancellablePromise.reject(error); });
+    };
+    Future.fromPromise = function (promise) {
+        return Future.fromComputation(function (resolve, reject) {
+            promise.then(resolve).catch(function (err) { return reject(err ? err.message : "Unknown error"); });
+            return function () { };
+        });
+    };
+    Future.fromComputation = function (computation) {
+        var cancel = function () { };
+        return new Future(function () {
+            var promise = new Promise(function (resolve, reject) {
+                cancel = computation(resolve, function (error) { return reject(error); });
+            });
+            return new rcpromise.CancellablePromise(promise, cancel || (function () { }));
+        });
+    };
+    Future.prototype.run = function (onSuccess, onError) {
+        return this._promise().then(onSuccess, function (err) {
+            if (err instanceof rcpromise.Cancellation) {
+                // no-op
+            }
+            else {
+                onError(err);
+            }
+        }).cancel;
+    };
+    Future.prototype.map = function (fn) {
+        var _this = this;
+        return new Future(function () { return _this._promise().then(fn); });
+    };
+    Future.prototype.mapError = function (fn) {
+        var _this = this;
+        return new Future(function () {
+            return _this._promise().catch(function (error) {
+                throw fn(error);
+            });
+        });
+    };
+    Future.prototype.flatMap = function (fn) {
+        var _this = this;
+        return new Future(function () { return _this._promise().then(function (data) { return fn(data)._promise(); }); });
+    };
+    Future.prototype.flatMapError = function (fn) {
+        var _this = this;
+        return new Future(function () { return _this._promise().catch(function (error) { return fn(error)._promise(); }); });
+    };
+    Future.prototype.chain = function (fn) {
+        return this.flatMap(fn);
+    };
+    Future.prototype.toPromise = function () {
+        return this._promise();
+    };
+    Future.join2 = function (async1, async2) {
+        return new Future(function () {
+            return rcpromise.CancellablePromise.all([async1._promise(), async2._promise()]);
+        });
+    };
+    Future.joinObj = function (obj, options) {
+        if (options === void 0) { options = { concurrency: 1 }; }
+        var asyncs = Object.values(obj);
+        return Future.parallel(asyncs, options).map(function (values) {
+            var keys = Object.keys(obj);
+            var pairs = keys.map(function (key, idx) { return [key, values[idx]]; });
+            return Object.fromEntries(pairs);
+        });
+    };
+    Future.sequential = function (asyncs) {
+        var _this = this;
+        return Future.block(function ($) { return __awaiter(_this, void 0, void 0, function () {
+            var output, _i, asyncs_1, async, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        output = [];
+                        _i = 0, asyncs_1 = asyncs;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < asyncs_1.length)) return [3 /*break*/, 4];
+                        async = asyncs_1[_i];
+                        return [4 /*yield*/, $(async)];
+                    case 2:
+                        res = _a.sent();
+                        output.push(res);
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, output];
+                }
+            });
+        }); });
+    };
+    Future.parallel = function (asyncs, options) {
+        var _this = this;
+        return new Future(function () {
+            return rcpromise.buildCancellablePromise(function ($) { return __awaiter(_this, void 0, void 0, function () {
+                var queue, output, _loop_1, _i, _a, _b, idx, async;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            queue = [];
+                            output = new Array(asyncs.length);
+                            _loop_1 = function (idx, async) {
+                                var queueItem$;
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            queueItem$ = async._promise().then(function (res) {
+                                                queue.splice(queue.indexOf(queueItem$), 1);
+                                                output[idx] = res;
+                                            });
+                                            queue.push(queueItem$);
+                                            if (!(queue.length >= options.concurrency)) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, $(rcpromise.CancellablePromise.race(queue))];
+                                        case 1:
+                                            _d.sent();
+                                            _d.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            };
+                            _i = 0, _a = asyncs.map(function (async, idx) { return [idx, async]; });
+                            _c.label = 1;
+                        case 1:
+                            if (!(_i < _a.length)) return [3 /*break*/, 4];
+                            _b = _a[_i], idx = _b[0], async = _b[1];
+                            return [5 /*yield**/, _loop_1(idx, async)];
+                        case 2:
+                            _c.sent();
+                            _c.label = 3;
+                        case 3:
+                            _i++;
+                            return [3 /*break*/, 1];
+                        case 4: return [4 /*yield*/, $(rcpromise.CancellablePromise.all(queue))];
+                        case 5:
+                            _c.sent();
+                            return [2 /*return*/, output];
+                    }
+                });
+            }); });
+        });
+    };
+    Future.sleep = function (ms) {
+        return new Future(function () { return rcpromise.CancellablePromise.delay(ms); }).map(function () { return ms; });
+    };
+    Future.void = function () {
+        return Future.success(undefined);
+    };
+    Future.block = function (blockFn) {
+        return new Future(function () {
+            return rcpromise.buildCancellablePromise(function (capturePromise) {
+                var captureAsync = function (async) {
+                    return capturePromise(async._promise());
+                };
+                captureAsync.throw = function (error) {
+                    throw error;
+                };
+                return blockFn(captureAsync);
+            });
+        });
+    };
+    Future.block_ = function () {
+        return function (blockFn) {
+            return Future.block(blockFn);
+        };
+    };
+    return Future;
+}());
+exports.Future = Future;
+function getJSON(url) {
+    var abortController = new AbortController();
+    return Future.fromComputation(function (resolve, reject) {
+        // exceptions: TypeError | DOMException[name=AbortError]
+        fetch(url, { method: "get", signal: abortController.signal })
+            .then(function (res) { return res.json(); }) // exceptions: SyntaxError
+            .then(function (data) { return resolve(data); })
+            .catch(function (error) {
+            if (isNamedError(error) && error.name === "AbortError") {
+                throw new real_cancellable_promise_1.Cancellation();
+            }
+            else if (error instanceof TypeError || error instanceof SyntaxError) {
+                reject(error);
+            }
+            else {
+                reject(new TypeError("Unknown error"));
+            }
+        });
+        return function () { return abortController.abort(); };
+    });
+}
+exports.getJSON = getJSON;
+function isNamedError(error) {
+    return Boolean(error && typeof error === "object" && "name" in error);
+}

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

@@ -0,0 +1,42 @@
+import { Collection } from "./Collection";
+import * as imap from "typed-immutable-map";
+/**
+ * Like ES6 Map, but immutable.
+ *
+ * ```
+ * import HashMap from "./HashMap";
+ *
+ * const map = HashMap.fromObject({ x: 1, y: 2, z: 3 })
+ *     .invert()
+ *     .pickBy(([key, value]) => key > 1)
+ *     .values(); // ["y", "z"]
+ */
+export declare class HashMap<K, V> {
+    protected _map: imap.HashMap<K, V>;
+    protected constructor(_map: imap.HashMap<K, V>);
+    static empty<K, V>(): HashMap<K, V>;
+    static fromPairs<K, V>(pairs: Array<[K, V]>): HashMap<K, V>;
+    static fromObject<K extends keyof any, V>(obj: Record<K, V>): HashMap<K, V>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): HashMap<K, V>;
+    equals(map: HashMap<K, V>): boolean;
+    keys(): K[];
+    values(): V[];
+    toPairs(): Array<[K, V]>;
+    get size(): number;
+    pick(keys: K[]): HashMap<K, V>;
+    pickBy(pred: (pair: readonly [K, V]) => boolean): HashMap<K, V>;
+    omit(keys: K[]): HashMap<K, V>;
+    omitBy(pred: (pair: readonly [K, V]) => boolean): HashMap<K, V>;
+    toCollection(): Collection<[K, V]>;
+    hasKey(key: K): boolean;
+    invert(): HashMap<V, K>;
+    invertMulti(): HashMap<V, K[]>;
+    mapValues<V2>(mapper: (pair: [K, V]) => V2): HashMap<K, V2>;
+    mapKeys<K2>(_mapper: (pair: [K, V]) => K2): HashMap<K2, V>;
+    merge(other: HashMap<K, V>): HashMap<K, V>;
+    forEach(fn: (pair: readonly [K, V]) => void): void;
+    toObject(): ToObject<K, V>;
+}
+type ToObject<K, V> = K extends keyof any ? Record<K, V> : Record<string, V>;
+export {};

package/domain/entities/generic/HashMap.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashMap = void 0;
+var Collection_1 = require("./Collection");
+var imap = __importStar(require("typed-immutable-map"));
+/**
+ * Like ES6 Map, but immutable.
+ *
+ * ```
+ * import HashMap from "./HashMap";
+ *
+ * const map = HashMap.fromObject({ x: 1, y: 2, z: 3 })
+ *     .invert()
+ *     .pickBy(([key, value]) => key > 1)
+ *     .values(); // ["y", "z"]
+ */
+/* Immutable Hash Map. Keys and values can be of any type. */
+var HashMap = /** @class */ (function () {
+    function HashMap(_map) {
+        this._map = _map;
+    }
+    /* Constructors */
+    HashMap.empty = function () {
+        return new HashMap(imap.empty());
+    };
+    HashMap.fromPairs = function (pairs) {
+        return new HashMap(imap.fromIterable(pairs));
+    };
+    HashMap.fromObject = function (obj) {
+        return new HashMap(imap.fromObject(obj));
+    };
+    /* Methods */
+    HashMap.prototype.get = function (key) {
+        return imap.get(key, this._map);
+    };
+    HashMap.prototype.set = function (key, value) {
+        var updated = imap.set(key, value, this._map);
+        return new HashMap(updated);
+    };
+    HashMap.prototype.equals = function (map) {
+        var _this = this;
+        var mapsHaveEqualSize = function () { return _this.size === map.size; };
+        var allValuesEqual = function () { return _this.keys().every(function (k) { return _this.get(k) === map.get(k); }); };
+        return mapsHaveEqualSize() && allValuesEqual();
+    };
+    HashMap.prototype.keys = function () {
+        return Array.from(imap.keys(this._map));
+    };
+    HashMap.prototype.values = function () {
+        return Array.from(imap.values(this._map));
+    };
+    HashMap.prototype.toPairs = function () {
+        return Array.from(imap.entries(this._map));
+    };
+    Object.defineProperty(HashMap.prototype, "size", {
+        get: function () {
+            return this._map.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HashMap.prototype.pick = function (keys) {
+        return this.pickBy(function (_a) {
+            var key = _a[0], _value = _a[1];
+            return keys.includes(key);
+        });
+    };
+    HashMap.prototype.pickBy = function (pred) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return new HashMap(imap.filter(function (value, key) { return pred([key, value]); }, this._map));
+    };
+    HashMap.prototype.omit = function (keys) {
+        return this.pickBy(function (_a) {
+            var key = _a[0], _value = _a[1];
+            return !keys.includes(key);
+        });
+    };
+    HashMap.prototype.omitBy = function (pred) {
+        return this.pickBy(function (_a) {
+            var key = _a[0], value = _a[1];
+            return !pred([key, value]);
+        });
+    };
+    HashMap.prototype.toCollection = function () {
+        return Collection_1.Collection.from(this.toPairs());
+    };
+    HashMap.prototype.hasKey = function (key) {
+        return imap.has(key, this._map);
+    };
+    HashMap.prototype.invert = function () {
+        var invertedPairs = this.toPairs().map(function (_a) {
+            var key = _a[0], value = _a[1];
+            return [value, key];
+        });
+        return HashMap.fromPairs(invertedPairs);
+    };
+    HashMap.prototype.invertMulti = function () {
+        return this.toCollection().groupFromMap(function (_a) {
+            var key = _a[0], value = _a[1];
+            return [value, key];
+        });
+    };
+    HashMap.prototype.mapValues = function (mapper) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return new HashMap(imap.map(function (value, key) { return mapper([key, value]); }, this._map));
+    };
+    HashMap.prototype.mapKeys = function (_mapper) {
+        var pairs = this.toPairs().map(function (_a) {
+            var key = _a[0], value = _a[1];
+            return [_mapper([key, value]), value];
+        });
+        return HashMap.fromPairs(pairs);
+    };
+    HashMap.prototype.merge = function (other) {
+        return HashMap.fromPairs(this.toPairs().concat(other.toPairs()));
+    };
+    HashMap.prototype.forEach = function (fn) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        imap.forEach(function (value, key) { return fn([key, value]); }, this._map);
+    };
+    HashMap.prototype.toObject = function () {
+        return imap.toObject(this._map);
+    };
+    return HashMap;
+}());
+exports.HashMap = HashMap;

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

@@ -0,0 +1,30 @@
+/**
+ * Expand methods for Javascript objects. An example:
+ *
+ * ```
+ * import _r from "./Rec";
+ *
+ * const obj = _r({ x: 1, y: 2, s: "hello" })
+ *     .pick(["x", "y"])
+ *     .merge(_r({ z: 3 }))
+ *     .value(); // { x: 1, y: 2, z: 3}
+ * ```
+ */
+export declare class Rec<T extends BaseObj> {
+    protected obj: T;
+    protected constructor(obj: T);
+    static from<T extends BaseObj>(obj: T): Rec<T>;
+    keys(): Array<keyof T>;
+    values(): Array<T[keyof T]>;
+    toObject(): T;
+    value(): T;
+    pick<K extends keyof T>(keys: K[]): Rec<Pick<T, K>>;
+    omit<K extends keyof T>(keys: K[]): Rec<Omit<T, K>>;
+    pickBy(filter: (key: keyof T) => boolean): Rec<Partial<T>>;
+    omitBy(filter: (key: keyof T) => boolean): Rec<Partial<T>>;
+    merge<T2 extends BaseObj>(rec2: Rec<T2>): Rec<Merge<T, T2>>;
+}
+export default function _r<T extends BaseObj>(obj: T): Rec<T>;
+type Merge<T1, T2> = Omit<T1, keyof T2> & T2;
+type BaseObj = Record<string, unknown>;
+export {};

package/domain/entities/generic/Rec.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Expand methods for Javascript objects. An example:
+ *
+ * ```
+ * import _r from "./Rec";
+ *
+ * const obj = _r({ x: 1, y: 2, s: "hello" })
+ *     .pick(["x", "y"])
+ *     .merge(_r({ z: 3 }))
+ *     .value(); // { x: 1, y: 2, z: 3}
+ * ```
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rec = void 0;
+var Rec = /** @class */ (function () {
+    function Rec(obj) {
+        this.obj = obj;
+    }
+    Rec.from = function (obj) {
+        return new Rec(obj);
+    };
+    Rec.prototype.keys = function () {
+        return Object.keys(this.obj);
+    };
+    Rec.prototype.values = function () {
+        return Object.values(this.obj);
+    };
+    Rec.prototype.toObject = function () {
+        return this.obj;
+    };
+    Rec.prototype.value = function () {
+        return this.obj;
+    };
+    Rec.prototype.pick = function (keys) {
+        return this.pickBy(function (key) { return keys.includes(key); });
+    };
+    Rec.prototype.omit = function (keys) {
+        return this.pickBy(function (key) { return !keys.includes(key); });
+    };
+    Rec.prototype.pickBy = function (filter) {
+        var pairs = Object.entries(this.obj);
+        var filtered = Object.fromEntries(pairs.filter(function (_a) {
+            var k = _a[0], _v = _a[1];
+            return filter(k);
+        }));
+        return new Rec(filtered);
+    };
+    Rec.prototype.omitBy = function (filter) {
+        return this.pickBy(function (key) { return !filter(key); });
+    };
+    Rec.prototype.merge = function (rec2) {
+        var merged = __assign(__assign({}, this.obj), rec2.obj);
+        return new Rec(merged);
+    };
+    return Rec;
+}());
+exports.Rec = Rec;
+function _r(obj) {
+    return Rec.from(obj);
+}
+exports.default = _r;

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

@@ -0,0 +1,36 @@
+/**
+ * Base class for typical classes with attributes. Features: create, update.
+ *
+ * ```
+ * class Counter extends Struct<{ id: Id; value: number }>() {
+ *     add(value: number): Counter {
+ *         return this._update({ value: this.value + value });
+ *     }
+ * }
+ *
+ * const counter1 = Counter.create({ id: "some-counter", value: 1 });
+ * const counter2 = counter1._update({ value: 2 });
+ * ```
+ */
+export declare function Struct<Attrs>(): {
+    new (values: Attrs): Attrs & {
+        _getAttributes(): Attrs;
+        _update(partialAttrs: Partial<Attrs>): this;
+    };
+    create: <U extends {
+        _getAttributes(): Attrs;
+        _update(partialAttrs: Partial<Attrs>): this;
+    }>(this: new (attrs: Attrs) => U, attrs: Attrs) => U;
+};
+declare const GenericStruct: {
+    new (values: unknown): {
+        _getAttributes(): unknown;
+        _update(partialAttrs: Partial<unknown>): this;
+    };
+    create: <U extends {
+        _getAttributes(): unknown;
+        _update(partialAttrs: Partial<unknown>): this;
+    }>(this: new (attrs: unknown) => U, attrs: unknown) => U;
+};
+export type GenericStructInstance = InstanceType<typeof GenericStruct>;
+export {};

package/domain/entities/generic/Struct.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Base class for typical classes with attributes. Features: create, update.
+ *
+ * ```
+ * class Counter extends Struct<{ id: Id; value: number }>() {
+ *     add(value: number): Counter {
+ *         return this._update({ value: this.value + value });
+ *     }
+ * }
+ *
+ * const counter1 = Counter.create({ id: "some-counter", value: 1 });
+ * const counter2 = counter1._update({ value: 2 });
+ * ```
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Struct = void 0;
+function Struct() {
+    var Base = /** @class */ (function () {
+        function Base(_attributes) {
+            Object.assign(this, _attributes);
+        }
+        Base.prototype._getAttributes = function () {
+            var _this = this;
+            var entries = Object.getOwnPropertyNames(this).map(function (key) { return [key, _this[key]]; });
+            return Object.fromEntries(entries);
+        };
+        Base.prototype._update = function (partialAttrs) {
+            var ParentClass = this.constructor;
+            return new ParentClass(__assign(__assign({}, this._getAttributes()), partialAttrs));
+        };
+        Base.create = function (attrs) {
+            return new this(attrs);
+        };
+        return Base;
+    }());
+    return Base;
+}
+exports.Struct = Struct;
+var GenericStruct = Struct();

package/domain/entities/generic/__tests__/Collection.spec.d.ts

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