@opra/common 0.33.13 → 1.0.0-alpha.1

package/esm/document/factory/api-document.factory.js

@@ -0,0 +1,174 @@
+import { resolveThunk } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { ApiDocument } from '../api-document.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { OpraDocumentError } from '../common/opra-document-error.js';
+import { BUILTIN, CLASS_NAME_PATTERN, kCtorMap } from '../constants.js';
+import { Base64Type, DateStringType, DateTimeStringType, DateTimeType, DateType, EmailType, FieldPathType, FilterType, ObjectIdType, OperationResult, TimeType, UrlType, UuidType, } from '../data-type/extended-types/index.js';
+import { AnyType, BigintType, BooleanType, IntegerType, NullType, NumberType, ObjectType, StringType, } from '../data-type/primitive-types/index.js';
+import { DataTypeFactory } from './data-type.factory.js';
+import { HttpApiFactory } from './http-api.factory.js';
+const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + OpraSchema.SpecVersion;
+/**
+ * @class ApiDocumentFactory
+ */
+export class ApiDocumentFactory {
+    /**
+     * Creates ApiDocument instance from given schema object
+     */
+    static async createDocument(schemaOrUrl, options) {
+        const factory = new ApiDocumentFactory();
+        const context = options instanceof DocumentInitContext ? options : new DocumentInitContext(options);
+        try {
+            const document = new ApiDocument();
+            await factory.initDocument(document, context, schemaOrUrl);
+            if (context.error.details.length)
+                throw context.error;
+            return document;
+        }
+        catch (e) {
+            try {
+                if (!(e instanceof OpraDocumentError)) {
+                    context.addError(e);
+                }
+            }
+            catch {
+                //
+            }
+            if (!context.error.message) {
+                const l = context.error.details.length;
+                context.error.message = `(${l}) error${l > 1 ? 's' : ''} found in document schema.`;
+                if (context.showErrorDetails) {
+                    context.error.message += context.error.details
+                        .map(d => {
+                        return `\n\n  - ${d.message}` + (d.path ? `\n    @${d.path}` : '');
+                    })
+                        .join('');
+                }
+            }
+            throw context.error;
+        }
+    }
+    /**
+     * Downloads schema from the given URL and creates the document instance   * @param url
+     */
+    async initDocument(document, context, schemaOrUrl) {
+        let init;
+        if (typeof schemaOrUrl === 'string') {
+            const resp = await fetch(schemaOrUrl, { method: 'GET' });
+            init = await resp.json();
+            if (!init)
+                return context.addError(`Invalid response returned from url: ${schemaOrUrl}`);
+            init.url = schemaOrUrl;
+        }
+        else
+            init = schemaOrUrl;
+        // Add builtin data types if this document is the root
+        if (!document[BUILTIN]) {
+            const builtinDocument = await this.createBuiltinDocument(context);
+            document.references.set('opra', builtinDocument);
+        }
+        init.spec = init.spec || OpraSchema.SpecVersion;
+        document.url = init.url;
+        if (init.info)
+            document.info = { ...init.info };
+        /** Add references  */
+        if (init.references) {
+            await context.enterAsync('.references', async () => {
+                let ns;
+                let r;
+                for ([ns, r] of Object.entries(init.references)) {
+                    r = await resolveThunk(r);
+                    await context.enterAsync(`[${ns}]`, async () => {
+                        if (!CLASS_NAME_PATTERN.test(ns))
+                            throw new TypeError(`Invalid namespace (${ns})`);
+                        if (r instanceof ApiDocument) {
+                            document.references.set(ns, r);
+                            return;
+                        }
+                        const refDoc = new ApiDocument();
+                        await this.initDocument(refDoc, context, r);
+                        document.references.set(ns, refDoc);
+                    });
+                }
+            });
+        }
+        if (init.types) {
+            await context.enterAsync('.types', async () => {
+                await DataTypeFactory.addDataTypes(context, document, init.types);
+            });
+        }
+        if (init.api) {
+            await context.enterAsync(`.api`, async () => {
+                if (init.api.protocol === 'http') {
+                    const api = await HttpApiFactory.createApi(context, document, init.api);
+                    if (api)
+                        document.api = api;
+                }
+                else
+                    context.addError(`Unknown service protocol (${init.api.protocol})`);
+            });
+        }
+    }
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    async createBuiltinDocument(context) {
+        const init = {
+            spec: OpraSchema.SpecVersion,
+            url: OPRA_SPEC_URL,
+            info: {
+                version: OpraSchema.SpecVersion,
+                title: 'Opra built-in types',
+                license: {
+                    url: 'https://github.com/oprajs/opra/blob/main/LICENSE',
+                    name: 'MIT',
+                },
+            },
+            types: [
+                // Primitive types
+                AnyType,
+                BigintType,
+                BooleanType,
+                IntegerType,
+                NullType,
+                NumberType,
+                ObjectType,
+                StringType,
+                // Extended types
+                Base64Type,
+                DateType,
+                DateStringType,
+                DateTimeType,
+                DateTimeStringType,
+                EmailType,
+                FieldPathType,
+                FilterType,
+                ObjectIdType,
+                OperationResult,
+                TimeType,
+                UrlType,
+                UuidType,
+            ],
+        };
+        const document = new ApiDocument();
+        document[BUILTIN] = true;
+        const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+        const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
+        const _ctorTypeMap = document.types[kCtorMap];
+        _ctorTypeMap.set(Object, 'object');
+        _ctorTypeMap.set(String, 'string');
+        _ctorTypeMap.set(Number, 'number');
+        _ctorTypeMap.set(Boolean, 'boolean');
+        _ctorTypeMap.set(Object, 'any');
+        _ctorTypeMap.set(Date, 'datetime');
+        _ctorTypeMap.set(BigIntConstructor, 'bigint');
+        _ctorTypeMap.set(ArrayBuffer, 'base64');
+        _ctorTypeMap.set(SharedArrayBuffer, 'base64');
+        _ctorTypeMap.set(BufferConstructor, 'base64');
+        await this.initDocument(document, context, init);
+        return document;
+    }
+}

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

@@ -0,0 +1,494 @@
+import { cloneObject, resolveThunk, ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { DATATYPE_METADATA, DECODER, ENCODER, kCtorMap, kDataTypeMap } from '../constants.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import { ComplexTypeBase } from '../data-type/complex-type-base.js';
+import { EnumType } from '../data-type/enum-type.js';
+import { MappedType } from '../data-type/mapped-type.js';
+import { MixinType } from '../data-type/mixin-type.js';
+import { SimpleType } from '../data-type/simple-type.js';
+const initializingSymbol = Symbol('initializing');
+/**
+ *
+ * @class DataTypeFactory
+ */
+export class DataTypeFactory {
+    static async createDataType(context, owner, thunk) {
+        context = context || new DocumentInitContext({ maxErrors: 0 });
+        const initArgs = await this._importDataTypeArgs(context, owner, thunk);
+        if (initArgs) {
+            if (typeof initArgs === 'string')
+                return owner.node.getDataType(initArgs);
+            return this._createDataType(context, owner, initArgs);
+        }
+    }
+    /**
+     *
+     * @param context
+     * @param target
+     * @param types
+     */
+    static async addDataTypes(context, target, types) {
+        const dataTypeMap = target.node[kDataTypeMap];
+        if (!dataTypeMap)
+            throw new TypeError('DocumentElement should has [kDataTypeMap] property');
+        const importedTypes = await this.createAllDataTypes(context, target, types);
+        if (!importedTypes)
+            return;
+        for (const dataType of importedTypes) {
+            if (dataType?.name) {
+                dataTypeMap.set(dataType.name, dataType);
+            }
+        }
+    }
+    /**
+     *
+     * @param context
+     * @param owner
+     * @param types
+     */
+    static async createAllDataTypes(context, owner, types) {
+        context = context || new DocumentInitContext({ maxErrors: 0 });
+        const initArgs = await this._prepareAllInitArgs(context, owner, types);
+        if (!initArgs)
+            return;
+        const initArgsMap = new ResponsiveMap();
+        for (const initArg of initArgs) {
+            initArgsMap.set(initArg.name, initArg);
+        }
+        const ctx = context.extend({ initArgsMap });
+        const out = [];
+        for (const [name, initArg] of initArgsMap.entries()) {
+            context.enter(`[${name}]`, () => {
+                if (!initArgsMap.has(name))
+                    return;
+                const dataType = this._createDataType(ctx, owner, initArg);
+                if (dataType)
+                    out.push(dataType);
+            });
+        }
+        return out;
+    }
+    /**
+     *
+     * @param ctx
+     * @param owner
+     * @param types
+     */
+    static async _prepareAllInitArgs(ctx, owner, types) {
+        const importQueue = new ResponsiveMap();
+        const initArgsMap = new ResponsiveMap();
+        const context = ctx.extend({ owner, importQueue, initArgsMap });
+        // istanbul ignore next
+        if (!owner.node[kDataTypeMap])
+            throw new TypeError('DocumentElement should has [kDataTypeMap] property');
+        // Add type sources into typeQueue
+        if (Array.isArray(types)) {
+            let i = 0;
+            for (let thunk of types) {
+                await context.enterAsync(`$[${i++}]`, async () => {
+                    thunk = await resolveThunk(thunk);
+                    const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk) || thunk[DATATYPE_METADATA];
+                    if (!(metadata && metadata.name)) {
+                        if (typeof thunk === 'function')
+                            return context.addError(`Class "${thunk.name}" doesn't have a valid data type metadata`);
+                        else
+                            return context.addError(`Object doesn't have a valid data type metadata`);
+                    }
+                    importQueue.set(metadata.name, thunk);
+                });
+            }
+        }
+        else {
+            let thunk;
+            let name;
+            for ([name, thunk] of Object.entries(types)) {
+                thunk = await resolveThunk(thunk);
+                importQueue.set(name, typeof thunk === 'object' ? { ...thunk, name } : thunk);
+            }
+        }
+        for (const name of Array.from(importQueue.keys())) {
+            if (!importQueue.has(name))
+                continue;
+            const dt = await this._importDataTypeArgs(context, owner, name);
+            // istanbul ignore next
+            if (dt && typeof dt !== 'string')
+                context.addError(`Embedded data type can't be loaded into document node directly`);
+        }
+        return Array.from(initArgsMap.values());
+    }
+    /**
+     *
+     * @param context
+     * @param owner
+     * @param thunk
+     * @protected
+     */
+    static async _importDataTypeArgs(context, owner, thunk) {
+        thunk = await resolveThunk(thunk);
+        const { importQueue, initArgsMap } = context;
+        // Check if data type already exist (maybe a builtin type or already imported)
+        const dataType = owner.node.findDataType(thunk);
+        if (dataType)
+            return dataType.name;
+        let metadata;
+        let ctor;
+        let instance;
+        if (typeof thunk !== 'string') {
+            const _ctorTypeMap = owner.node.getDocument().types[kCtorMap];
+            const name = _ctorTypeMap.get(thunk);
+            if (name)
+                thunk = name;
+        }
+        if (typeof thunk === 'string') {
+            const name = thunk;
+            thunk = importQueue?.get(name) || context.initArgsMap?.get(name);
+            if (!thunk)
+                return context.addError(`Unknown data type (${name})`);
+        }
+        else {
+            //
+        }
+        if (typeof thunk === 'function') {
+            // Check if class has metadata
+            metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
+            if (!metadata)
+                return context.addError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
+            ctor = thunk;
+        }
+        else if (typeof thunk === 'object') {
+            // It may be an enum object or enum array
+            metadata = thunk[DATATYPE_METADATA];
+            if (metadata) {
+                instance = thunk;
+                if (metadata.kind !== OpraSchema.EnumType.Kind)
+                    metadata = undefined;
+            }
+            else if (OpraSchema.isDataType(thunk)) {
+                metadata = thunk;
+                ctor = metadata.ctor;
+            }
+            else {
+                // Or may be a DataType instance, e.g. an extended SimpleType object
+                ctor = Object.getPrototypeOf(thunk).constructor;
+                metadata = ctor && Reflect.getMetadata(DATATYPE_METADATA, ctor);
+                if (metadata) {
+                    if (metadata.kind === OpraSchema.SimpleType.Kind) {
+                        const baseArgs = await this._importDataTypeArgs(context, owner, metadata.name);
+                        if (!baseArgs)
+                            return;
+                        if (typeof baseArgs === 'object' && baseArgs.kind !== OpraSchema.SimpleType.Kind)
+                            return context.addError('Kind of base data type is not same');
+                        return {
+                            kind: OpraSchema.SimpleType.Kind,
+                            name: undefined,
+                            base: baseArgs,
+                            properties: thunk,
+                        };
+                    }
+                }
+            }
+        }
+        if (!metadata)
+            return context.addError(`No DataType metadata found`);
+        return context.enterAsync(metadata.name ? `[${metadata.name}]` : '', async () => {
+            /** Check for circular dependencies */
+            if (metadata.name) {
+                const curr = initArgsMap?.get(metadata.name);
+                if (curr) {
+                    if (curr[initializingSymbol])
+                        return context.addError('Circular reference detected');
+                    return metadata.name;
+                }
+            }
+            const out = {
+                kind: metadata.kind,
+                name: metadata.name,
+            };
+            /** Mark "out" object as initializing. This will help us to detect circular dependencies */
+            out[initializingSymbol] = true;
+            try {
+                if (out.name && importQueue?.has(out.name)) {
+                    initArgsMap?.set(metadata.name, out);
+                }
+                else if (out.name)
+                    return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
+                switch (out.kind) {
+                    case OpraSchema.ComplexType.Kind:
+                        out.ctor = ctor;
+                        await this._prepareComplexTypeArgs(context, owner, out, metadata);
+                        break;
+                    case OpraSchema.EnumType.Kind:
+                        out.instance = instance;
+                        await this._prepareEnumTypeArgs(context, owner, out, metadata);
+                        break;
+                    case OpraSchema.MappedType.Kind:
+                        await this._prepareMappedTypeArgs(context, owner, out, metadata);
+                        break;
+                    case OpraSchema.MixinType.Kind:
+                        await this._prepareMixinTypeArgs(context, owner, out, metadata);
+                        break;
+                    case OpraSchema.SimpleType.Kind:
+                        out.ctor = ctor;
+                        await this._prepareSimpleTypeArgs(context, owner, out, metadata);
+                        break;
+                    default:
+                        /** istanbul ignore next */
+                        return context.addError(`Invalid data type kind ${metadata.kind}`);
+                }
+            }
+            finally {
+                if (out.name)
+                    importQueue?.delete(out.name);
+                delete out[initializingSymbol];
+            }
+            return importQueue && out.name ? out.name : out;
+        });
+    }
+    static async _prepareDataTypeArgs(context, initArgs, metadata) {
+        initArgs.description = metadata.description;
+        initArgs.abstract = metadata.abstract;
+        initArgs.examples = metadata.examples;
+    }
+    static async _prepareComplexTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        await context.enterAsync('.base', async () => {
+            let baseArgs;
+            if (metadata.base) {
+                baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
+            }
+            else if (initArgs.ctor) {
+                const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
+                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
+                    baseArgs = await this._importDataTypeArgs(context, owner, baseClass);
+            }
+            if (!baseArgs)
+                return;
+            initArgs.base = preferName(baseArgs);
+            initArgs.ctor = initArgs.ctor || baseArgs.ctor;
+        });
+        // Initialize additionalFields
+        if (metadata.additionalFields != null) {
+            if (typeof metadata.additionalFields === 'boolean' || Array.isArray(metadata.additionalFields))
+                initArgs.additionalFields = metadata.additionalFields;
+            else
+                await context.enterAsync('.additionalFields', async () => {
+                    const t = await this._importDataTypeArgs(context, owner, metadata.additionalFields);
+                    if (t)
+                        initArgs.additionalFields = preferName(t);
+                });
+        }
+        if (metadata.fields) {
+            initArgs.fields = {};
+            await context.enterAsync('.fields', async () => {
+                for (const [k, v] of Object.entries(metadata.fields)) {
+                    await context.enterAsync(`[${k}]`, async () => {
+                        const fieldMeta = typeof v === 'string' ? { type: v } : v;
+                        if (fieldMeta.isArray && !fieldMeta.type)
+                            return context.addError(`"type" must be defined explicitly for array fields`);
+                        const t = await this._importDataTypeArgs(context, owner, fieldMeta.type);
+                        if (!t)
+                            return;
+                        initArgs.fields[k] = {
+                            ...fieldMeta,
+                            type: preferName(t),
+                        };
+                    });
+                }
+            });
+        }
+    }
+    static async _prepareEnumTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        if (metadata.base) {
+            await context.enterAsync('.base', async () => {
+                const baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
+                if (!baseArgs)
+                    return;
+                initArgs.base = preferName(baseArgs);
+            });
+        }
+        initArgs.attributes = cloneObject(metadata.attributes);
+    }
+    static async _prepareSimpleTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        await context.enterAsync('.base', async () => {
+            let baseArgs;
+            if (metadata.base) {
+                baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
+            }
+            else if (initArgs.ctor) {
+                const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
+                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
+                    baseArgs = await this._importDataTypeArgs(context, owner, baseClass);
+            }
+            if (!baseArgs)
+                return;
+            initArgs.base = preferName(baseArgs);
+            initArgs.ctor = initArgs.ctor || baseArgs.ctor;
+        });
+        initArgs.properties = metadata.properties;
+        if (!initArgs.properties && initArgs.ctor)
+            initArgs.properties = new initArgs.ctor();
+        if (metadata.attributes)
+            initArgs.attributes = cloneObject(metadata.attributes);
+        if (typeof initArgs.properties?.[DECODER] === 'function')
+            initArgs.generateDecoder = initArgs.properties?.[DECODER].bind(initArgs.properties);
+        if (typeof initArgs.properties?.[ENCODER] === 'function')
+            initArgs.generateEncoder = initArgs.properties?.[ENCODER].bind(initArgs.properties);
+    }
+    static async _prepareMappedTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        await context.enterAsync('.base', async () => {
+            let baseArgs;
+            if (metadata.base) {
+                baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
+            }
+            else if (initArgs.ctor) {
+                const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
+                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
+                    baseArgs = await this._importDataTypeArgs(context, owner, baseClass);
+            }
+            if (!baseArgs)
+                return;
+            initArgs.base = preferName(baseArgs);
+            initArgs.ctor = initArgs.ctor || baseArgs.ctor;
+        });
+        if (metadata.pick)
+            initArgs.pick = [...metadata.pick];
+        else if (metadata.omit)
+            initArgs.omit = [...metadata.omit];
+        else if (metadata.partial)
+            initArgs.partial = Array.isArray(metadata.partial) ? [...metadata.partial] : metadata.partial;
+        else if (metadata.required)
+            initArgs.required = Array.isArray(metadata.required) ? [...metadata.required] : metadata.required;
+    }
+    static async _prepareMixinTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        initArgs.types = [];
+        await context.enterAsync('.types', async () => {
+            const _initTypes = metadata.types;
+            let i = 0;
+            for (const t of _initTypes) {
+                await context.enterAsync(`[${i++}]`, async () => {
+                    const baseArgs = await this._importDataTypeArgs(context, owner, t);
+                    if (!baseArgs)
+                        return;
+                    initArgs.types.push(preferName(baseArgs));
+                });
+            }
+        });
+    }
+    static _createDataType(context, owner, args) {
+        const initArgs = typeof args === 'string' ? context.initArgsMap?.get(args) : args;
+        switch (initArgs?.kind) {
+            case OpraSchema.ComplexType.Kind:
+                return this._createComplexType(context, owner, initArgs);
+            case OpraSchema.EnumType.Kind:
+                return this._createEnumType(context, owner, initArgs);
+            case OpraSchema.MappedType.Kind:
+                return this._createMappedType(context, owner, initArgs);
+            case OpraSchema.MixinType.Kind:
+                return this._createMixinType(context, owner, initArgs);
+            case OpraSchema.SimpleType.Kind:
+                return this._createSimpleType(context, owner, initArgs);
+        }
+        context.addError(`Unknown data type (${String(args)})`);
+    }
+    static _createComplexType(context, owner, args) {
+        const initArgs = cloneObject(args);
+        if (args.base) {
+            context.enter('.base', () => {
+                initArgs.base = (owner.node.findDataType(args.base) ||
+                    this._createDataType(context, owner, args.base));
+            });
+        }
+        /** Set additionalFields */
+        if (args.additionalFields) {
+            context.enter('.additionalFields', () => {
+                if (typeof args.additionalFields === 'boolean' || Array.isArray(args.additionalFields))
+                    initArgs.additionalFields = args.additionalFields;
+                else {
+                    if (typeof args.additionalFields === 'string') {
+                        initArgs.additionalFields =
+                            owner.node.findDataType(args.additionalFields) ||
+                                this._createDataType(context, owner, args.additionalFields);
+                    }
+                    else {
+                        initArgs.additionalFields = this._createDataType(context, owner, args.additionalFields);
+                    }
+                }
+            });
+        }
+        /** Add own fields */
+        initArgs.fields = {};
+        if (args.fields) {
+            context.enter('.fields', () => {
+                for (const [k, v] of Object.entries(args.fields)) {
+                    context.enter(`[${k}]`, () => {
+                        const type = owner.node.findDataType(v.type) || this._createDataType(context, owner, v.type);
+                        if (type)
+                            initArgs.fields[k] = {
+                                ...v,
+                                name: k,
+                                type,
+                            };
+                    });
+                }
+            });
+        }
+        return new ComplexType(owner, initArgs);
+    }
+    static _createEnumType(context, owner, args) {
+        const initArgs = cloneObject(args);
+        if (args.base) {
+            context.enter('.base', () => {
+                initArgs.base = (owner.node.findDataType(args.base) ||
+                    this._createDataType(context, owner, args.base));
+            });
+        }
+        initArgs.attributes = args.attributes;
+        return new EnumType(owner, initArgs);
+    }
+    static _createMappedType(context, owner, args) {
+        const initArgs = cloneObject(args);
+        if (args.base) {
+            context.enter('.base', () => {
+                initArgs.base = (owner.node.findDataType(args.base) || this._createDataType(context, owner, args.base));
+            });
+        }
+        return new MappedType(owner, initArgs);
+    }
+    static _createMixinType(context, owner, args) {
+        const initArgs = cloneObject(args);
+        if (args.types) {
+            context.enter('.types', () => {
+                initArgs.types = [];
+                let i = 0;
+                for (const t of args.types) {
+                    context.enter(`[${i++}]`, () => {
+                        const base = owner.node.findDataType(t) || this._createDataType(context, owner, t);
+                        if (!(base instanceof ComplexTypeBase))
+                            throw new TypeError(`"${base?.kind}" can't be set as base for a "${initArgs.kind}"`);
+                        initArgs.types.push(base);
+                    });
+                }
+            });
+        }
+        return new MixinType(owner, initArgs);
+    }
+    static _createSimpleType(context, owner, args) {
+        const initArgs = cloneObject(args);
+        if (args.base) {
+            context.enter('.base', () => {
+                initArgs.base = (owner.node.findDataType(args.base) ||
+                    this._createDataType(context, owner, args.base));
+            });
+        }
+        return new SimpleType(owner, initArgs);
+    }
+}
+function preferName(initArgs) {
+    return typeof initArgs === 'object' ? (initArgs.name ? initArgs.name : initArgs) : initArgs;
+}