@opra/common 1.4.4 → 1.5.1

package/esm/document/common/document-node.js

@@ -18,25 +18,23 @@ export class DocumentNode {
         // istanbul ignore next
         throw new Error('ApiDocument not found in document tree');
     }
-    hasDataType(nameOrCtor) {
-        const result = this[kDataTypeMap]?.has(nameOrCtor);
-        if (result)
-            return result;
-        return this.parent ? this.parent.hasDataType(nameOrCtor) : false;
+    hasDataType(nameOrCtor, scope) {
+        return !!this.findDataType(nameOrCtor, scope);
     }
-    findDataType(nameOrCtor) {
-        const result = this[kDataTypeMap]?.get(nameOrCtor);
-        if (result)
-            return result;
-        return this.parent ? this.parent.findDataType(nameOrCtor) : undefined;
+    findDataType(nameOrCtor, scope) {
+        const dt = this[kDataTypeMap]?.get(nameOrCtor);
+        if (dt && (!scope || dt.inScope(scope)))
+            return dt;
+        return this.parent
+            ? this.parent.findDataType(nameOrCtor, scope)
+            : undefined;
     }
     /**
      * Returns DataType instance by name or Constructor. Returns undefined if not found
-     * @param nameOrCtor
      */
-    getDataType(nameOrCtor) {
+    getDataType(nameOrCtor, scope) {
         const dt = this.findDataType(nameOrCtor);
-        if (dt)
+        if (dt && (!scope || dt.inScope(scope)))
             return dt;
         let name = '';
         if (typeof nameOrCtor === 'function') {
@@ -53,7 +51,9 @@ export class DocumentNode {
             else if (typeof nameOrCtor === 'function')
                 name = nameOrCtor.name;
         }
-        throw new TypeError(`Unknown data type` + (name ? ' (' + name + ')' : ''));
+        if (dt)
+            throw new TypeError(`Data type${name ? ' (' + name + ')' : ''} is not in requested scope (${scope})`);
+        throw new TypeError(`Unknown data type${name ? ' (' + name + ')' : ''}`);
     }
     getDataTypeNameWithNs(dataType) {
         if (!dataType.name)
@@ -65,10 +65,9 @@ export class DocumentNode {
      * Returns ComplexType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a ComplexType
-     * @param nameOrCtor
      */
-    getComplexType(nameOrCtor) {
-        const t = this.getDataType(nameOrCtor);
+    getComplexType(nameOrCtor, scope) {
+        const t = this.getDataType(nameOrCtor, scope);
         if (t.kind === OpraSchema.ComplexType.Kind)
             return t;
         throw new TypeError(`Data type "${t.name}" is not a ComplexType`);
@@ -77,10 +76,9 @@ export class DocumentNode {
      * Returns SimpleType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a SimpleType
-     * @param nameOrCtor
      */
-    getSimpleType(nameOrCtor) {
-        const t = this.getDataType(nameOrCtor);
+    getSimpleType(nameOrCtor, scope) {
+        const t = this.getDataType(nameOrCtor, scope);
         if (t.kind === OpraSchema.SimpleType.Kind)
             return t;
         throw new TypeError(`Data type "${t.name || t}" is not a SimpleType`);
@@ -89,10 +87,9 @@ export class DocumentNode {
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a EnumType
-     * @param nameOrCtor
      */
-    getEnumType(nameOrCtor) {
-        const t = this.getDataType(nameOrCtor);
+    getEnumType(nameOrCtor, scope) {
+        const t = this.getDataType(nameOrCtor, scope);
         if (t.kind === OpraSchema.EnumType.Kind)
             return t;
         throw new TypeError(`Data type "${t.name || t}" is not a EnumType`);
@@ -101,10 +98,9 @@ export class DocumentNode {
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a MappedType
-     * @param nameOrCtor
      */
-    getMappedType(nameOrCtor) {
-        const t = this.getDataType(nameOrCtor);
+    getMappedType(nameOrCtor, scope) {
+        const t = this.getDataType(nameOrCtor, scope);
         if (t.kind === OpraSchema.MappedType.Kind)
             return t;
         throw new TypeError(`Data type "${t.name || t}" is not a MappedType`);
@@ -113,10 +109,9 @@ export class DocumentNode {
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a MixinType
-     * @param nameOrCtor
      */
-    getMixinType(nameOrCtor) {
-        const t = this.getDataType(nameOrCtor);
+    getMixinType(nameOrCtor, scope) {
+        const t = this.getDataType(nameOrCtor, scope);
         if (t.kind === OpraSchema.MixinType.Kind)
             return t;
         throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);

package/esm/document/common/value.js

@@ -17,12 +17,16 @@ export const Value = function (owner, initArgs) {
  * @class Value
  */
 class ValueClass extends DocumentElement {
-    toJSON() {
+    toJSON(options) {
         const typeName = this.type
             ? this.node.getDataTypeNameWithNs(this.type)
             : undefined;
         return omitUndefined({
-            type: this.type ? (typeName ? typeName : this.type.toJSON()) : 'any',
+            type: this.type
+                ? typeName
+                    ? typeName
+                    : this.type.toJSON(options)
+                : 'any',
             description: this.description,
             isArray: this.isArray,
             examples: this.examples,

package/esm/document/constants.js

@@ -7,7 +7,6 @@ export const DECORATOR = Symbol.for('DECORATOR');
 export const BUILTIN = Symbol.for('BUILTIN');
 export const NAMESPACE_PATTERN = /([a-z$_]\w+):(.+)/i;
 export const CLASS_NAME_PATTERN = /^[a-z][\w_]*$/i;
-export const EXTRACT_TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
 export const kDataTypeMap = Symbol.for('kDataTypeMap');
 export const kCtorMap = Symbol.for('kCtorMap');
 export const kTypeNSMap = Symbol.for('kTypeNSMap');

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

@@ -2,10 +2,10 @@ import { omitUndefined } from '@jsopen/objects';
 import { asMutable } from 'ts-gems';
 import { DocumentElement } from '../common/document-element.js';
 import { DECORATOR } from '../constants.js';
-import { ApiFieldDecorator } from '../decorators/api-field-decorator.js';
+import { ApiFieldDecoratorFactory } from '../decorators/api-field-decorator.js';
+import { testScopeMatch } from '../utils/test-scope-match.js';
 import { ComplexTypeBase } from './complex-type-base.js';
 /**
- * @constructor ApiField
  * @decorator ApiField
  */
 export const ApiField = function (...args) {
@@ -25,6 +25,7 @@ export const ApiField = function (...args) {
         throw new Error('Field origin should be one of ComplexType, MappedType or MixinType');
     }
     _this.origin = origin;
+    _this.scopePattern = initArgs.scopePattern;
     _this.type = initArgs.type || owner.node.getDataType('any');
     _this.description = initArgs.description;
     _this.isArray = initArgs.isArray;
@@ -38,19 +39,22 @@ export const ApiField = function (...args) {
     _this.readonly = initArgs.readonly;
     _this.writeonly = initArgs.writeonly;
     _this.examples = initArgs.examples;
-    _this.hidden = initArgs.hidden;
 };
 /**
- *
- * @class ApiField
+ * The ApiFieldClass represents a descriptive metadata structure for API fields,
+ * supporting features like data type definition, scoping, localization, and constraints.
+ * This class extends DocumentElement, inheriting base document structure capabilities.
  */
 class ApiFieldClass extends DocumentElement {
-    toJSON() {
+    inScope(scope) {
+        return testScopeMatch(scope, this.scopePattern);
+    }
+    toJSON(options) {
         const typeName = this.type
             ? this.node.getDataTypeNameWithNs(this.type)
             : undefined;
         return omitUndefined({
-            type: typeName ? typeName : this.type?.toJSON(),
+            type: typeName ? typeName : this.type?.toJSON(options),
             description: this.description,
             isArray: this.isArray || undefined,
             default: this.default,
@@ -67,5 +71,5 @@ class ApiFieldClass extends DocumentElement {
     }
 }
 ApiField.prototype = ApiFieldClass.prototype;
-Object.assign(ApiField, ApiFieldDecorator);
-ApiField[DECORATOR] = ApiFieldDecorator;
+Object.assign(ApiField, ApiFieldDecoratorFactory);
+ApiField[DECORATOR] = ApiFieldDecoratorFactory;

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

@@ -1,7 +1,6 @@
 import { asMutable } from 'ts-gems';
 import { validator, vg } from 'valgen';
 import { parseFieldsProjection, ResponsiveMap, } from '../../helpers/index.js';
-import { translate } from '../../i18n/index.js';
 import { DataType } from './data-type.js';
 export const FIELD_PATH_PATTERN = /^([+-])?([a-z$_][\w.]*)$/i;
 /**
@@ -24,21 +23,29 @@ class ComplexTypeBaseClass extends DataType {
     /**
      *
      */
-    findField(nameOrPath) {
+    findField(nameOrPath, scope) {
         if (nameOrPath.includes('.')) {
-            const fieldPath = this.parseFieldPath(nameOrPath);
+            const fieldPath = this.parseFieldPath(nameOrPath, { scope });
+            if (fieldPath.length === 0)
+                throw new Error(`Field "${nameOrPath}" does not exist in scope "${scope}"`);
             const lastItem = fieldPath.pop();
             return lastItem?.field;
         }
-        return this.fields.get(nameOrPath);
+        const field = this.fields.get(nameOrPath);
+        if (field && scope && !field.inScope(scope))
+            return;
+        return field;
     }
     /**
      *
      */
-    getField(nameOrPath) {
+    getField(nameOrPath, scope) {
         const field = this.findField(nameOrPath);
-        if (!field)
-            throw new Error(translate('error:UNKNOWN_FIELD', { field: nameOrPath }));
+        if (field && scope && !field.inScope(scope))
+            throw new Error(`Field "${nameOrPath}" does not exist in scope "${scope}"`);
+        if (!field) {
+            throw new Error(`Field (${nameOrPath}) does not exist`);
+        }
         return field;
     }
     /**
@@ -69,7 +76,7 @@ class ComplexTypeBaseClass extends DataType {
             }
             if (dataType) {
                 if (dataType instanceof ComplexTypeBase) {
-                    field = dataType.fields.get(item.fieldName);
+                    field = dataType.getField(item.fieldName, options?.scope);
                     if (field) {
                         item.fieldName = field.name;
                         item.field = field;
@@ -149,9 +156,13 @@ class ComplexTypeBaseClass extends DataType {
         // Process fields
         let fieldName;
         for (const field of this.fields.values()) {
-            if ((context.ignoreReadonlyFields && field.readonly) ||
-                (context.ignoreWriteonlyFields && field.writeonly) ||
-                (context.ignoreHiddenFields && field.hidden)) {
+            if (
+            /** Ignore field if required scope(s) do not match field scopes */
+            (context.scope && !field.inScope(context.scope)) ||
+                /** Ignore field if readonly and ignoreReadonlyFields option true */
+                (context.ignoreReadonlyFields && field.readonly) ||
+                /** Ignore field if writeonly and ignoreWriteonlyFields option true */
+                (context.ignoreWriteonlyFields && field.writeonly)) {
                 schema[field.name] = vg.isUndefined({ coerce: true });
                 continue;
             }

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

@@ -68,21 +68,26 @@ class ComplexTypeClass extends ComplexTypeBase {
             return true;
         return !!this.base?.extendsFrom(baseType);
     }
-    toJSON() {
+    toJSON(options) {
+        const superJson = super.toJSON(options);
         const baseName = this.base
             ? this.node.getDataTypeNameWithNs(this.base)
             : undefined;
-        const out = omitUndefined({
-            ...ComplexTypeBase.prototype.toJSON.call(this),
+        const out = {
+            ...superJson,
             kind: this.kind,
-            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
-        });
+            base: this.base
+                ? baseName
+                    ? baseName
+                    : this.base.toJSON(options)
+                : undefined,
+        };
         if (this.additionalFields) {
             if (this.additionalFields instanceof DataType) {
                 const typeName = this.node.getDataTypeNameWithNs(this.additionalFields);
                 out.additionalFields = typeName
                     ? typeName
-                    : this.additionalFields.toJSON();
+                    : this.additionalFields.toJSON(options);
             }
             else
                 out.additionalFields = this.additionalFields;
@@ -91,8 +96,9 @@ class ComplexTypeClass extends ComplexTypeBase {
             const fields = {};
             let i = 0;
             for (const field of this.fields.values()) {
-                if (field.origin === this) {
-                    fields[field.name] = field.toJSON();
+                if (field.origin === this &&
+                    (!options?.scope || field.inScope(options?.scope))) {
+                    fields[field.name] = field.toJSON(options);
                     i++;
                 }
             }
@@ -101,6 +107,14 @@ class ComplexTypeClass extends ComplexTypeBase {
         }
         return omitUndefined(out);
     }
+    _locateBase(callback) {
+        if (!this.base)
+            return;
+        if (callback(this.base))
+            return this.base;
+        if (this.base._locateBase)
+            return this.base._locateBase(callback);
+    }
 }
 ComplexType.prototype = ComplexTypeClass.prototype;
 Object.assign(ComplexType, ComplexTypeDecorator);

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

@@ -3,6 +3,7 @@ import { asMutable } from 'ts-gems';
 import { DocumentElement } from '../common/document-element.js';
 import { CLASS_NAME_PATTERN } from '../constants.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom, } from '../utils/inspect.util.js';
+import { testScopeMatch } from '../utils/test-scope-match.js';
 /**
  * DataType constructor
  */
@@ -17,6 +18,7 @@ context) {
     DocumentElement.call(this, owner);
     const _this = asMutable(this);
     _this.kind = initArgs.kind;
+    _this.scopePattern = initArgs.scopePattern;
     _this.name = initArgs.name;
     _this.description = initArgs.description;
     _this.abstract = initArgs.abstract;
@@ -30,7 +32,18 @@ class DataTypeClass extends DocumentElement {
     get embedded() {
         return !this.name;
     }
-    toJSON() {
+    inScope(scope) {
+        return testScopeMatch(scope, this.scopePattern);
+    }
+    toJSON(options) {
+        if (options?.scope) {
+            /** Locate base model which is not available for given scope */
+            const outOfScope = this._locateBase(dt => !dt.inScope(options.scope));
+            if (outOfScope) {
+                const baseName = this.node.getDataTypeNameWithNs(outOfScope);
+                throw new TypeError(`"${baseName}" model is not available for "${options.scope}" scope`);
+            }
+        }
         return omitUndefined({
             kind: this.kind,
             description: this.description,

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

@@ -48,16 +48,26 @@ class EnumTypeClass extends DataType {
     generateCodec() {
         return vg.isEnum(Object.keys(this.attributes));
     }
-    toJSON() {
+    toJSON(options) {
+        const superJson = super.toJSON(options);
         const baseName = this.base
             ? this.node.getDataTypeNameWithNs(this.base)
             : undefined;
         return omitUndefined({
-            ...DataType.prototype.toJSON.call(this),
-            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
+            ...superJson,
+            kind: this.kind,
+            base: baseName,
             attributes: cloneObject(this.ownAttributes),
         });
     }
+    _locateBase(callback) {
+        if (!this.base)
+            return;
+        if (callback(this.base))
+            return this.base;
+        if (this.base._locateBase)
+            return this.base._locateBase(callback);
+    }
 }
 EnumType.prototype = EnumTypeClass.prototype;
 Object.assign(EnumType, EnumTypeClass);

package/esm/document/data-type/extended-types/base64.type.js

@@ -16,6 +16,7 @@ let Base64Type = class Base64Type {
 };
 Base64Type = __decorate([
     SimpleType({
+        name: 'base64',
         description: 'A stream of bytes, base64 encoded',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/date-string.type.js

@@ -34,6 +34,7 @@ __decorate([
 ], DateStringType.prototype, "maxValue", void 0);
 DateStringType = __decorate([
     (SimpleType({
+        name: 'datestring',
         description: 'Date string value',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/date-time-string.type.js

@@ -34,6 +34,7 @@ __decorate([
 ], DateTimeStringType.prototype, "maxValue", void 0);
 DateTimeStringType = __decorate([
     (SimpleType({
+        name: 'datetimestring',
         description: 'DateTime string value',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/date-time.type.js

@@ -52,6 +52,7 @@ __decorate([
 ], DateTimeType.prototype, "maxValue", void 0);
 DateTimeType = __decorate([
     (SimpleType({
+        name: 'datetime',
         description: 'A full datetime value',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/date.type.js

@@ -52,6 +52,7 @@ __decorate([
 ], DateType.prototype, "maxValue", void 0);
 DateType = __decorate([
     (SimpleType({
+        name: 'date',
         description: 'A date without time',
         nameMappings: {
             js: 'Date',

package/esm/document/data-type/extended-types/email.type.js

@@ -80,6 +80,7 @@ __decorate([
 ], EmailType.prototype, "blacklistedChars", void 0);
 EmailType = __decorate([
     (SimpleType({
+        name: 'email',
         description: 'An email value',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/field-path.type.js

@@ -1,32 +1,35 @@
 import { __decorate, __metadata } from "tslib";
 import { toString, validator, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
+import { DataType } from '../data-type.js';
 import { SimpleType } from '../simple-type.js';
 let FieldPathType = class FieldPathType {
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
-    [DECODER](properties, element) {
+    [DECODER](properties, element, scope) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
         const allowSigns = properties.allowSigns;
-        const decodeFieldPath = validator('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns }));
+        const decodeFieldPath = validator('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns, scope }));
         return vg.pipe([toString, decodeFieldPath]);
     }
-    [ENCODER](properties, element) {
-        return this[DECODER](properties, element);
+    [ENCODER](properties, element, scope) {
+        return this[DECODER](properties, element, scope);
     }
-    toJSON(properties, element) {
+    toJSON(properties, element, options) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
+        /** Test scope */
+        DataType.prototype.toJSON.call(dataType, options);
         const typeName = dataType
             ? element.node.getDataTypeNameWithNs(dataType)
             : undefined;
         return {
-            dataType: typeName ? typeName : dataType.toJSON(),
+            dataType: typeName ? typeName : dataType.toJSON(options),
             allowSigns: properties.allowSigns,
         };
     }
@@ -47,6 +50,7 @@ __decorate([
 ], FieldPathType.prototype, "allowSigns", void 0);
 FieldPathType = __decorate([
     SimpleType({
+        name: 'fieldpath',
         description: 'Field path',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/filter.type.js

@@ -3,6 +3,7 @@ import { validator } from 'valgen';
 import { FilterRules } from '../../../filter/filter-rules.js';
 import { OpraFilter } from '../../../filter/index.js';
 import { DECODER, ENCODER } from '../../constants.js';
+import { DataType } from '../data-type.js';
 import { SimpleType } from '../simple-type.js';
 let FilterType = class FilterType {
     constructor(attributes) {
@@ -21,12 +22,17 @@ let FilterType = class FilterType {
     [ENCODER]() {
         return encodeFilter;
     }
-    toJSON(properties, element) {
+    toJSON(properties, element, options) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
+        /** Test scope */
+        DataType.prototype.toJSON.call(dataType, options);
+        const typeName = dataType
+            ? element.node.getDataTypeNameWithNs(dataType)
+            : undefined;
         return {
-            dataType: dataType.name ? dataType.name : dataType.toJSON(),
+            dataType: typeName ? typeName : dataType.toJSON(options),
             rules: properties.rules,
         };
     }
@@ -46,6 +52,7 @@ __decorate([
 ], FilterType.prototype, "rules", void 0);
 FilterType = __decorate([
     SimpleType({
+        name: 'filter',
         description: 'A query filter',
         nameMappings: {
             js: 'object',
@@ -55,12 +62,12 @@ FilterType = __decorate([
     __metadata("design:paramtypes", [Object])
 ], FilterType);
 export { FilterType };
-const decodeFilter = (dataType, rules) => validator('decodeFilter', (input, context, _this) => {
+const decodeFilter = (dataType, rules, scope) => validator('decodeFilter', (input, context, _this) => {
     if (typeof input === 'string') {
         try {
             const filter = OpraFilter.parse(input);
             if (rules)
-                return rules.normalizeFilter(filter, dataType);
+                return rules.normalizeFilter(filter, dataType, scope);
             return filter;
         }
         catch (e) {

package/esm/document/data-type/extended-types/object-id.type.js

@@ -16,6 +16,7 @@ let ObjectIdType = class ObjectIdType {
 };
 ObjectIdType = __decorate([
     SimpleType({
+        name: 'ObjectId',
         description: 'A MongoDB ObjectID value',
         nameMappings: {
             js: 'object',

package/esm/document/data-type/extended-types/operation-result.type.js

@@ -37,6 +37,7 @@ __decorate([
 ], OperationResult.prototype, "errors", void 0);
 OperationResult = __decorate([
     ComplexType({
+        name: 'OperationResult',
         description: 'Operation result',
     }),
     __metadata("design:paramtypes", [Object])

package/esm/document/data-type/extended-types/time.type.js

@@ -38,6 +38,7 @@ __decorate([
 ], TimeType.prototype, "maxValue", void 0);
 TimeType = __decorate([
     (SimpleType({
+        name: 'time',
         description: 'Time string in 24h format',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/url.type.js

@@ -16,6 +16,7 @@ let UrlType = class UrlType {
 };
 UrlType = __decorate([
     (SimpleType({
+        name: 'url',
         description: 'A Uniform Resource Identifier Reference (RFC 3986 icon) value',
         nameMappings: {
             js: 'string',

package/esm/document/data-type/extended-types/uuid.type.js

@@ -22,6 +22,7 @@ __decorate([
 ], UuidType.prototype, "version", void 0);
 UuidType = __decorate([
     SimpleType({
+        name: 'uuid',
         description: 'A Universal Unique Identifier (UUID) value',
         nameMappings: {
             js: 'string',

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

@@ -85,13 +85,14 @@ class MappedTypeClass extends ComplexTypeBase {
             return true;
         return !!this.base?.extendsFrom(baseType);
     }
-    toJSON() {
+    toJSON(options) {
+        const superJson = super.toJSON(options);
         const baseName = this.base
             ? this.node.getDataTypeNameWithNs(this.base)
             : undefined;
         return omitUndefined({
-            ...ComplexTypeBase.prototype.toJSON.call(this),
-            base: baseName ? baseName : this.base.toJSON(),
+            ...superJson,
+            base: baseName ? baseName : this.base.toJSON(options),
             kind: this.kind,
             pick: this.pick,
             omit: this.omit,
@@ -99,6 +100,14 @@ class MappedTypeClass extends ComplexTypeBase {
             required: this.required,
         });
     }
+    _locateBase(callback) {
+        if (!this.base)
+            return;
+        if (callback(this.base))
+            return this.base;
+        if (this.base._locateBase)
+            return this.base._locateBase(callback);
+    }
 }
 MappedType.prototype = MappedTypeClass.prototype;
 MappedType._applyMixin = () => undefined;

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

@@ -54,16 +54,28 @@ class MixinTypeClass extends ComplexTypeBase {
         }
         return false;
     }
-    toJSON() {
+    toJSON(options) {
+        const superJson = super.toJSON(options);
         return omitUndefined({
-            ...ComplexTypeBase.prototype.toJSON.call(this),
+            ...superJson,
             kind: this.kind,
-            types: this.types.map(t => {
-                const baseName = this.node.getDataTypeNameWithNs(t);
-                return baseName ? baseName : t.toJSON();
+            types: this.types.map(base => {
+                const baseName = this.node.getDataTypeNameWithNs(base);
+                return baseName ? baseName : base.toJSON(options);
             }),
         });
     }
+    _locateBase(callback) {
+        for (const t of this.types) {
+            if (callback(t))
+                return t;
+            if (t._locateBase) {
+                const x = t._locateBase(callback);
+                if (x)
+                    return x;
+            }
+        }
+    }
 }
 MixinType.prototype = MixinTypeClass.prototype;
 MixinType[DECORATOR] = MixinTypeFactory;