@aeriajs/common 0.0.24 → 0.0.26

package/dist/evaluateCondition.mjs

@@ -1,63 +1,60 @@
+"use strict";
 import { arraysIntersects } from "./arraysIntersects.mjs";
-var equalOrContains = function(term1, term2) {
-    if (Array.isArray(term1) && Array.isArray(term2)) {
-        return arraysIntersects(term1, term2);
-    }
-    if (Array.isArray(term1)) {
-        return term1.includes(term2);
-    }
-    if (Array.isArray(term2)) {
-        return term2.includes(term1);
-    }
+const equalOrContains = (term1, term2) => {
+  if (Array.isArray(term1) && Array.isArray(term2)) {
+    return arraysIntersects(term1, term2);
+  }
+  if (Array.isArray(term1)) {
+    return term1.includes(term2);
+  }
+  if (Array.isArray(term2)) {
+    return term2.includes(term1);
+  }
 };
-var evaluatesToTrue = function(subject, condition) {
-    if ("term1" in condition) {
-        if (!subject) {
-            return false;
-        }
-        var term1 = subject[condition.term1];
-        if (condition.operator === "truthy") {
-            return !!term1;
-        }
-        var operator = condition.operator, term2 = condition.term2;
-        switch(operator){
-            case "equal":
-                return term1 === term2;
-            case "in":
-                return !!equalOrContains(term1, term2);
-            case "gt":
-                return term1 > term2;
-            case "lt":
-                return term1 < term2;
-            case "gte":
-                return term1 >= term2;
-            case "lte":
-                return term1 <= term2;
-        }
-    }
-    if ("and" in condition) {
-        return condition.and.every(function(condition) {
-            return evaluatesToTrue(subject, condition);
-        });
-    }
-    if ("or" in condition) {
-        return condition.or.some(function(condition) {
-            return evaluatesToTrue(subject, condition);
-        });
-    }
-    if ("not" in condition) {
-        return !evaluatesToTrue(subject, condition.not);
-    }
-    return false;
+const evaluatesToTrue = (subject, condition) => {
+  if ("term1" in condition) {
+    if (!subject) {
+      return false;
+    }
+    const term1 = subject[condition.term1];
+    if (condition.operator === "truthy") {
+      return !!term1;
+    }
+    const { operator, term2 } = condition;
+    switch (operator) {
+      case "equal":
+        return term1 === term2;
+      case "in":
+        return !!equalOrContains(term1, term2);
+      case "gt":
+        return term1 > term2;
+      case "lt":
+        return term1 < term2;
+      case "gte":
+        return term1 >= term2;
+      case "lte":
+        return term1 <= term2;
+    }
+  }
+  if ("and" in condition) {
+    return condition.and.every((condition2) => evaluatesToTrue(subject, condition2));
+  }
+  if ("or" in condition) {
+    return condition.or.some((condition2) => evaluatesToTrue(subject, condition2));
+  }
+  if ("not" in condition) {
+    return !evaluatesToTrue(subject, condition.not);
+  }
+  return false;
 };
-export var evaluateCondition = function(subject, condition) {
-    var result = {
-        satisfied: false,
-        else: null
-    };
-    var satisfied = result.satisfied = evaluatesToTrue(subject, condition);
-    if (!satisfied && "else" in condition) {
-        result.else = condition.else;
-    }
-    return result;
+export const evaluateCondition = (subject, condition) => {
+  const result = {
+    satisfied: false,
+    else: null
+  };
+  const satisfied = result.satisfied = evaluatesToTrue(subject, condition);
+  if (!satisfied && "else" in condition) {
+    result.else = condition.else;
+  }
+  return result;
 };

package/dist/formatValue.mjs

@@ -1,59 +1,50 @@
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
-    }
-}
+"use strict";
 import { formatDateTime } from "./date.mjs";
 import { getReferenceProperty } from "./getReferenceProperty.mjs";
-export var formatValue = function(value, key, property, index) {
-    if (Array.isArray(value)) {
-        return value.map(function(v) {
-            return formatValue(v, key, property, index);
-        }).join(", ");
+export const formatValue = (value, key, property, index) => {
+  if (Array.isArray(value)) {
+    return value.map((v) => formatValue(v, key, property, index)).join(", ");
+  }
+  const firstValue = (() => {
+    if (!property) {
+      return value;
+    }
+    const refProperty = getReferenceProperty(property);
+    if (refProperty) {
+      const firstIndex = index || refProperty.indexes?.[0];
+      return firstIndex && value?.[firstIndex];
+    }
+    if (value instanceof Object) {
+      return Object.values(value)[0];
+    }
+    return value;
+  })();
+  const formatted = (() => {
+    if (!property) {
+      return firstValue;
+    }
+    if ("type" in property) {
+      if (property.type === "boolean") {
+        return firstValue ? "true" : false;
+      }
+    }
+    if ("format" in property && property.format) {
+      if ([
+        "date",
+        "date-time"
+      ].includes(property.format)) {
+        return formatDateTime(String(value), {
+          hours: property.format === "date-time"
+        });
+      }
+    }
+    if ([
+      void 0,
+      null
+    ].includes(firstValue)) {
+      return "-";
     }
-    var firstValue = function() {
-        if (!property) {
-            return value;
-        }
-        var refProperty = getReferenceProperty(property);
-        if (refProperty) {
-            var _refProperty_indexes;
-            var firstIndex = index || ((_refProperty_indexes = refProperty.indexes) === null || _refProperty_indexes === void 0 ? void 0 : _refProperty_indexes[0]);
-            return firstIndex && (value === null || value === void 0 ? void 0 : value[firstIndex]);
-        }
-        if (_instanceof(value, Object)) {
-            return Object.values(value)[0];
-        }
-        return value;
-    }();
-    var formatted = function() {
-        if (!property) {
-            return firstValue;
-        }
-        if ("type" in property) {
-            if (property.type === "boolean") {
-                return firstValue ? "true" : false;
-            }
-        }
-        if ("format" in property && property.format) {
-            if ([
-                "date",
-                "date-time"
-            ].includes(property.format)) {
-                return formatDateTime(String(value), {
-                    hours: property.format === "date-time"
-                });
-            }
-        }
-        if ([
-            undefined,
-            null
-        ].includes(firstValue)) {
-            return "-";
-        }
-        return firstValue;
-    }();
-    return String(formatted);
+    return firstValue;
+  })();
+  return String(formatted);
 };

package/dist/freshItem.mjs

@@ -1,133 +1,36 @@
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_with_holes(arr) {
-    if (Array.isArray(arr)) return arr;
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
+"use strict";
+const freshProperties = (properties) => Object.entries(properties).reduce((a, [key, property]) => {
+  const value = (() => {
+    if ("$ref" in property) {
+      return {};
     }
-    return obj;
-}
-function _iterable_to_array_limit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
+    if ("properties" in property) {
+      return freshProperties(property.properties);
     }
-    return _arr;
-}
-function _non_iterable_rest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
+    if ("type" in property) {
+      switch (property.type) {
+        case "boolean":
+          return false;
+        case "array":
+          return [];
+        case "object":
+          return {};
+      }
     }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-            symbols = symbols.filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-            });
-        }
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-var freshProperties = function(properties) {
-    return Object.entries(properties).reduce(function(a, param) {
-        var _param = _sliced_to_array(param, 2), key = _param[0], property = _param[1];
-        var value = function() {
-            if ("$ref" in property) {
-                return {};
-            }
-            if ("properties" in property) {
-                return freshProperties(property.properties);
-            }
-            if ("type" in property) {
-                switch(property.type){
-                    case "boolean":
-                        return false;
-                    case "array":
-                        return [];
-                    case "object":
-                        return {};
-                }
-            }
-            return null;
-        }();
-        if (value === null) {
-            return a;
-        }
-        return _object_spread_props(_object_spread({}, a), _define_property({}, key, value));
-    }, {});
-};
-export var freshItem = function(description) {
-    var item = freshProperties(description.properties);
-    if (description.freshItem) {
-        Object.assign(item, description.freshItem);
-    }
-    return item;
+    return null;
+  })();
+  if (value === null) {
+    return a;
+  }
+  return {
+    ...a,
+    [key]: value
+  };
+}, {});
+export const freshItem = (description) => {
+  const item = freshProperties(description.properties);
+  if (description.freshItem) {
+    Object.assign(item, description.freshItem);
+  }
+  return item;
 };

package/dist/getMissingProperties.mjs

@@ -1,50 +1,42 @@
+"use strict";
 import { checkForUndefined } from "./checkForUndefined.mjs";
 import { evaluateCondition } from "./evaluateCondition.mjs";
-export var getMissingProperties = function(what, schema, required) {
-    var missingProps = [];
-    if (Array.isArray(required)) {
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = required[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var propName = _step.value;
-                var isMissing = checkForUndefined(schema.properties[propName], propName, what);
-                if (isMissing) {
-                    missingProps.push(propName);
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
+export const getMissingProperties = (what, schema, required) => {
+  const missingProps = [];
+  if (Array.isArray(required)) {
+    for (const propName of required) {
+      const isMissing = checkForUndefined(
+        schema.properties[propName],
+        propName,
+        what
+      );
+      if (isMissing) {
+        missingProps.push(propName);
+      }
+    }
+  } else {
+    for (const propName in required) {
+      const requiredProp = required[propName];
+      if (typeof requiredProp === "boolean") {
+        if (!requiredProp) {
+          continue;
         }
-    } else {
-        for(var propName1 in required){
-            var requiredProp = required[propName1];
-            if (typeof requiredProp === "boolean") {
-                if (!requiredProp) {
-                    continue;
-                }
-            }
-            if (typeof requiredProp === "object") {
-                var result = evaluateCondition(what, requiredProp);
-                if (!result.satisfied) {
-                    continue;
-                }
-            }
-            var isMissing1 = checkForUndefined(schema.properties[propName1], propName1, what);
-            if (isMissing1) {
-                missingProps.push(propName1);
-            }
+      }
+      if (typeof requiredProp === "object") {
+        const result = evaluateCondition(what, requiredProp);
+        if (!result.satisfied) {
+          continue;
         }
+      }
+      const isMissing = checkForUndefined(
+        schema.properties[propName],
+        propName,
+        what
+      );
+      if (isMissing) {
+        missingProps.push(propName);
+      }
     }
-    return missingProps;
+  }
+  return missingProps;
 };

package/dist/getReferenceProperty.mjs

@@ -1,11 +1,10 @@
-export var getReferenceProperty = function(property) {
-    var search = [
-        "items" in property ? property.items : null,
-        "additionalProperties" in property ? property.additionalProperties : null,
-        property
-    ];
-    var reference = search.find(function(_) {
-        return !!_;
-    });
-    return reference && "$ref" in reference ? reference : null;
+"use strict";
+export const getReferenceProperty = (property) => {
+  const search = [
+    "items" in property ? property.items : null,
+    "additionalProperties" in property ? property.additionalProperties : null,
+    property
+  ];
+  const reference = search.find((_) => !!_);
+  return reference && "$ref" in reference ? reference : null;
 };

package/dist/getValueFromPath.mjs

@@ -1,6 +1,7 @@
-export var getValueFromPath = function(object, path) {
-    var fragments = path.split(".");
-    return fragments.reduce(function(a, fragment) {
-        return a && a[fragment];
-    }, object);
+"use strict";
+export const getValueFromPath = (object, path) => {
+  const fragments = path.split(".");
+  return fragments.reduce((a, fragment) => {
+    return a && a[fragment];
+  }, object);
 };