@veracity/vui 0.0.1

package/utils/object.js

@@ -0,0 +1,93 @@
+"use strict";
+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.omit = exports.objectFilter = exports.mergeWith = exports.isObj = exports.get = exports.filterUndefined = void 0;
+/** Removes keys from an object if their value is undefined. */
+var filterUndefined = function (object) { return objectFilter(object, function (val) { return val !== null && val !== undefined; }); };
+exports.filterUndefined = filterUndefined;
+/**
+ * Recursively retrieves a nested property of a given object
+ * @param object
+ * @param path string, such as: 'user.name', or array ['user', 'name']
+ * @param separator used when path is a string to split individual keys
+ */
+function get(object, path, separator) {
+    if (separator === void 0) { separator = '.'; }
+    if (!isObj(object))
+        return;
+    var keys = Array.isArray(path) ? path : path.split(separator);
+    return keys.reduce(function (obj, property) { return obj === null || obj === void 0 ? void 0 : obj[property]; }, object);
+}
+exports.get = get;
+/** Checks if the item is an object. */
+function isObj(item) {
+    return item && typeof item === 'object' && item.constructor === Object;
+}
+exports.isObj = isObj;
+/**
+ * Recursively deep merges two objects in an immutable fashion, following these rules:
+ * - Property exists in both objects and is an object itself => merge
+ * - Property exists in both objects and has the same, non-object type => override
+ * - Property doesn't exist in source => override
+ */
+function mergeWith(source, override) {
+    var output;
+    if (isObj(source) && isObj(override)) {
+        output = __assign({}, source);
+        Object.keys(override).forEach(function (key) {
+            if (key === '__proto__')
+                return;
+            if (key in source) {
+                if (override[key] && typeof source[key] === typeof override[key]) {
+                    if (isObj(override[key])) {
+                        output[key] = mergeWith(source[key], override[key]);
+                    }
+                    else {
+                        output[key] = override[key];
+                    }
+                }
+            }
+            else {
+                output[key] = override[key];
+            }
+        });
+    }
+    return output;
+}
+exports.mergeWith = mergeWith;
+/**
+ * Returns the items of an object that meet the condition specified in a callback function.
+ */
+function objectFilter(object, fn) {
+    var result = {};
+    Object.keys(object).forEach(function (key) {
+        var value = object[key];
+        var shouldPass = fn(value, key, object);
+        if (shouldPass) {
+            result[key] = value;
+        }
+    });
+    return result;
+}
+exports.objectFilter = objectFilter;
+/** Removes given keys from an object. */
+function omit(object, keys) {
+    var result = {};
+    Object.keys(object).forEach(function (key) {
+        if (keys.includes(key))
+            return;
+        result[key] = object[key];
+    });
+    return result;
+}
+exports.omit = omit;

package/utils/types.d.ts

@@ -0,0 +1,3 @@
+export declare type AnyNumber = number & {};
+export declare type AnyString = string & {};
+export declare type Dict<T = any> = Record<string, T>;

package/utils/types.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-types */
+Object.defineProperty(exports, "__esModule", { value: true });