@innet/server 2.0.0-beta.1 → 2.0.0-beta.11

package/utils/rules/maxDate/maxDate.js

@@ -10,7 +10,11 @@ function maxDate(max) {
             throw new helpers.RulesError('date', data);
         }
         if (value > max) {
-            throw new helpers.RulesError('maxDate', Object.assign(Object.assign({}, data), { max: max.toISOString(), value }));
+            throw new helpers.RulesError('maxDate', {
+                ...data,
+                max: max.toISOString(),
+                value,
+            });
         }
         return value;
     };

package/utils/rules/maxLength/maxLength.es6.js

@@ -6,8 +6,11 @@ function maxLength(max) {
             throw new RulesError('string', data);
         }
         if (value.length > max) {
-            throw new RulesError('maxLength', Object.assign(Object.assign({}, data), { max,
-                value }));
+            throw new RulesError('maxLength', {
+                ...data,
+                max,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/maxLength/maxLength.js

@@ -10,8 +10,11 @@ function maxLength(max) {
             throw new helpers.RulesError('string', data);
         }
         if (value.length > max) {
-            throw new helpers.RulesError('maxLength', Object.assign(Object.assign({}, data), { max,
-                value }));
+            throw new helpers.RulesError('maxLength', {
+                ...data,
+                max,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/min/min.es6.js

@@ -3,11 +3,17 @@ import { RulesError } from '../helpers.es6.js';
 function min(min) {
     return (value, data) => {
         if (!['bigint', 'number'].includes(typeof value)) {
-            throw new RulesError('number', Object.assign(Object.assign({}, data), { value }));
+            throw new RulesError('number', {
+                ...data,
+                value,
+            });
         }
         if (value < min) {
-            throw new RulesError('minimum', Object.assign(Object.assign({}, data), { min,
-                value }));
+            throw new RulesError('minimum', {
+                ...data,
+                min,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/min/min.js

@@ -7,11 +7,17 @@ var helpers = require('../helpers.js');
 function min(min) {
     return (value, data) => {
         if (!['bigint', 'number'].includes(typeof value)) {
-            throw new helpers.RulesError('number', Object.assign(Object.assign({}, data), { value }));
+            throw new helpers.RulesError('number', {
+                ...data,
+                value,
+            });
         }
         if (value < min) {
-            throw new helpers.RulesError('minimum', Object.assign(Object.assign({}, data), { min,
-                value }));
+            throw new helpers.RulesError('minimum', {
+                ...data,
+                min,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/minBin/minBin.es6.js

@@ -3,8 +3,11 @@ import { RulesError } from '../helpers.es6.js';
 function minBin(min) {
     return (value, data) => {
         if (value.size < min) {
-            throw new RulesError('minBin', Object.assign({ min,
-                value }, data));
+            throw new RulesError('minBin', {
+                min,
+                value,
+                ...data,
+            });
         }
         return value;
     };

package/utils/rules/minBin/minBin.js

@@ -7,8 +7,11 @@ var helpers = require('../helpers.js');
 function minBin(min) {
     return (value, data) => {
         if (value.size < min) {
-            throw new helpers.RulesError('minBin', Object.assign({ min,
-                value }, data));
+            throw new helpers.RulesError('minBin', {
+                min,
+                value,
+                ...data,
+            });
         }
         return value;
     };

package/utils/rules/minDate/minDate.es6.js

@@ -6,7 +6,11 @@ function minDate(min) {
             throw new RulesError('date', data);
         }
         if (value < min) {
-            throw new RulesError('minDate', Object.assign(Object.assign({}, data), { min: min.toISOString(), value }));
+            throw new RulesError('minDate', {
+                ...data,
+                min: min.toISOString(),
+                value,
+            });
         }
         return value;
     };

package/utils/rules/minDate/minDate.js

@@ -10,7 +10,11 @@ function minDate(min) {
             throw new helpers.RulesError('date', data);
         }
         if (value < min) {
-            throw new helpers.RulesError('minDate', Object.assign(Object.assign({}, data), { min: min.toISOString(), value }));
+            throw new helpers.RulesError('minDate', {
+                ...data,
+                min: min.toISOString(),
+                value,
+            });
         }
         return value;
     };

package/utils/rules/minLength/minLength.es6.js

@@ -6,8 +6,11 @@ function minLength(min) {
             throw new RulesError('string', data);
         }
         if (value.length < min) {
-            throw new RulesError('minLength', Object.assign(Object.assign({}, data), { min,
-                value }));
+            throw new RulesError('minLength', {
+                ...data,
+                min,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/minLength/minLength.js

@@ -10,8 +10,11 @@ function minLength(min) {
             throw new helpers.RulesError('string', data);
         }
         if (value.length < min) {
-            throw new helpers.RulesError('minLength', Object.assign(Object.assign({}, data), { min,
-                value }));
+            throw new helpers.RulesError('minLength', {
+                ...data,
+                min,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/num/num.es6.js

@@ -3,7 +3,10 @@ import { RulesError } from '../helpers.es6.js';
 function num(value, data) {
     const result = Number(value);
     if (isNaN(result) || result > Number.MAX_SAFE_INTEGER || result < -Number.MAX_SAFE_INTEGER) {
-        throw new RulesError('number', Object.assign({ value }, data));
+        throw new RulesError('number', {
+            value,
+            ...data,
+        });
     }
     return result;
 }

package/utils/rules/num/num.js

@@ -7,7 +7,10 @@ var helpers = require('../helpers.js');
 function num(value, data) {
     const result = Number(value);
     if (isNaN(result) || result > Number.MAX_SAFE_INTEGER || result < -Number.MAX_SAFE_INTEGER) {
-        throw new helpers.RulesError('number', Object.assign({ value }, data));
+        throw new helpers.RulesError('number', {
+            value,
+            ...data,
+        });
     }
     return result;
 }

package/utils/rules/objectOf/objectOf.es6.js

@@ -3,11 +3,14 @@ import { RulesError, addKey } from '../helpers.es6.js';
 function objectOf(map, rest) {
     return (value, data) => {
         if (value === null || typeof value !== 'object') {
-            throw new RulesError('object', Object.assign({ value }, data));
+            throw new RulesError('object', {
+                value,
+                ...data,
+            });
         }
         const result = {};
         for (const key in map) {
-            const val = map[key](value[key], Object.assign(Object.assign({}, data), { key: addKey(key, data) }));
+            const val = map[key](value[key], { ...data, key: addKey(key, data) });
             if (val !== undefined) {
                 result[key] = val;
             }
@@ -16,7 +19,7 @@ function objectOf(map, rest) {
             for (const key in value) {
                 if (key in map)
                     continue;
-                const val = rest(value[key], Object.assign(Object.assign({}, data), { key: addKey(key, data) }));
+                const val = rest(value[key], { ...data, key: addKey(key, data) });
                 if (val !== undefined) {
                     result[key] = val;
                 }

package/utils/rules/objectOf/objectOf.js

@@ -7,11 +7,14 @@ var helpers = require('../helpers.js');
 function objectOf(map, rest) {
     return (value, data) => {
         if (value === null || typeof value !== 'object') {
-            throw new helpers.RulesError('object', Object.assign({ value }, data));
+            throw new helpers.RulesError('object', {
+                value,
+                ...data,
+            });
         }
         const result = {};
         for (const key in map) {
-            const val = map[key](value[key], Object.assign(Object.assign({}, data), { key: helpers.addKey(key, data) }));
+            const val = map[key](value[key], { ...data, key: helpers.addKey(key, data) });
             if (val !== undefined) {
                 result[key] = val;
             }
@@ -20,7 +23,7 @@ function objectOf(map, rest) {
             for (const key in value) {
                 if (key in map)
                     continue;
-                const val = rest(value[key], Object.assign(Object.assign({}, data), { key: helpers.addKey(key, data) }));
+                const val = rest(value[key], { ...data, key: helpers.addKey(key, data) });
                 if (val !== undefined) {
                     result[key] = val;
                 }

package/utils/rules/pattern/pattern.es6.js

@@ -4,8 +4,12 @@ function pattern(pattern, patternId = String(pattern)) {
     const normPattern = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
     return (value, data) => {
         if (!normPattern.test(value)) {
-            throw new RulesError('pattern', Object.assign({ pattern: String(normPattern), patternId,
-                value }, data));
+            throw new RulesError('pattern', {
+                pattern: String(normPattern),
+                patternId,
+                value,
+                ...data,
+            });
         }
         return value;
     };

package/utils/rules/pattern/pattern.js

@@ -8,8 +8,12 @@ function pattern(pattern, patternId = String(pattern)) {
     const normPattern = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
     return (value, data) => {
         if (!normPattern.test(value)) {
-            throw new helpers.RulesError('pattern', Object.assign({ pattern: String(normPattern), patternId,
-                value }, data));
+            throw new helpers.RulesError('pattern', {
+                pattern: String(normPattern),
+                patternId,
+                value,
+                ...data,
+            });
         }
         return value;
     };

package/utils/rules/tupleOf/tupleOf.es6.js

@@ -10,7 +10,7 @@ function tupleOf(rules) {
         }
         const result = [];
         for (let index = 0; index < rules.length; index++) {
-            result.push(rules[index](value[index], Object.assign(Object.assign({}, data), { key: addKey(index, data) })));
+            result.push(rules[index](value[index], { ...data, key: addKey(index, data) }));
         }
         return result;
     };

package/utils/rules/tupleOf/tupleOf.js

@@ -14,7 +14,7 @@ function tupleOf(rules) {
         }
         const result = [];
         for (let index = 0; index < rules.length; index++) {
-            result.push(rules[index](value[index], Object.assign(Object.assign({}, data), { key: helpers.addKey(index, data) })));
+            result.push(rules[index](value[index], { ...data, key: helpers.addKey(index, data) }));
         }
         return result;
     };

package/utils/rules/values/index.es6.js

@@ -1 +1 @@
-export { values } from './values.es6.js';
+export { getArrayValues, values } from './values.es6.js';

package/utils/rules/values/index.js

@@ -6,4 +6,5 @@ var values = require('./values.js');
 
 
 
+exports.getArrayValues = values.getArrayValues;
 exports.values = values.values;

package/utils/rules/values/values.d.ts

@@ -1 +1,3 @@
-export declare function values(values: any[]): (value: any, data?: object) => any;
+import { type SchemaValues } from '../../../types';
+export declare function getArrayValues<T, F extends (value: T | string) => any = () => T>(values: SchemaValues<T>, format?: F): ReturnType<F>[];
+export declare function values<T>(values: T[]): (value: any, data?: object) => any;

package/utils/rules/values/values.es6.js

@@ -1,13 +1,19 @@
 import { RulesError } from '../helpers.es6.js';
 
+function getArrayValues(values, format = (value => value)) {
+    return Array.isArray(values) ? values.map(format) : Object.keys(values).map(format);
+}
 function values(values) {
     return (value, data) => {
         if (!values.includes(value)) {
-            throw new RulesError('values', Object.assign(Object.assign({}, data), { value,
-                values }));
+            throw new RulesError('values', {
+                ...data,
+                value,
+                values,
+            });
         }
         return value;
     };
 }
 
-export { values };
+export { getArrayValues, values };

package/utils/rules/values/values.js

@@ -4,14 +4,21 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var helpers = require('../helpers.js');
 
+function getArrayValues(values, format = (value => value)) {
+    return Array.isArray(values) ? values.map(format) : Object.keys(values).map(format);
+}
 function values(values) {
     return (value, data) => {
         if (!values.includes(value)) {
-            throw new helpers.RulesError('values', Object.assign(Object.assign({}, data), { value,
-                values }));
+            throw new helpers.RulesError('values', {
+                ...data,
+                value,
+                values,
+            });
         }
         return value;
     };
 }
 
+exports.getArrayValues = getArrayValues;
 exports.values = values;

package/utils/stringifySearch/stringifySearch.es6.js

@@ -1,7 +1,10 @@
 import qs from 'qs';
 
 function stringifySearch(search, options) {
-    return qs.stringify(search, Object.assign({ encode: false }, options));
+    return qs.stringify(search, {
+        encode: false,
+        ...options,
+    });
 }
 
 export { stringifySearch };

package/utils/stringifySearch/stringifySearch.js

@@ -9,7 +9,10 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 
 function stringifySearch(search, options) {
-    return qs__default["default"].stringify(search, Object.assign({ encode: false }, options));
+    return qs__default["default"].stringify(search, {
+        encode: false,
+        ...options,
+    });
 }
 
 exports.stringifySearch = stringifySearch;

package/_virtual/_rollup-plugin-process-env.es6.js

@@ -1,10 +0,0 @@
-;(function () {
-  const env = {"INNETJS_JSX_PACKAGE_VERSION":"1.4.0"};
-  if (typeof process === 'undefined') {
-    globalThis.process = { env: env };
-  } else if (process.env) {
-    Object.assign(process.env, env);
-  } else {
-    process.env = env;
-  }
-})();

package/_virtual/_rollup-plugin-process-env.js

@@ -1,12 +0,0 @@
-'use strict';
-
-;(function () {
-  const env = {"INNETJS_JSX_PACKAGE_VERSION":"1.4.0"};
-  if (typeof process === 'undefined') {
-    globalThis.process = { env: env };
-  } else if (process.env) {
-    Object.assign(process.env, env);
-  } else {
-    process.env = env;
-  }
-})();