@opra/common 0.24.2 → 0.25.0

package/esm/document/data-type/complex-type-class.js

@@ -0,0 +1,147 @@
+import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
+import { translate } from '../../i18n/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataType } from './data-type.js';
+import { ApiField } from './field.js';
+/**
+ * @class ComplexType
+ */
+export class ComplexTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.ComplexType.Kind;
+        const own = this.own = {};
+        own.ctor = init?.ctor || init?.base?.ctor;
+        own.abstract = init?.abstract;
+        own.additionalFields = init?.additionalFields;
+        own.fields = new ResponsiveMap();
+        this.kind = OpraSchema.ComplexType.Kind;
+        this.base = init?.base;
+        this.ctor = own.ctor || Object;
+        this.abstract = own.abstract;
+        this.additionalFields = own.additionalFields;
+        this.fields = new ResponsiveMap();
+        if (this.base) {
+            if (this.additionalFields == null)
+                this.additionalFields = this.base.additionalFields;
+            if (this.base.fields)
+                for (const [k, el] of this.base.fields.entries()) {
+                    const newEl = new ApiField(this, el);
+                    this.fields.set(k, newEl);
+                }
+        }
+    }
+    addField(init) {
+        const field = new ApiField(this, init);
+        this.own.fields.set(field.name, field);
+        this.fields.set(field.name, field);
+        return field;
+    }
+    findField(nameOrPath) {
+        let field;
+        if (nameOrPath.includes('.')) {
+            for (const [, f] of this.iteratePath(nameOrPath, true)) {
+                if (!f)
+                    return;
+                field = f;
+            }
+            return field;
+        }
+        return this.fields.get(nameOrPath);
+    }
+    getField(nameOrPath) {
+        let field;
+        if (nameOrPath.includes('.')) {
+            for (const [, f] of this.iteratePath(nameOrPath)) {
+                field = f;
+            }
+        }
+        else
+            field = this.fields.get(nameOrPath);
+        if (!field)
+            throw new Error(translate('error:UNKNOWN_FIELD', { field: 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;
+        const ComplexType = Object.getPrototypeOf(this).constructor;
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                i++;
+                if (i < len) {
+                    s = arr[i];
+                    if (dataType && !(dataType instanceof 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(translate('error:UNKNOWN_FIELD', { field: curPath }));
+                        }
+                    }
+                }
+                return {
+                    done: i >= len,
+                    value: [field?.name || s, field, curPath]
+                };
+            }
+        };
+    }
+    normalizeFieldPath(fieldPaths) {
+        const array = (Array.isArray(fieldPaths) ? fieldPaths : [fieldPaths])
+            .map(s => {
+            let curPath = '';
+            for (const [, , p] of this.iteratePath(s)) {
+                curPath = p;
+            }
+            return curPath;
+        }).flat();
+        return array.length ? array : undefined;
+    }
+    exportSchema() {
+        const out = super.exportSchema();
+        Object.assign(out, omitUndefined({
+            base: this.base ?
+                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
+            abstract: this.own.abstract,
+            additionalFields: this.own.additionalFields
+        }));
+        if (this.own.fields.size) {
+            const fields = out.fields = {};
+            for (const field of this.own.fields.values()) {
+                fields[field.name] = field.exportSchema();
+            }
+        }
+        return omitUndefined(out);
+    }
+    isTypeOf(t) {
+        return t === this.own.ctor;
+    }
+    extendsFrom(t) {
+        const base = t instanceof DataType ? t : this.document.getDataType(t);
+        if (this.base) {
+            if (this.base === base)
+                return true;
+            return this.base.extendsFrom(base);
+        }
+        return false;
+    }
+}

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

@@ -1,177 +1,22 @@
 import 'reflect-metadata';
-import omit from 'lodash.omit';
 import merge from 'putil-merge';
-import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
-import { translate } from '../../i18n/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA, TYPENAME_PATTERN } from '../constants.js';
-import { ApiField } from './api-field.js';
-import { DataType } from './data-type.js';
-/**
- * @class ComplexType
- */
-class ComplexTypeClass extends DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.ComplexType.Kind;
-        const own = this.own = {};
-        own.ctor = init?.ctor || init?.base?.ctor;
-        own.abstract = init?.abstract;
-        own.additionalFields = init?.additionalFields;
-        own.fields = new ResponsiveMap();
-        this.kind = OpraSchema.ComplexType.Kind;
-        this.base = init?.base;
-        this.ctor = own.ctor || Object;
-        this.abstract = own.abstract;
-        this.additionalFields = own.additionalFields;
-        this.fields = new ResponsiveMap();
-        if (this.base) {
-            if (this.additionalFields == null)
-                this.additionalFields = this.base.additionalFields;
-            if (this.base.fields)
-                for (const [k, el] of this.base.fields.entries()) {
-                    const newEl = new ApiField(this, el);
-                    this.fields.set(k, newEl);
-                }
-        }
-    }
-    addField(init) {
-        const field = new ApiField(this, init);
-        this.own.fields.set(field.name, field);
-        this.fields.set(field.name, field);
-        return field;
-    }
-    findField(nameOrPath) {
-        let field;
-        if (nameOrPath.includes('.')) {
-            for (const [, f] of this.iteratePath(nameOrPath, true)) {
-                if (!f)
-                    return;
-                field = f;
-            }
-            return field;
-        }
-        return this.fields.get(nameOrPath);
-    }
-    getField(nameOrPath) {
-        let field;
-        if (nameOrPath.includes('.')) {
-            for (const [, f] of this.iteratePath(nameOrPath)) {
-                field = f;
-            }
-        }
-        else
-            field = this.fields.get(nameOrPath);
-        if (!field)
-            throw new Error(translate('error:UNKNOWN_FIELD', { field: 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 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(translate('error:UNKNOWN_FIELD', { field: curPath }));
-                        }
-                    }
-                }
-                return {
-                    done: i >= len,
-                    value: [field?.name || s, field, curPath]
-                };
-            }
-        };
-    }
-    normalizeFieldPath(fieldPaths) {
-        const array = (Array.isArray(fieldPaths) ? fieldPaths : [fieldPaths])
-            .map(s => {
-            let curPath = '';
-            for (const [, , p] of this.iteratePath(s)) {
-                curPath = p;
-            }
-            return curPath;
-        }).flat();
-        return array.length ? array : undefined;
-    }
-    exportSchema() {
-        const out = super.exportSchema();
-        Object.assign(out, omitUndefined({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            abstract: this.own.abstract,
-            additionalFields: this.own.additionalFields
-        }));
-        if (this.own.fields.size) {
-            const fields = out.fields = {};
-            for (const field of this.own.fields.values()) {
-                fields[field.name] = field.exportSchema();
-            }
-        }
-        return omitUndefined(out);
-    }
-    isTypeOf(t) {
-        return t === this.own.ctor;
-    }
-    extendsFrom(t) {
-        const base = t instanceof DataType ? t : this.document.getDataType(t);
-        if (this.base) {
-            if (this.base === base)
-                return true;
-            return this.base.extendsFrom(base);
-        }
-        return false;
-    }
-}
+import { DECORATOR } from '../constants.js';
+import { ComplexTypeDecorator } from '../decorators/complex-type.decorator.js';
+import { ComplexTypeClass } from './complex-type-class.js';
 /**
  * @class ComplexType
+ * @decorator ComplexType
  */
 export const ComplexType = function (...args) {
-    // Constructor
-    if (this) {
-        const [document, init] = args;
-        merge(this, new ComplexTypeClass(document, init), { descriptor: true });
-        return;
+    // Decorator
+    if (!this) {
+        const [options] = args;
+        return ComplexType[DECORATOR](options);
     }
-    // ClassDecorator
-    const [options] = args;
-    return function (target) {
-        const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-        let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
-        if (!metadata) {
-            metadata = {};
-            Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
-        }
-        metadata.kind = OpraSchema.ComplexType.Kind;
-        metadata.name = name;
-        // Merge options
-        if (options)
-            Object.assign(metadata, omit(options, ['kind', 'name', 'base', 'fields']));
-    };
+    // Constructor
+    const [document, init] = args;
+    merge(this, new ComplexTypeClass(document, init), { descriptor: true });
 };
 ComplexType.prototype = ComplexTypeClass.prototype;
+Object.assign(ComplexType, ComplexTypeDecorator);
+ComplexType[DECORATOR] = ComplexTypeDecorator;

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

@@ -1,5 +1,9 @@
 import { omitUndefined } from '../../helpers/index.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
+/**
+ * @class DataType
+ * @abstract
+ */
 export class DataType {
     constructor(document, init) {
         this.document = document;

package/esm/document/data-type/enum-type-class.js

@@ -0,0 +1,27 @@
+import * as vg from 'valgen';
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataType } from './data-type.js';
+export class EnumTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.EnumType.Kind;
+        this.base = init.base;
+        this.ownValues = init.values;
+        this.ownMeanings = init.meanings || {};
+        this.values = { ...this.base?.values, ...this.ownValues };
+        this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
+        this.decode = vg.isEnum(Object.values(this.values));
+        this.encode = vg.isEnum(Object.values(this.values));
+    }
+    exportSchema() {
+        const out = DataType.prototype.exportSchema.call(this);
+        Object.assign(out, omitUndefined({
+            base: this.base ?
+                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
+            values: this.ownValues,
+            meanings: this.ownMeanings
+        }));
+        return out;
+    }
+}

package/esm/document/data-type/enum-type.js

@@ -1,59 +1,34 @@
 import 'reflect-metadata';
 import omit from 'lodash.omit';
 import merge from 'putil-merge';
-import * as vg from 'valgen';
-import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
-import { DataType } from './data-type.js';
-class EnumTypeClass extends DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.EnumType.Kind;
-        this.base = init.base;
-        this.ownValues = init.values;
-        this.ownMeanings = init.meanings || {};
-        this.values = { ...this.base?.values, ...this.ownValues };
-        this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
-        this.decode = vg.isEnum(Object.values(this.values));
-        this.encode = vg.isEnum(Object.values(this.values));
-    }
-    exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            values: this.ownValues,
-            meanings: this.ownMeanings
-        }));
-        return out;
-    }
-}
+import { EnumTypeClass } from './enum-type-class.js';
 /**
  * @class EnumType
  */
 export const EnumType = function (...args) {
-    if (this) {
-        // Constructor
-        const [document, init] = args;
-        merge(this, new EnumTypeClass(document, init), { descriptor: true });
-        return;
-    }
     // Injector
-    const [enumSource, options] = args;
-    const values = Array.isArray(enumSource)
-        ? enumSource.reduce((obj, v) => {
-            obj[v] = v;
-            return obj;
-        }, {})
-        : enumSource;
-    const metadata = {
-        kind: OpraSchema.EnumType.Kind,
-        values
-    };
-    if (options)
-        Object.assign(metadata, omit(options, ['kind', 'values']));
-    Reflect.defineMetadata(DATATYPE_METADATA, metadata, enumSource);
-    return values;
+    if (!this) {
+        const [enumSource, options] = args;
+        const values = Array.isArray(enumSource)
+            ? enumSource.reduce((obj, v) => {
+                obj[v] = v;
+                return obj;
+            }, {})
+            : enumSource;
+        const metadata = {
+            kind: OpraSchema.EnumType.Kind,
+            values
+        };
+        if (options)
+            Object.assign(metadata, omit(options, ['kind', 'values']));
+        Reflect.defineMetadata(DATATYPE_METADATA, metadata, enumSource);
+        return values;
+    }
+    // Constructor
+    const [document, init] = args;
+    merge(this, new EnumTypeClass(document, init), { descriptor: true });
+    return;
 };
 EnumType.prototype = EnumTypeClass.prototype;

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

@@ -0,0 +1,30 @@
+import { omitUndefined } from '../../helpers/index.js';
+export class FieldClass {
+    constructor(owner, init) {
+        this.owner = owner;
+        this.name = init.name;
+        this.origin = init.origin || owner;
+        this.type = init.type;
+        this.description = init.description;
+        this.isArray = init.isArray;
+        this.default = init.default;
+        this.fixed = init.fixed;
+        this.required = init.required;
+        this.exclusive = init.exclusive;
+        this.deprecated = init.deprecated;
+        this.examples = init.examples;
+    }
+    exportSchema() {
+        return omitUndefined({
+            type: this.type.name ? this.type.name : this.type.exportSchema(),
+            description: this.description,
+            isArray: this.isArray,
+            default: this.default,
+            fixed: this.fixed,
+            required: this.required,
+            exclusive: this.exclusive,
+            deprecated: this.deprecated,
+            examples: this.examples
+        });
+    }
+}

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

@@ -0,0 +1,41 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { EnumType } from './enum-type.js';
+export function FieldDecorator(options) {
+    return function (target, propertyKey) {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can't be used as a field`);
+        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
+        metadata.kind = OpraSchema.ComplexType.Kind;
+        metadata.fields = metadata.fields || {};
+        const designType = Reflect.getMetadata('design:type', target, propertyKey);
+        const elemMeta = metadata.fields[propertyKey] = {
+            ...options,
+            enum: undefined,
+            designType
+        };
+        if (designType === Array) {
+            elemMeta.isArray = true;
+            delete elemMeta.designType;
+        }
+        if (options?.enum) {
+            elemMeta.type = undefined;
+            if (Array.isArray(options.enum)) {
+                const enumObj = options.enum.reduce((o, v) => {
+                    o[v] = v;
+                    return o;
+                }, {});
+                EnumType(enumObj);
+                elemMeta.enum = enumObj;
+            }
+            else {
+                const m = Reflect.getOwnMetadata(DATATYPE_METADATA, 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(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
+    };
+}

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

@@ -0,0 +1,21 @@
+import merge from 'putil-merge';
+import { DECORATOR } from '../constants.js';
+import { FieldClass } from './field-class.js';
+import { FieldDecorator } from './field-decorator.js';
+/**
+ * @class ApiField
+ * @decorator ApiField
+ */
+export const ApiField = function (...args) {
+    // Decorator
+    if (!this) {
+        const [options] = args;
+        return ApiField[DECORATOR](options);
+    }
+    // Constructor
+    const [owner, init] = args;
+    merge(this, new FieldClass(owner, init), { descriptor: true });
+};
+ApiField.prototype = FieldClass.prototype;
+Object.assign(ApiField, FieldDecorator);
+ApiField[DECORATOR] = FieldDecorator;

package/esm/document/data-type/mapped-type-class.js

@@ -0,0 +1,43 @@
+import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataType } from './data-type.js';
+export class MappedTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.MappedType.Kind;
+        const own = this.own;
+        own.pick = init.pick;
+        own.omit = init.omit;
+        this.kind = OpraSchema.MappedType.Kind;
+        this.type = init.type;
+        this.pick = own.pick;
+        this.omit = own.omit;
+        this.fields = new ResponsiveMap();
+        this.additionalFields = this.type.additionalFields;
+        const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
+        for (const [elemName, elem] of this.type.fields.entries()) {
+            if (isInheritedPredicate(elemName))
+                this.fields.set(elemName, elem);
+        }
+    }
+    exportSchema() {
+        const out = DataType.prototype.exportSchema.call(this);
+        Object.assign(out, omitUndefined({
+            type: this.type.name ? this.type.name : this.type.exportSchema(),
+            pick: this.own.pick,
+            omit: this.own.omit,
+        }));
+        return out;
+    }
+}
+export function getIsInheritedPredicateFn(pick, omit) {
+    const pickKeys = pick?.map(x => String(x).toLowerCase());
+    const omitKeys = omit?.map(x => String(x).toLowerCase());
+    return (propertyName) => {
+        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
+            return false;
+        if (pickKeys)
+            return pickKeys.includes(propertyName.toLowerCase());
+        return true;
+    };
+}

package/esm/document/data-type/mapped-type.js

@@ -1,37 +1,20 @@
 import 'reflect-metadata';
 import merge from 'putil-merge';
-import { inheritPropertyInitializers, mergePrototype, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
+import { inheritPropertyInitializers, mergePrototype } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
-import { DataType } from './data-type.js';
-class MappedTypeClass extends DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.MappedType.Kind;
-        const own = this.own;
-        own.pick = init.pick;
-        own.omit = init.omit;
-        this.kind = OpraSchema.MappedType.Kind;
-        this.type = init.type;
-        this.pick = own.pick;
-        this.omit = own.omit;
-        this.fields = new ResponsiveMap();
-        this.additionalFields = this.type.additionalFields;
-        const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
-        for (const [elemName, elem] of this.type.fields.entries()) {
-            if (isInheritedPredicate(elemName))
-                this.fields.set(elemName, elem);
-        }
-    }
-    exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
-            type: this.type.name ? this.type.name : this.type.exportSchema(),
-            pick: this.own.pick,
-            omit: this.own.omit,
-        }));
-        return out;
-    }
+import { getIsInheritedPredicateFn, MappedTypeClass } from './mapped-type-class.js';
+/**
+ *
+ */
+export function PickType(classRef, keys) {
+    return MappedType(classRef, { pick: keys });
+}
+/**
+ *
+ */
+export function OmitType(classRef, keys) {
+    return MappedType(classRef, { omit: keys });
 }
 /**
  * @class MappedType
@@ -75,26 +58,3 @@ export const MappedType = function (...args) {
 };
 MappedType.prototype = MappedTypeClass.prototype;
 MappedType._applyMixin = () => void 0;
-function getIsInheritedPredicateFn(pick, omit) {
-    const pickKeys = pick?.map(x => String(x).toLowerCase());
-    const omitKeys = omit?.map(x => String(x).toLowerCase());
-    return (propertyName) => {
-        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
-            return false;
-        if (pickKeys)
-            return pickKeys.includes(propertyName.toLowerCase());
-        return true;
-    };
-}
-/**
- *
- */
-export function PickType(classRef, keys) {
-    return MappedType(classRef, { pick: keys });
-}
-/**
- *
- */
-export function OmitType(classRef, keys) {
-    return MappedType(classRef, { omit: keys });
-}