@aeriajs/common 0.0.0

package/dist/either.d.ts

@@ -0,0 +1,9 @@
+import type { Either, Left, Right } from '@aeriajs/types';
+export declare const left: <const T>(value: T) => Left<T>;
+export declare const right: <const T>(value: T) => Right<T>;
+export declare const isLeft: <L>(either: Either<L, any>) => either is Left<L>;
+export declare const isRight: <R>(either: Either<any, R>) => either is Right<R>;
+export declare const unwrapEither: <L, R>(either: Either<L, R>) => L | R;
+export declare const error: <const T>(value: T) => Left<T>;
+export declare const ok: <const T>(value: T) => Right<T>;
+export declare const unsafe: <L, R>(either: Either<L, R>, message?: any) => R;

package/dist/either.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsafe = exports.ok = exports.error = exports.unwrapEither = exports.isRight = exports.isLeft = exports.right = exports.left = void 0;
+const left = (value) => ({
+    _tag: 'Left',
+    value,
+});
+exports.left = left;
+const right = (value) => ({
+    _tag: 'Right',
+    value,
+});
+exports.right = right;
+const isLeft = (either) => {
+    return either._tag === 'Left';
+};
+exports.isLeft = isLeft;
+const isRight = (either) => {
+    return either._tag === 'Right';
+};
+exports.isRight = isRight;
+const unwrapEither = (either) => {
+    return either.value;
+};
+exports.unwrapEither = unwrapEither;
+exports.error = exports.left;
+exports.ok = exports.right;
+const unsafe = (either, message) => {
+    if (either._tag !== 'Right') {
+        if (process.env.NODE_ENV !== 'production') {
+            console.trace(JSON.stringify(either.value, null, 2));
+        }
+        throw new Error(`unsafe threw: ${either.value} (${message || '-'})`);
+    }
+    return either.value;
+};
+exports.unsafe = unsafe;

package/dist/either.mjs

@@ -0,0 +1,32 @@
+export var left = function(value) {
+    return {
+        _tag: "Left",
+        value: value
+    };
+};
+export var right = function(value) {
+    return {
+        _tag: "Right",
+        value: value
+    };
+};
+export var isLeft = function(either) {
+    return either._tag === "Left";
+};
+export var isRight = function(either) {
+    return either._tag === "Right";
+};
+export var unwrapEither = function(either) {
+    return either.value;
+};
+export var error = left;
+export var ok = right;
+export var unsafe = function(either, message) {
+    if (either._tag !== "Right") {
+        if (process.env.NODE_ENV !== "production") {
+            console.trace(JSON.stringify(either.value, null, 2));
+        }
+        throw new Error("unsafe threw: ".concat(either.value, " (").concat(message || "-", ")"));
+    }
+    return either.value;
+};

package/dist/evaluateCondition.d.ts

@@ -0,0 +1,5 @@
+import type { Condition } from '@aeriajs/types';
+export declare const evaluateCondition: (subject: any, condition: Condition) => {
+    satisfied: boolean;
+    else: null;
+};

package/dist/evaluateCondition.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateCondition = void 0;
+const arraysIntersects_js_1 = require("./arraysIntersects.js");
+const equalOrContains = (term1, term2) => {
+    if (Array.isArray(term1) && Array.isArray(term2)) {
+        return (0, arraysIntersects_js_1.arraysIntersects)(term1, term2);
+    }
+    if (Array.isArray(term1)) {
+        return term1.includes(term2);
+    }
+    if (Array.isArray(term2)) {
+        return term2.includes(term1);
+    }
+};
+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((condition) => evaluatesToTrue(subject, condition));
+    }
+    if ('or' in condition) {
+        return condition.or.some((condition) => evaluatesToTrue(subject, condition));
+    }
+    if ('not' in condition) {
+        return !evaluatesToTrue(subject, condition.not);
+    }
+    return false;
+};
+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;
+};
+exports.evaluateCondition = evaluateCondition;

package/dist/evaluateCondition.mjs

@@ -0,0 +1,63 @@
+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);
+    }
+};
+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;
+};
+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;
+};

package/dist/formatValue.d.ts

@@ -0,0 +1,2 @@
+import type { Property } from '@aeriajs/types';
+export declare const formatValue: (value: any, key: string, property?: Property, index?: string) => string;

package/dist/formatValue.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatValue = void 0;
+const date_js_1 = require("./date.js");
+const getReferenceProperty_js_1 = require("./getReferenceProperty.js");
+const formatValue = (value, key, property, index) => {
+    if (Array.isArray(value)) {
+        return value.map((v) => (0, exports.formatValue)(v, key, property, index)).join(', ');
+    }
+    const firstValue = (() => {
+        if (!property) {
+            return value;
+        }
+        const refProperty = (0, getReferenceProperty_js_1.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 (0, date_js_1.formatDateTime)(String(value), {
+                    hours: property.format === 'date-time',
+                });
+            }
+        }
+        if ([
+            undefined,
+            null,
+        ].includes(firstValue)) {
+            return '-';
+        }
+        return firstValue;
+    })();
+    return String(formatted);
+};
+exports.formatValue = formatValue;

package/dist/formatValue.mjs

@@ -0,0 +1,59 @@
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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(", ");
+    }
+    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);
+};

package/dist/freshItem.d.ts

@@ -0,0 +1,2 @@
+import type { Description } from '@aeriajs/types';
+export declare const freshItem: (description: Pick<Description, 'properties' | 'freshItem'>) => Record<string, any>;

package/dist/freshItem.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freshItem = void 0;
+const freshProperties = (properties) => Object.entries(properties).reduce((a, [key, property]) => {
+    const value = (() => {
+        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 {
+        ...a,
+        [key]: value,
+    };
+}, {});
+const freshItem = (description) => {
+    const item = freshProperties(description.properties);
+    if (description.freshItem) {
+        Object.assign(item, description.freshItem);
+    }
+    return item;
+};
+exports.freshItem = freshItem;

package/dist/freshItem.mjs

@@ -0,0 +1,133 @@
+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;
+    }
+    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;
+        }
+    }
+    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]);
+        });
+    }
+    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;
+};

package/dist/getMissingProperties.d.ts

@@ -0,0 +1,2 @@
+import type { JsonSchema } from '@aeriajs/types';
+export declare const getMissingProperties: (what: Record<string, any>, schema: Omit<JsonSchema, '$id'>, required: JsonSchema['required']) => string[];

package/dist/getMissingProperties.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMissingProperties = void 0;
+const checkForUndefined_js_1 = require("./checkForUndefined.js");
+const evaluateCondition_js_1 = require("./evaluateCondition.js");
+const getMissingProperties = (what, schema, required) => {
+    const missingProps = [];
+    if (Array.isArray(required)) {
+        for (const propName of required) {
+            const isMissing = (0, checkForUndefined_js_1.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;
+                }
+            }
+            if (typeof requiredProp === 'object') {
+                const result = (0, evaluateCondition_js_1.evaluateCondition)(what, requiredProp);
+                if (!result.satisfied) {
+                    continue;
+                }
+            }
+            const isMissing = (0, checkForUndefined_js_1.checkForUndefined)(schema.properties[propName], propName, what);
+            if (isMissing) {
+                missingProps.push(propName);
+            }
+        }
+    }
+    return missingProps;
+};
+exports.getMissingProperties = getMissingProperties;

package/dist/getMissingProperties.mjs

@@ -0,0 +1,50 @@
+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;
+                }
+            }
+        }
+    } 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);
+            }
+        }
+    }
+    return missingProps;
+};

package/dist/getReferenceProperty.d.ts

@@ -0,0 +1,2 @@
+import type { Property } from '@aeriajs/types';
+export declare const getReferenceProperty: (property: Property) => (import("@aeriajs/types").PropertyBase & import("@aeriajs/types").RefProperty) | null;

package/dist/getReferenceProperty.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferenceProperty = void 0;
+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;
+};
+exports.getReferenceProperty = getReferenceProperty;

package/dist/getReferenceProperty.mjs

@@ -0,0 +1,11 @@
+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;
+};

package/dist/getValueFromPath.d.ts

@@ -0,0 +1 @@
+export declare const getValueFromPath: (object: any, path: string) => any;

package/dist/getValueFromPath.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueFromPath = void 0;
+const getValueFromPath = (object, path) => {
+    const fragments = path.split('.');
+    return fragments.reduce((a, fragment) => {
+        return a && a[fragment];
+    }, object);
+};
+exports.getValueFromPath = getValueFromPath;

package/dist/getValueFromPath.mjs

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

package/dist/http.d.ts

@@ -0,0 +1,20 @@
+import type { RequestMethod } from '@aeriajs/types';
+export type RequestParams = Omit<RequestInit, 'headers'> & {
+    method: RequestMethod;
+    headers?: Partial<Record<string, string>>;
+};
+export type RequestConfig<Return = any> = {
+    params?: RequestParams;
+    requestTransformer?: (...args: Parameters<typeof defaultRequestTransformer>) => Promise<Return>;
+    responseTransformer?: typeof defaultResponseTransformer;
+};
+export declare const defaultRequestTransformer: (url: string, payload: any, params: RequestParams) => Promise<{
+    url: string;
+    params: RequestParams;
+}>;
+export declare const defaultResponseTransformer: (response: Awaited<ReturnType<typeof fetch>>) => Promise<Response & {
+    data: any;
+}>;
+export declare const request: <Return = any>(url: string, payload?: any, config?: RequestConfig<Return> | undefined) => Promise<Response & {
+    data: any;
+}>;