@opra/common 0.16.2 → 0.17.0

package/cjs/document/data-type/complex-type.js

@@ -90,65 +90,78 @@ const proto = {
         this.fields.set(field.name, field);
         return field;
     },
-    getField(name) {
-        if (name.includes('.')) {
-            let dt = this;
-            const arr = name.split('.');
-            const l = arr.length;
-            let field;
-            for (let i = 0; i < l; i++) {
-                if (!(dt instanceof exports.ComplexType))
-                    throw new TypeError(`"${arr.slice(0, i - 1)}" field is not a ${index_js_2.OpraSchema.ComplexType.Kind} and has no child fields`);
-                field = dt.getField(arr[i]);
-                dt = field.type;
-            }
-            // @ts-ignore
-            return field;
+    findField(nameOrPath) {
+        let field;
+        for (const [, f] of this.iteratePath(nameOrPath, true)) {
+            if (!f)
+                return;
+            field = f;
+        }
+        return field;
+    },
+    getField(nameOrPath) {
+        let field;
+        for (const [, f, path] of this.iteratePath(nameOrPath)) {
+            if (!f)
+                throw new Error(`Invalid field definition "${path}"`);
+            field = f;
         }
-        const t = this.fields.get(name);
-        if (!t)
-            throw new Error(`"${this.name}" type doesn't have an field named "${name}"`);
-        return t;
+        /* istanbul ignore next */
+        if (!field)
+            throw new Error(`Invalid field definition "${nameOrPath}"`);
+        return field;
+    },
+    iteratePath(path, silent) {
+        const arr = path.split('.');
+        const len = arr.length;
+        let dataType = this;
+        let field;
+        let curPath = '';
+        let s;
+        let i = -1;
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                i++;
+                if (i < len) {
+                    s = arr[i];
+                    if (dataType && !(dataType instanceof exports.ComplexType)) {
+                        if (silent)
+                            return { done: true, value: [] };
+                        throw new TypeError(`"${curPath}" field is not a complex type and has no child fields`);
+                    }
+                    field = dataType?.fields.get(s);
+                    if (field) {
+                        curPath += (curPath ? '.' : '') + field.name;
+                        dataType = field.type;
+                    }
+                    else {
+                        curPath += (curPath ? '.' : '') + s;
+                        if (dataType && !dataType.additionalFields) {
+                            if (silent)
+                                return { done: true, value: [] };
+                            throw new Error(`Invalid field definition "${curPath}"`);
+                        }
+                    }
+                }
+                return {
+                    done: i >= len,
+                    value: [field?.name || s, field, curPath]
+                };
+            }
+        };
     },
-    normalizeFieldNames(fields) {
-        const fieldsTree = (fields && (0, index_js_1.pathToObjectTree)(Array.isArray(fields) ? fields : [fields])) || {};
-        const out = _normalizeFieldsNames([], this.document, this, fieldsTree, '', '');
-        return out.length ? out : undefined;
+    normalizeFieldPath(path) {
+        if (Array.isArray(path))
+            return path.map((s) => this.normalizeFieldPath(s));
+        let curPath = '';
+        for (const [, , p] of this.iteratePath(path)) {
+            curPath = p;
+        }
+        return curPath;
     }
 };
 Object.assign(exports.ComplexType.prototype, proto);
 Object.setPrototypeOf(exports.ComplexType.prototype, data_type_js_1.DataType.prototype);
-/**
- * Normalizes field names
- */
-function _normalizeFieldsNames(target, document, dataType, node, parentPath = '', actualPath = '') {
-    let curPath = '';
-    for (const k of Object.keys(node)) {
-        const nodeVal = node[k];
-        const field = dataType?.fields.get(k);
-        if (!field) {
-            curPath = parentPath ? parentPath + '.' + k : k;
-            if ((dataType && !dataType.additionalFields))
-                throw new TypeError(`Unknown field "${curPath}"`);
-            if (typeof nodeVal === 'object')
-                _normalizeFieldsNames(target, document, undefined, nodeVal, curPath, actualPath);
-            else
-                target.push(curPath);
-            continue;
-        }
-        curPath = parentPath ? parentPath + '.' + field.name : field.name;
-        if (typeof nodeVal === 'object') {
-            if (!(field.type instanceof exports.ComplexType))
-                throw new TypeError(`"${(actualPath ? actualPath + '.' + curPath : curPath)}" is not a complex type and has no sub fields`);
-            if (target.findIndex(x => x === parentPath) >= 0)
-                continue;
-            target = _normalizeFieldsNames(target, document, field.type, nodeVal, curPath, actualPath);
-            continue;
-        }
-        if (target.findIndex(x => x.startsWith(curPath + '.')) >= 0) {
-            target = target.filter(x => !x.startsWith(curPath + '.'));
-        }
-        target.push(curPath);
-    }
-    return target;
-}

package/cjs/document/data-type/simple-type.js

@@ -51,7 +51,6 @@ const proto = {
         Object.assign(out, (0, index_js_1.omitUndefined)({
             base: this.base ?
                 (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            codec: this.own.codec,
             pattern: this.own.pattern
         }));
         return out;

package/cjs/document/resource/collection.js

@@ -64,9 +64,9 @@ const proto = {
         if (!_this.primaryKey.length)
             throw new TypeError(`You must provide primaryKey for Collection resource ("${_this.name}")`);
         _this.primaryKey.forEach(f => {
-            const el = dataType.getField(f);
-            if (!(el.type instanceof simple_type_js_1.SimpleType))
-                throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${el.type.kind}`);
+            const field = dataType.getField(f);
+            if (!(field?.type instanceof simple_type_js_1.SimpleType))
+                throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
         });
         if (_this.controller) {
             const instance = typeof _this.controller == 'function'
@@ -122,13 +122,11 @@ const proto = {
             return result;
         }
     },
-    normalizeFieldNames(fields) {
-        return this.type.normalizeFieldNames(fields);
+    normalizeFieldPath(path) {
+        return this.type.normalizeFieldPath(path);
     },
     normalizeSortFields(fields) {
-        const normalized = this.normalizeFieldNames(fields);
-        if (!normalized)
-            return;
+        const normalized = this.type.normalizeFieldPath(fields);
         const findManyEndpoint = this.operations.findMany;
         const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
         normalized.forEach(field => {
@@ -139,25 +137,26 @@ const proto = {
         });
         return normalized;
     },
-    normalizeFilterFields(ast) {
+    normalizeFilter(ast) {
         if (ast instanceof index_js_2.ComparisonExpression) {
-            this.normalizeFilterFields(ast.left);
+            this.normalizeFilter(ast.left);
         }
         else if (ast instanceof index_js_2.LogicalExpression) {
-            ast.items.forEach(item => this.normalizeFilterFields(item));
+            ast.items.forEach(item => this.normalizeFilter(item));
         }
         else if (ast instanceof index_js_2.ArithmeticExpression) {
-            ast.items.forEach(item => this.normalizeFilterFields(item.expression));
+            ast.items.forEach(item => this.normalizeFilter(item.expression));
         }
         else if (ast instanceof index_js_2.ArrayExpression) {
-            ast.items.forEach(item => this.normalizeFilterFields(item));
+            ast.items.forEach(item => this.normalizeFilter(item));
         }
         else if (ast instanceof index_js_2.ParenthesesExpression) {
-            this.normalizeFilterFields(ast.expression);
+            this.normalizeFilter(ast.expression);
         }
         else if (ast instanceof index_js_2.QualifiedIdentifier) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            ast.value = this.normalizeFieldNames([ast.value])[0];
+            ast.field = this.type.findField(ast.value);
+            ast.dataType = ast.field?.type || this.document.getDataType('any');
+            ast.value = this.type.normalizeFieldPath(ast.value);
         }
         return ast;
     }

package/cjs/document/resource/singleton.js

@@ -67,8 +67,8 @@ const proto = {
         }));
         return out;
     },
-    normalizeFieldNames(fields) {
-        return this.type.normalizeFieldNames(fields);
+    normalizeFieldPath(path) {
+        return this.type.normalizeFieldPath(path);
     },
 };
 Object.assign(exports.Singleton.prototype, proto);

package/cjs/http/http-params.js

@@ -191,7 +191,7 @@ class HttpParams {
             get(target, p, receiver) {
                 if (typeof p === 'string') {
                     const v = _this[kEntries].get(p);
-                    return v ? (v.length > 1 ? v : v[0]) : undefined;
+                    return v ? (v.length > 1 ? v : v[0]) : null;
                 }
                 return Reflect.get(target, p, receiver);
             },
@@ -236,7 +236,7 @@ class HttpParams {
                 ? value.map((v) => fn(v)).join(prmDef.arrayDelimiter || ',')
                 : fn(value);
         }
-        return encodeURIParam(value);
+        return encodeURIParam(String(value));
     }
     decodeValue(value, key) {
         const prmDef = this[kParamDefs].get(key);
@@ -268,6 +268,12 @@ class HttpParams {
         }
         return decodeURIComponent(value);
     }
+    [(_a = kEntries, _b = kSize, _c = kParamDefs, Symbol.iterator)]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return 'HttpParams';
+    }
     _append(name, value) {
         let values = this[kEntries].get(name);
         if (!values) {
@@ -283,8 +289,7 @@ class HttpParams {
             return false;
         const oldSize = this[kSize];
         if (value) {
-            const valueToDelete = Array.isArray(value) ? value : [value];
-            const newValues = oldValues.filter(x => !valueToDelete.includes(x));
+            const newValues = oldValues.filter(x => x === value);
             this[kEntries].set(name, newValues);
             this[kSize] += -oldValues.length + newValues.length;
         }
@@ -295,7 +300,7 @@ class HttpParams {
         return oldSize !== this[kSize];
     }
     _set(name, value, index) {
-        if (value == null) {
+        if (value === undefined) {
             this._delete(name);
             return;
         }
@@ -314,12 +319,6 @@ class HttpParams {
         values[Math.min(index, values.length)] = value;
         this[kSize] += -oldLen + values.length;
     }
-    [(_a = kEntries, _b = kSize, _c = kParamDefs, Symbol.iterator)]() {
-        return this.entries();
-    }
-    get [Symbol.toStringTag]() {
-        return 'HttpParams';
-    }
 }
 exports.HttpParams = HttpParams;
 HttpParams.kEntries = kEntries;

package/esm/document/api-document.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiDocument = void 0;
-const index_js_1 = require("../exception/index.js");
-const index_js_2 = require("../helpers/index.js");
-const index_js_3 = require("../schema/index.js");
-const constants_js_1 = require("./constants.js");
-const complex_type_js_1 = require("./data-type/complex-type.js");
-const simple_type_js_1 = require("./data-type/simple-type.js");
-class ApiDocument {
+import { NotAcceptableError, NotFoundError } from '../exception/index.js';
+import { cloneObject, omitUndefined, ResponsiveMap } from '../helpers/index.js';
+import { OpraSchema } from '../schema/index.js';
+import { NAMESPACE_PATTERN } from './constants.js';
+import { ComplexType } from './data-type/complex-type.js';
+import { SimpleType } from './data-type/simple-type.js';
+export class ApiDocument {
     constructor() {
-        this._typeCache = new index_js_2.ResponsiveMap();
+        this._typeCache = new ResponsiveMap();
         this._typesCacheByCtor = new Map();
-        this.references = new index_js_2.ResponsiveMap();
-        this.types = new index_js_2.ResponsiveMap();
-        this.resources = new index_js_2.ResponsiveMap();
+        this.references = new ResponsiveMap();
+        this.types = new ResponsiveMap();
+        this.resources = new ResponsiveMap();
         this.info = {
             version: '',
             title: ''
@@ -33,19 +30,19 @@ class ApiDocument {
         if (t === null) {
             if (silent)
                 return;
-            throw new index_js_1.NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+            throw new NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
         }
         if (typeof nameOrCtor === 'string') {
-            const m = constants_js_1.NAMESPACE_PATTERN.exec(nameOrCtor);
+            const m = NAMESPACE_PATTERN.exec(nameOrCtor);
             if (!m)
-                throw new index_js_1.NotFoundError(`Invalid data type name "${nameOrCtorName}"`);
+                throw new NotFoundError(`Invalid data type name "${nameOrCtorName}"`);
             // If given string has namespace pattern (ns:type_name)
             if (m[2]) {
                 const ref = this.references.get(m[1]);
                 if (!ref) {
                     if (silent)
                         return;
-                    throw new index_js_1.NotFoundError(`Reference "${m[1]}" not found`);
+                    throw new NotFoundError(`Reference "${m[1]}" not found`);
                 }
                 dataType = ref.getDataType(m[2]);
                 this._typeCache.set(nameOrCtor, dataType);
@@ -70,7 +67,7 @@ class ApiDocument {
         else if (typeof nameOrCtor === 'function') {
             const types = Array.from(this.types.values()).reverse();
             for (const dt of types) {
-                if ((dt instanceof complex_type_js_1.ComplexType || dt instanceof simple_type_js_1.SimpleType) && dt.own.ctor === nameOrCtor) {
+                if ((dt instanceof ComplexType || dt instanceof SimpleType) && dt.own.ctor === nameOrCtor) {
                     dataType = dt;
                     break;
                 }
@@ -86,7 +83,7 @@ class ApiDocument {
             }
         }
         if (dataType) {
-            if ((dataType instanceof complex_type_js_1.ComplexType || dataType instanceof simple_type_js_1.SimpleType) &&
+            if ((dataType instanceof ComplexType || dataType instanceof SimpleType) &&
                 dataType.own?.ctor && dataType.own.ctor !== Object)
                 this._typesCacheByCtor.set(dataType.own.ctor, dataType);
             return dataType;
@@ -99,7 +96,7 @@ class ApiDocument {
         }
         if (silent)
             return;
-        throw new index_js_1.NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+        throw new NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
     }
     getComplexType(nameOrCtor, silent) {
         if (nameOrCtor === Object)
@@ -107,30 +104,30 @@ class ApiDocument {
         const t = this.getDataType(nameOrCtor);
         if (!t && silent)
             return;
-        if (t && t.kind === index_js_3.OpraSchema.ComplexType.Kind)
+        if (t && t.kind === OpraSchema.ComplexType.Kind)
             return t;
-        throw new index_js_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
     }
     getSimpleType(nameOrCtor, silent) {
         const t = this.getDataType(nameOrCtor);
         if (!t && silent)
             return;
-        if (t && t.kind === index_js_3.OpraSchema.SimpleType.Kind)
+        if (t && t.kind === OpraSchema.SimpleType.Kind)
             return t;
-        throw new index_js_1.NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
     }
     getResource(path, silent) {
         let resource;
-        const m = constants_js_1.NAMESPACE_PATTERN.exec(path);
+        const m = NAMESPACE_PATTERN.exec(path);
         if (!m)
-            throw new index_js_1.NotFoundError(`Invalid resource path "${path}"`);
+            throw new NotFoundError(`Invalid resource path "${path}"`);
         // If given string has namespace pattern (ns:type_name)
         if (m[2]) {
             const ref = this.references.get(m[1]);
             if (!ref) {
                 if (silent)
                     return;
-                throw new index_js_1.NotFoundError(`Reference "${m[1]}" not found`);
+                throw new NotFoundError(`Reference "${m[1]}" not found`);
             }
             return ref.getResource(m[2]);
         }
@@ -150,32 +147,32 @@ class ApiDocument {
         }
         if (silent)
             return;
-        throw new index_js_1.NotFoundError(`Resource not found (${path})`);
+        throw new NotFoundError(`Resource not found (${path})`);
     }
     getCollection(path, silent) {
         const t = this.getResource(path);
         if (!t && silent)
             return;
-        if (t && t.kind === index_js_3.OpraSchema.Collection.Kind)
+        if (t && t.kind === OpraSchema.Collection.Kind)
             return t;
-        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
+        throw new NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
     }
     getSingleton(path, silent) {
         const t = this.getResource(path);
         if (!t && silent)
             return;
-        if (t && t.kind === index_js_3.OpraSchema.Singleton.Kind)
+        if (t && t.kind === OpraSchema.Singleton.Kind)
             return t;
-        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
+        throw new NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
     }
     /**
      * Export as Opra schema definition object
      */
     exportSchema() {
         const schema = {
-            version: index_js_3.OpraSchema.SpecVersion,
+            version: OpraSchema.SpecVersion,
             url: this.url,
-            info: (0, index_js_2.cloneObject)(this.info)
+            info: cloneObject(this.info)
         };
         if (this.references.size) {
             const references = {};
@@ -201,11 +198,10 @@ class ApiDocument {
                 types[name] = r.exportSchema();
             }
         }
-        return (0, index_js_2.omitUndefined)(schema);
+        return omitUndefined(schema);
     }
     invalidate() {
         this._typeCache.clear();
         this._typesCacheByCtor.clear();
     }
 }
-exports.ApiDocument = ApiDocument;

package/esm/document/constants.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TYPENAME_PATTERN = exports.NAMESPACE_PATTERN = exports.METADATA_KEY = void 0;
-exports.METADATA_KEY = Symbol.for('opra.metadata');
-exports.NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
-exports.TYPENAME_PATTERN = /^(.*)Type$/;
+export const METADATA_KEY = Symbol.for('opra.metadata');
+export const NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
+export const TYPENAME_PATTERN = /^(.*)Type$/;

package/esm/document/data-type/api-field.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiField = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const constants_js_1 = require("../constants.js");
-const enum_type_js_1 = require("./enum-type.js");
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { METADATA_KEY } from '../constants.js';
+import { EnumType } from './enum-type.js';
 /**
  * @class ComplexType
  */
-exports.ApiField = function (...args) {
+export const ApiField = function (...args) {
     // ClassDecorator
     if (!this) {
         const [options] = args;
         return function (target, propertyKey) {
             if (typeof propertyKey !== 'string')
                 throw new TypeError(`Symbol properties can't be used as a field`);
-            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target.constructor) || {};
-            metadata.kind = index_js_2.OpraSchema.ComplexType.Kind;
+            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
+            metadata.kind = OpraSchema.ComplexType.Kind;
             metadata.fields = metadata.fields || {};
             const designType = Reflect.getMetadata('design:type', target, propertyKey);
             const isArray = designType === Array;
@@ -34,17 +31,17 @@ exports.ApiField = function (...args) {
                         o[v] = v;
                         return o;
                     }, {});
-                    (0, enum_type_js_1.EnumType)(enumObj);
+                    EnumType(enumObj);
                     elemMeta.enum = enumObj;
                 }
                 else {
-                    const m = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, options?.enum);
-                    if (!index_js_2.OpraSchema.isEnumType(m))
+                    const m = Reflect.getOwnMetadata(METADATA_KEY, options?.enum);
+                    if (!OpraSchema.isEnumType(m))
                         throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
                     elemMeta.enum = options.enum;
                 }
             }
-            Reflect.defineMetadata(constants_js_1.METADATA_KEY, (0, index_js_1.omitUndefined)(metadata), target.constructor);
+            Reflect.defineMetadata(METADATA_KEY, omitUndefined(metadata), target.constructor);
         };
     }
     // Constructor
@@ -79,4 +76,4 @@ const proto = {
         return out;
     }
 };
-Object.assign(exports.ApiField.prototype, proto);
+Object.assign(ApiField.prototype, proto);

package/esm/document/data-type/builtin/any.type.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnyType = void 0;
-const tslib_1 = require("tslib");
-const simple_type_js_1 = require("../simple-type.js");
+import { __decorate } from "tslib";
+import { SimpleType } from '../simple-type.js';
 let AnyType = class AnyType {
 };
-AnyType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
+AnyType = __decorate([
+    SimpleType({
         description: 'Any value',
         ctor: Object
     })
 ], AnyType);
-exports.AnyType = AnyType;
+export { AnyType };

package/esm/document/data-type/builtin/base64.type.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Base64Type = void 0;
-const tslib_1 = require("tslib");
-const simple_type_js_1 = require("../simple-type.js");
+import { __decorate } from "tslib";
+import { SimpleType } from '../simple-type.js';
 const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:(?:[A-Za-z0-9+/][AQgw](:?==)?)|(?:[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=?))?$/;
 let Base64Type = class Base64Type {
     decode(v) {
@@ -29,10 +26,10 @@ let Base64Type = class Base64Type {
             throw new TypeError(`Invalid base64 value "${String(v).substring(0, 10)}..."`);
     }
 };
-Base64Type = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
+Base64Type = __decorate([
+    SimpleType({
         description: 'A stream of bytes, base64 encoded',
         ctor: ArrayBuffer
     })
 ], Base64Type);
-exports.Base64Type = Base64Type;
+export { Base64Type };

package/esm/document/data-type/builtin/bigint.type.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigIntType = void 0;
-const tslib_1 = require("tslib");
-const simple_type_js_1 = require("../simple-type.js");
+import { __decorate } from "tslib";
+import { SimpleType } from '../simple-type.js';
 const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
 let BigIntType = class BigIntType {
     decode(v) {
@@ -23,11 +20,11 @@ let BigIntType = class BigIntType {
             throw new TypeError(`Invalid number value "${v}"`);
     }
 };
-BigIntType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
+BigIntType = __decorate([
+    SimpleType({
         name: 'bigint',
         description: 'BigInt number',
         ctor: BigIntConstructor
     })
 ], BigIntType);
-exports.BigIntType = BigIntType;
+export { BigIntType };

package/esm/document/data-type/builtin/boolean.type.js

@@ -1,28 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BooleanType = void 0;
-const tslib_1 = require("tslib");
-const putil_varhelpers_1 = require("putil-varhelpers");
-const simple_type_js_1 = require("../simple-type.js");
+import { __decorate } from "tslib";
+import { toBoolean } from 'putil-varhelpers';
+import { SimpleType } from '../simple-type.js';
 let BooleanType = class BooleanType {
     decode(v) {
         if (v == null)
             return v;
-        return (0, putil_varhelpers_1.toBoolean)(v);
+        return toBoolean(v);
     }
     encode(v) {
         if (v == null)
             return v;
-        return (0, putil_varhelpers_1.toBoolean)(v);
+        return toBoolean(v);
     }
     coerce(v) {
         return this.decode(v);
     }
 };
-BooleanType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
+BooleanType = __decorate([
+    SimpleType({
         description: 'Simple true/false value',
         ctor: Boolean
     })
 ], BooleanType);
-exports.BooleanType = BooleanType;
+export { BooleanType };