@croct/sdk 0.9.1 → 0.11.0-alpha

package/uuid.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uuid4 = void 0;
-function uuid4(sortable) {
-    if (sortable === void 0) { sortable = false; }
-    var uuid = '';
+function uuid4(sortable = false) {
+    let uuid = '';
     if (sortable) {
-        var prefix = Date.now().toString(16).padStart(12, '0').substring(0, 12);
-        uuid = "".concat(prefix.substring(0, 8), "-").concat(prefix.substring(8, 12));
+        const prefix = Date.now()
+            .toString(16)
+            .padStart(12, '0')
+            .substring(0, 12);
+        uuid = `${prefix.substring(0, 8)}-${prefix.substring(8, 12)}`;
     }
-    for (var index = uuid.length; index < 36; index++) {
+    for (let index = uuid.length; index < 36; index++) {
         switch (index) {
             case 8:
             case 13:
@@ -21,7 +23,7 @@ function uuid4(sortable) {
                 uuid += '4';
                 break;
             default: {
-                var random = (Math.random() * 16) | 0;
+                let random = (Math.random() * 16) | 0;
                 if (index === 19) {
                     // bits 6-7 of the clock_seq_hi_and_reserved to 01
                     random = (random & 3) | 8;

package/validation/arrayType.d.ts

@@ -1,5 +1,5 @@
 import { Schema, TypeSchema } from './schema';
-declare type ArrayDefinition = {
+type ArrayDefinition = {
     minItems: number;
     maxItems: number;
     items?: Schema;
@@ -8,7 +8,7 @@ export declare class ArrayType implements TypeSchema {
     private readonly definition;
     constructor(definition?: Partial<ArrayDefinition>);
     getTypes(): string[];
-    isValidType(value: unknown): value is Array<unknown>;
+    isValidType(value: unknown): value is unknown[];
     validate(value: unknown, path?: string[]): void;
 }
 export {};

package/validation/arrayType.js

@@ -1,45 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayType = void 0;
-var tslib_1 = require("tslib");
-var schema_1 = require("./schema");
-var violation_1 = require("./violation");
-var ArrayType = /** @class */ (function () {
-    function ArrayType(definition) {
-        if (definition === void 0) { definition = {}; }
+const schema_1 = require("./schema");
+const violation_1 = require("./violation");
+class ArrayType {
+    constructor(definition = {}) {
         var _a, _b;
-        this.definition = tslib_1.__assign(tslib_1.__assign({}, definition), { minItems: (_a = definition.minItems) !== null && _a !== void 0 ? _a : -1, maxItems: (_b = definition.maxItems) !== null && _b !== void 0 ? _b : -1 });
+        this.definition = {
+            ...definition,
+            minItems: (_a = definition.minItems) !== null && _a !== void 0 ? _a : -1,
+            maxItems: (_b = definition.maxItems) !== null && _b !== void 0 ? _b : -1,
+        };
     }
-    ArrayType.prototype.getTypes = function () {
+    getTypes() {
         return ['array'];
-    };
-    ArrayType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return Array.isArray(value);
-    };
-    ArrayType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!this.isValidType(value)) {
-            throw new schema_1.Violation("Expected value of type array at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: 'string' });
+            throw new schema_1.Violation(`Expected value of type array at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: 'string' });
         }
-        var _a = this.definition, minItems = _a.minItems, maxItems = _a.maxItems;
-        var length = value.length;
+        const { minItems, maxItems } = this.definition;
+        const { length } = value;
         if (minItems >= 0 && minItems > length) {
-            throw new schema_1.Violation("Expected ".concat(minItems === maxItems ? 'exactly' : 'at least', " ")
-                + "".concat(minItems, " ").concat(minItems === 1 ? 'item' : 'items', " ")
-                + "at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat(length, "."), path, { limit: minItems });
+            throw new schema_1.Violation(`Expected ${minItems === maxItems ? 'exactly' : 'at least'} `
+                + `${minItems} ${minItems === 1 ? 'item' : 'items'} `
+                + `at path '${(0, violation_1.formatPath)(path)}', actual ${length}.`, path, { limit: minItems });
         }
         if (maxItems >= 0 && maxItems < length) {
-            throw new schema_1.Violation("Expected ".concat(minItems === maxItems ? 'exactly' : 'at most', " ")
-                + "".concat(maxItems, " ").concat(maxItems === 1 ? 'item' : 'items', " ")
-                + "at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat(length, "."), path, { limit: maxItems });
+            throw new schema_1.Violation(`Expected ${minItems === maxItems ? 'exactly' : 'at most'} `
+                + `${maxItems} ${maxItems === 1 ? 'item' : 'items'} `
+                + `at path '${(0, violation_1.formatPath)(path)}', actual ${length}.`, path, { limit: maxItems });
         }
         if (this.definition.items === undefined) {
             return;
         }
-        for (var index = 0; index < length; index++) {
-            this.definition.items.validate(value[index], path.concat([index.toString()]));
+        for (let index = 0; index < length; index++) {
+            this.definition
+                .items
+                .validate(value[index], path.concat([index.toString()]));
         }
-    };
-    return ArrayType;
-}());
+    }
+}
 exports.ArrayType = ArrayType;

package/validation/booleanType.js

@@ -1,23 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BooleanType = void 0;
-var schema_1 = require("./schema");
-var violation_1 = require("./violation");
-var BooleanType = /** @class */ (function () {
-    function BooleanType() {
-    }
-    BooleanType.prototype.getTypes = function () {
+const schema_1 = require("./schema");
+const violation_1 = require("./violation");
+class BooleanType {
+    getTypes() {
         return ['boolean'];
-    };
-    BooleanType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return typeof value === 'boolean';
-    };
-    BooleanType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!this.isValidType(value)) {
-            throw new schema_1.Violation("Expected value of type boolean at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: 'boolean' });
+            throw new schema_1.Violation(`Expected value of type boolean at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: 'boolean' });
         }
-    };
-    return BooleanType;
-}());
+    }
+}
 exports.BooleanType = BooleanType;

package/validation/functionType.js

@@ -1,23 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionType = void 0;
-var schema_1 = require("./schema");
-var violation_1 = require("./violation");
-var FunctionType = /** @class */ (function () {
-    function FunctionType() {
-    }
-    FunctionType.prototype.getTypes = function () {
+const schema_1 = require("./schema");
+const violation_1 = require("./violation");
+class FunctionType {
+    getTypes() {
         return ['function'];
-    };
-    FunctionType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return typeof value === 'function';
-    };
-    FunctionType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!this.isValidType(value)) {
-            throw new schema_1.Violation("Expected value of type function at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: 'function' });
+            throw new schema_1.Violation(`Expected value of type function at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: 'function' });
         }
-    };
-    return FunctionType;
-}());
+    }
+}
 exports.FunctionType = FunctionType;

package/validation/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnionType = exports.StringType = exports.ObjectType = exports.NumberType = exports.NullType = exports.MixedSchema = exports.JsonPrimitiveType = exports.JsonObjectType = exports.JsonArrayType = exports.JsonType = exports.FunctionType = exports.BooleanType = exports.ArrayType = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./schema"), exports);
 tslib_1.__exportStar(require("./violation"), exports);
 var arrayType_1 = require("./arrayType");

package/validation/jsonType.d.ts

@@ -1,5 +1,5 @@
 import { Schema, TypeSchema } from './schema';
-declare type JsonObjectDefinition = {
+type JsonObjectDefinition = {
     properties?: Schema;
     propertyNames?: Schema;
 };
@@ -10,7 +10,7 @@ export declare class JsonObjectType implements TypeSchema {
     isValidType(value: unknown): boolean;
     validate(value: unknown, path?: string[]): void;
 }
-declare type JsonArrayDefinition = {
+type JsonArrayDefinition = {
     items?: Schema;
 };
 export declare class JsonArrayType implements TypeSchema {

package/validation/jsonType.js

@@ -1,127 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonType = exports.JsonPrimitiveType = exports.JsonArrayType = exports.JsonObjectType = void 0;
-var tslib_1 = require("tslib");
-var schema_1 = require("./schema");
-var violation_1 = require("./violation");
+const schema_1 = require("./schema");
+const violation_1 = require("./violation");
 function isJsonPrimitive(value) {
     return value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number';
 }
+function isPlainObject(value) {
+    return Object.prototype
+        .toString
+        .call(value) === '[object Object]';
+}
 function isJsonArray(value) {
     return Array.isArray(value) && value.every(isJsonValue);
 }
-function isJsonValue(value) {
-    return isJsonPrimitive(value) || isJsonArray(value) || isJsonObject(value);
-}
 function isJsonObject(value) {
     return isPlainObject(value) && Object.values(value).every(isJsonValue);
 }
-// eslint-disable-next-line @typescript-eslint/ban-types
-function isPlainObject(value) {
-    return Object.prototype.toString.call(value) === '[object Object]';
+function isJsonValue(value) {
+    return isJsonPrimitive(value) || isJsonArray(value) || isJsonObject(value);
 }
-var JsonObjectType = /** @class */ (function () {
-    function JsonObjectType(definition) {
-        if (definition === void 0) { definition = {}; }
+class JsonObjectType {
+    constructor(definition = {}) {
         this.definition = definition;
     }
-    JsonObjectType.prototype.getTypes = function () {
+    getTypes() {
         return ['object'];
-    };
-    JsonObjectType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return isPlainObject(value);
-    };
-    JsonObjectType.prototype.validate = function (value, path) {
-        var e_1, _a;
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!isJsonObject(value)) {
-            throw new schema_1.Violation("Expected a JSON object at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: 'object' });
+            throw new schema_1.Violation(`Expected a JSON object at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: 'object' });
         }
         if (this.definition.properties === undefined && this.definition.propertyNames === undefined) {
             return;
         }
-        try {
-            for (var _b = tslib_1.__values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = tslib_1.__read(_c.value, 2), entryName = _d[0], entryValue = _d[1];
-                var propertyPath = path.concat([entryName]);
-                if (this.definition.propertyNames !== undefined) {
-                    this.definition.propertyNames.validate(entryName, propertyPath);
-                }
-                if (this.definition.properties !== undefined) {
-                    this.definition.properties.validate(entryValue, path.concat([entryName]));
-                }
+        for (const [entryName, entryValue] of Object.entries(value)) {
+            const propertyPath = path.concat([entryName]);
+            if (this.definition.propertyNames !== undefined) {
+                this.definition
+                    .propertyNames
+                    .validate(entryName, propertyPath);
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            if (this.definition.properties !== undefined) {
+                this.definition
+                    .properties
+                    .validate(entryValue, path.concat([entryName]));
             }
-            finally { if (e_1) throw e_1.error; }
         }
-    };
-    return JsonObjectType;
-}());
+    }
+}
 exports.JsonObjectType = JsonObjectType;
-var JsonArrayType = /** @class */ (function () {
-    function JsonArrayType(definition) {
-        if (definition === void 0) { definition = {}; }
+class JsonArrayType {
+    constructor(definition = {}) {
         this.definition = definition;
     }
-    JsonArrayType.prototype.getTypes = function () {
+    getTypes() {
         return ['array'];
-    };
-    JsonArrayType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return Array.isArray(value);
-    };
-    JsonArrayType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!isJsonArray(value)) {
-            throw new schema_1.Violation("Expected a JSON array at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: 'array' });
+            throw new schema_1.Violation(`Expected a JSON array at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: 'array' });
         }
         if (this.definition.items === undefined) {
             return;
         }
-        for (var index = 0; index < value.length; index++) {
-            this.definition.items.validate(value[index], path.concat([index.toString()]));
+        for (let index = 0; index < value.length; index++) {
+            this.definition
+                .items
+                .validate(value[index], path.concat([index.toString()]));
         }
-    };
-    return JsonArrayType;
-}());
-exports.JsonArrayType = JsonArrayType;
-var JsonPrimitiveType = /** @class */ (function () {
-    function JsonPrimitiveType() {
     }
-    JsonPrimitiveType.prototype.getTypes = function () {
+}
+exports.JsonArrayType = JsonArrayType;
+class JsonPrimitiveType {
+    getTypes() {
         return ['null', 'number', 'string', 'boolean'];
-    };
-    JsonPrimitiveType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return isJsonPrimitive(value);
-    };
-    JsonPrimitiveType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!this.isValidType(value)) {
-            throw new schema_1.Violation("Expected a JSON primitive at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: this.getTypes().join('|') });
+            throw new schema_1.Violation(`Expected a JSON primitive at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: this.getTypes().join('|') });
         }
-    };
-    return JsonPrimitiveType;
-}());
-exports.JsonPrimitiveType = JsonPrimitiveType;
-var JsonType = /** @class */ (function () {
-    function JsonType() {
     }
-    JsonType.prototype.getTypes = function () {
+}
+exports.JsonPrimitiveType = JsonPrimitiveType;
+class JsonType {
+    getTypes() {
         return ['null', 'number', 'string', 'boolean', 'array', 'object'];
-    };
-    JsonType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return isJsonPrimitive(value) || Array.isArray(value) || isPlainObject(value);
-    };
-    JsonType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!isJsonValue(value)) {
-            throw new schema_1.Violation("Expected a JSON value at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: this.getTypes().join('|') });
+            throw new schema_1.Violation(`Expected a JSON value at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: this.getTypes().join('|') });
         }
-    };
-    return JsonType;
-}());
+    }
+}
 exports.JsonType = JsonType;

package/validation/mixedSchema.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MixedSchema = void 0;
-var MixedSchema = /** @class */ (function () {
-    function MixedSchema() {
-    }
-    MixedSchema.prototype.validate = function () {
+class MixedSchema {
+    validate() {
         // always valid
-    };
-    return MixedSchema;
-}());
+    }
+}
 exports.MixedSchema = MixedSchema;

package/validation/nullType.js

@@ -1,23 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NullType = void 0;
-var schema_1 = require("./schema");
-var violation_1 = require("./violation");
-var NullType = /** @class */ (function () {
-    function NullType() {
-    }
-    NullType.prototype.getTypes = function () {
+const schema_1 = require("./schema");
+const violation_1 = require("./violation");
+class NullType {
+    getTypes() {
         return ['null'];
-    };
-    NullType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return value === null;
-    };
-    NullType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!this.isValidType(value)) {
-            throw new schema_1.Violation("Expected value of type null at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: 'null' });
+            throw new schema_1.Violation(`Expected value of type null at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: 'null' });
         }
-    };
-    return NullType;
-}());
+    }
+}
 exports.NullType = NullType;

package/validation/numberType.d.ts

@@ -1,5 +1,5 @@
 import { TypeSchema } from './schema';
-declare type NumberDefinition = {
+type NumberDefinition = {
     integer: boolean;
     minimum: number;
     maximum: number;

package/validation/numberType.js

@@ -1,36 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumberType = void 0;
-var tslib_1 = require("tslib");
-var schema_1 = require("./schema");
-var violation_1 = require("./violation");
-var NumberType = /** @class */ (function () {
-    function NumberType(definition) {
-        if (definition === void 0) { definition = {}; }
+const schema_1 = require("./schema");
+const violation_1 = require("./violation");
+class NumberType {
+    constructor(definition = {}) {
         var _a, _b, _c;
-        this.definition = tslib_1.__assign(tslib_1.__assign({}, definition), { integer: (_a = definition.integer) !== null && _a !== void 0 ? _a : false, minimum: (_b = definition.minimum) !== null && _b !== void 0 ? _b : Number.NEGATIVE_INFINITY, maximum: (_c = definition.maximum) !== null && _c !== void 0 ? _c : Number.POSITIVE_INFINITY });
+        this.definition = {
+            ...definition,
+            integer: (_a = definition.integer) !== null && _a !== void 0 ? _a : false,
+            minimum: (_b = definition.minimum) !== null && _b !== void 0 ? _b : Number.NEGATIVE_INFINITY,
+            maximum: (_c = definition.maximum) !== null && _c !== void 0 ? _c : Number.POSITIVE_INFINITY,
+        };
     }
-    NumberType.prototype.getTypes = function () {
+    getTypes() {
         return [this.definition.integer ? 'integer' : 'number'];
-    };
-    NumberType.prototype.isValidType = function (value) {
+    }
+    isValidType(value) {
         return typeof value === 'number' && (!this.definition.integer || Number.isInteger(value));
-    };
-    NumberType.prototype.validate = function (value, path) {
-        if (path === void 0) { path = []; }
+    }
+    validate(value, path = []) {
         if (!this.isValidType(value)) {
-            var type = this.getTypes()[0];
-            throw new schema_1.Violation("Expected value of type ".concat(type, " at path '").concat((0, violation_1.formatPath)(path), "', actual ").concat((0, violation_1.describe)(value), "."), path, { type: type });
+            const type = this.getTypes()[0];
+            throw new schema_1.Violation(`Expected value of type ${type} at path '${(0, violation_1.formatPath)(path)}', actual ${(0, violation_1.describe)(value)}.`, path, { type: type });
         }
         if (value < this.definition.minimum) {
-            throw new schema_1.Violation("Expected a value greater than or equal to ".concat(this.definition.minimum, " ")
-                + "at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat(value, "."), path, { limit: this.definition.minimum });
+            throw new schema_1.Violation(`Expected a value greater than or equal to ${this.definition.minimum} `
+                + `at path '${(0, violation_1.formatPath)(path)}', actual ${value}.`, path, { limit: this.definition.minimum });
         }
         if (value > this.definition.maximum) {
-            throw new schema_1.Violation("Expected a value less than or equal to ".concat(this.definition.maximum, " ")
-                + "at path '".concat((0, violation_1.formatPath)(path), "', actual ").concat(value, "."), path, { limit: this.definition.maximum });
+            throw new schema_1.Violation(`Expected a value less than or equal to ${this.definition.maximum} `
+                + `at path '${(0, violation_1.formatPath)(path)}', actual ${value}.`, path, { limit: this.definition.maximum });
         }
-    };
-    return NumberType;
-}());
+    }
+}
 exports.NumberType = NumberType;

package/validation/objectType.d.ts

@@ -1,5 +1,5 @@
 import { Schema, TypeSchema } from './schema';
-declare type ObjectDefinition = {
+type ObjectDefinition = {
     type?: {
         new (...args: any): any;
     };