@opra/common 1.20.0 → 1.22.0

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

@@ -1,647 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataTypeFactory = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const document_init_context_js_1 = require("../common/document-init-context.js");
-const constants_js_1 = require("../constants.js");
-const array_type_js_1 = require("../data-type/array-type.js");
-const complex_type_js_1 = require("../data-type/complex-type.js");
-const complex_type_base_js_1 = require("../data-type/complex-type-base.js");
-const data_type_js_1 = require("../data-type/data-type.js");
-const enum_type_js_1 = require("../data-type/enum-type.js");
-const mapped_type_js_1 = require("../data-type/mapped-type.js");
-const mixin_type_js_1 = require("../data-type/mixin-type.js");
-const simple_type_js_1 = require("../data-type/simple-type.js");
-const union_type_js_1 = require("../data-type/union-type.js");
-const initializingSymbol = Symbol('initializing');
-/**
- *
- * @class DataTypeFactory
- */
-class DataTypeFactory {
-    static async createDataType(context, owner, thunk) {
-        context = context || new document_init_context_js_1.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);
-        }
-    }
-    static async resolveDataType(context, owner, v) {
-        if (v) {
-            const dt = owner.node.findDataType(v);
-            if (dt)
-                return dt;
-        }
-        if (typeof v === 'object' || typeof v === 'function') {
-            const dt = await DataTypeFactory.createDataType(context, owner, v);
-            if (dt)
-                return dt;
-        }
-        if (v) {
-            /** To throw not found error */
-            const dt = owner.node.getDataType(v);
-            /** istanbul ignore next */
-            if (dt)
-                return dt;
-        }
-        return owner.node.getDataType('any');
-    }
-    /**
-     *
-     * @param context
-     * @param target
-     * @param types
-     */
-    static async addDataTypes(context, target, types) {
-        const dataTypeMap = target.node[constants_js_1.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 document_init_context_js_1.DocumentInitContext({ maxErrors: 0 });
-        const initArgs = await this._prepareAllInitArgs(context, owner, types);
-        if (!initArgs)
-            return;
-        const initArgsMap = new index_js_1.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 index_js_1.ResponsiveMap();
-        const initArgsMap = new index_js_1.ResponsiveMap();
-        const context = ctx.extend({ owner, importQueue, initArgsMap });
-        // istanbul ignore next
-        if (!owner.node[constants_js_1.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 (0, index_js_1.resolveThunk)(thunk);
-                    const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, thunk) ||
-                        thunk[constants_js_1.DATATYPE_METADATA];
-                    if (!(metadata && metadata.name)) {
-                        if (typeof thunk === 'function') {
-                            return context.addError(`Class "${thunk.name}" doesn't have a valid data type metadata`);
-                        }
-                        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 (0, index_js_1.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
-     * @param checkCircularDeps
-     * @protected
-     */
-    static async _importDataTypeArgs(context, owner, thunk, checkCircularDeps) {
-        thunk = await (0, index_js_1.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 instanceof data_type_js_1.DataType)
-            return dataType.name;
-        let metadata;
-        let ctor;
-        let instance;
-        if (typeof thunk !== 'string') {
-            const _ctorTypeMap = owner.node.getDocument().types[constants_js_1.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(constants_js_1.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[constants_js_1.DATATYPE_METADATA];
-            if (metadata) {
-                instance = thunk;
-                if (metadata.kind !== index_js_2.OpraSchema.EnumType.Kind)
-                    metadata = undefined;
-            }
-            else if (index_js_2.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(constants_js_1.DATATYPE_METADATA, ctor);
-                if (metadata) {
-                    if (metadata.kind === index_js_2.OpraSchema.SimpleType.Kind) {
-                        const baseArgs = await this._importDataTypeArgs(context, owner, metadata.name);
-                        if (!baseArgs)
-                            return;
-                        if (typeof baseArgs === 'object' &&
-                            baseArgs.kind !== index_js_2.OpraSchema.SimpleType.Kind) {
-                            return context.addError('Kind of base data type is not same');
-                        }
-                        return {
-                            kind: index_js_2.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 (checkCircularDeps && 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) {
-                    if (importQueue?.has(out.name)) {
-                        initArgsMap?.set(metadata.name, out);
-                        out._instance = { name: metadata.name };
-                        out[constants_js_1.kDataTypeMap] = owner.node[constants_js_1.kDataTypeMap];
-                    }
-                    else {
-                        return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
-                    }
-                }
-                switch (out.kind) {
-                    case index_js_2.OpraSchema.ArrayType.Kind:
-                        await this._prepareArrayTypeArgs(context, owner, out, metadata);
-                        break;
-                    case index_js_2.OpraSchema.ComplexType.Kind:
-                        out.ctor = ctor;
-                        await this._prepareComplexTypeArgs(context, owner, out, metadata);
-                        break;
-                    case index_js_2.OpraSchema.EnumType.Kind:
-                        out.instance = instance;
-                        await this._prepareEnumTypeArgs(context, owner, out, metadata);
-                        break;
-                    case index_js_2.OpraSchema.MappedType.Kind:
-                        await this._prepareMappedTypeArgs(context, owner, out, metadata);
-                        break;
-                    case index_js_2.OpraSchema.MixinType.Kind:
-                        await this._prepareMixinTypeArgs(context, owner, out, metadata);
-                        break;
-                    case index_js_2.OpraSchema.SimpleType.Kind:
-                        out.ctor = ctor;
-                        await this._prepareSimpleTypeArgs(context, owner, out, metadata);
-                        break;
-                    case index_js_2.OpraSchema.UnionType.Kind:
-                        await this._prepareUnionTypeArgs(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;
-        initArgs.scopePattern = metadata.scopePattern;
-    }
-    static async _prepareArrayTypeArgs(context, owner, initArgs, metadata) {
-        await this._prepareDataTypeArgs(context, initArgs, metadata);
-        await context.enterAsync('.type', async () => {
-            const baseArgs = await this._importDataTypeArgs(context, owner, metadata.type);
-            if (!baseArgs)
-                return;
-            initArgs.type = preferName(baseArgs);
-        });
-    }
-    static async _prepareComplexTypeArgs(context, owner, initArgs, metadata) {
-        await this._prepareDataTypeArgs(context, initArgs, metadata);
-        initArgs.keyField = metadata.keyField;
-        initArgs.discriminatorField = metadata.discriminatorField;
-        initArgs.discriminatorValue = metadata.discriminatorValue;
-        await context.enterAsync('.base', async () => {
-            let baseArgs;
-            if (metadata.base) {
-                baseArgs = await this._importDataTypeArgs(context, owner, metadata.base, true);
-            }
-            else if (initArgs.ctor) {
-                const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
-                if (Reflect.hasMetadata(constants_js_1.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 || 'any');
-                        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 = (0, index_js_1.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, true);
-            }
-            else if (initArgs.ctor) {
-                const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
-                if (Reflect.hasMetadata(constants_js_1.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;
-        initArgs.nameMappings = metadata.nameMappings;
-        if (!initArgs.properties && initArgs.ctor)
-            initArgs.properties = new initArgs.ctor();
-        if (metadata.attributes)
-            initArgs.attributes = (0, index_js_1.cloneObject)(metadata.attributes);
-        if (typeof initArgs.properties?.[constants_js_1.DECODER] === 'function') {
-            initArgs.generateDecoder = initArgs.properties?.[constants_js_1.DECODER].bind(initArgs.properties);
-        }
-        if (typeof initArgs.properties?.[constants_js_1.ENCODER] === 'function') {
-            initArgs.generateEncoder = initArgs.properties?.[constants_js_1.ENCODER].bind(initArgs.properties);
-        }
-    }
-    static async _prepareMappedTypeArgs(context, owner, initArgs, metadata) {
-        await this._prepareDataTypeArgs(context, initArgs, metadata);
-        initArgs.discriminatorField = metadata.discriminatorField;
-        initArgs.discriminatorValue = metadata.discriminatorValue;
-        await context.enterAsync('.base', async () => {
-            let baseArgs;
-            if (metadata.base) {
-                baseArgs = await this._importDataTypeArgs(context, owner, metadata.base, true);
-            }
-            else if (initArgs.ctor) {
-                const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
-                if (Reflect.hasMetadata(constants_js_1.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 async _prepareUnionTypeArgs(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) {
-        let dataType = owner.node.findDataType(typeof args === 'string' ? args : args.name || '');
-        if (dataType instanceof data_type_js_1.DataType)
-            return dataType;
-        const initArgs = typeof args === 'string' ? context.initArgsMap?.get(args) : args;
-        if (initArgs) {
-            const dataTypeMap = initArgs[constants_js_1.kDataTypeMap];
-            if (!dataTypeMap)
-                delete initArgs._instance;
-            dataType = initArgs._instance;
-            if (dataType?.name && dataTypeMap) {
-                dataTypeMap.set(dataType.name, dataType);
-            }
-            switch (initArgs?.kind) {
-                case index_js_2.OpraSchema.ArrayType.Kind:
-                    return this._createArrayType(context, owner, initArgs);
-                case index_js_2.OpraSchema.ComplexType.Kind:
-                    return this._createComplexType(context, owner, initArgs);
-                case index_js_2.OpraSchema.EnumType.Kind:
-                    return this._createEnumType(context, owner, initArgs);
-                case index_js_2.OpraSchema.MappedType.Kind:
-                    return this._createMappedType(context, owner, initArgs);
-                case index_js_2.OpraSchema.MixinType.Kind:
-                    return this._createMixinType(context, owner, initArgs);
-                case index_js_2.OpraSchema.SimpleType.Kind:
-                    return this._createSimpleType(context, owner, initArgs);
-                case index_js_2.OpraSchema.UnionType.Kind:
-                    return this._createUnionType(context, owner, initArgs);
-                default:
-                    break;
-            }
-        }
-        context.addError(`Unknown data type (${String(args)})`);
-    }
-    static _createArrayType(context, owner, args) {
-        const dataType = args._instance || {};
-        Object.setPrototypeOf(dataType, array_type_js_1.ArrayType.prototype);
-        const initArgs = (0, index_js_1.cloneObject)(args);
-        if (args.type) {
-            context.enter('.type', () => {
-                initArgs.type = this._createDataType(context, owner, args.type);
-            });
-        }
-        array_type_js_1.ArrayType.apply(dataType, [owner, initArgs]);
-        return dataType;
-    }
-    static _createComplexType(context, owner, args) {
-        const dataType = args._instance || {};
-        Object.setPrototypeOf(dataType, complex_type_js_1.ComplexType.prototype);
-        const initArgs = (0, index_js_1.cloneObject)(args);
-        if (args.base) {
-            context.enter('.base', () => {
-                initArgs.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 {
-                    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 = this._createDataType(context, owner, v.type);
-                        if (type) {
-                            initArgs.fields[k] = {
-                                ...v,
-                                name: k,
-                                type,
-                            };
-                        }
-                    });
-                }
-            });
-        }
-        complex_type_js_1.ComplexType.apply(dataType, [owner, initArgs]);
-        return dataType;
-    }
-    static _createEnumType(context, owner, args) {
-        const dataType = args._instance || {};
-        Object.setPrototypeOf(dataType, enum_type_js_1.EnumType.prototype);
-        const initArgs = (0, index_js_1.cloneObject)(args);
-        if (args.base) {
-            context.enter('.base', () => {
-                initArgs.base = this._createDataType(context, owner, args.base);
-            });
-        }
-        initArgs.attributes = args.attributes;
-        enum_type_js_1.EnumType.apply(dataType, [owner, initArgs]);
-        return dataType;
-    }
-    static _createMappedType(context, owner, args) {
-        const dataType = args._instance || {};
-        Object.setPrototypeOf(dataType, mapped_type_js_1.MappedType.prototype);
-        const initArgs = (0, index_js_1.cloneObject)(args);
-        if (args.base) {
-            context.enter('.base', () => {
-                initArgs.base = this._createDataType(context, owner, args.base);
-            });
-        }
-        mapped_type_js_1.MappedType.apply(dataType, [owner, initArgs]);
-        return dataType;
-    }
-    static _createMixinType(context, owner, args) {
-        const dataType = args._instance || {};
-        Object.setPrototypeOf(dataType, mixin_type_js_1.MixinType.prototype);
-        const initArgs = (0, index_js_1.cloneObject)(args);
-        if (args.types) {
-            context.enter('.types', () => {
-                initArgs.types = [];
-                let i = 0;
-                for (const t of args.types) {
-                    context.enter(`[${i++}]`, () => {
-                        const base = this._createDataType(context, owner, t);
-                        if (!(base instanceof complex_type_base_js_1.ComplexTypeBase)) {
-                            throw new TypeError(`"${base?.kind}" can't be set as base for a "${initArgs.kind}"`);
-                        }
-                        initArgs.types.push(base);
-                    });
-                }
-            });
-        }
-        mixin_type_js_1.MixinType.apply(dataType, [owner, initArgs]);
-        return dataType;
-    }
-    static _createSimpleType(context, owner, args) {
-        const dataType = args._instance || {};
-        Object.setPrototypeOf(dataType, simple_type_js_1.SimpleType.prototype);
-        const initArgs = (0, index_js_1.cloneObject)(args);
-        if (args.base) {
-            context.enter('.base', () => {
-                initArgs.base = this._createDataType(context, owner, args.base);
-            });
-        }
-        simple_type_js_1.SimpleType.apply(dataType, [owner, initArgs]);
-        return dataType;
-    }
-    static _createUnionType(context, owner, args) {
-        const dataType = args._instance || {};
-        Object.setPrototypeOf(dataType, union_type_js_1.UnionType.prototype);
-        const initArgs = (0, index_js_1.cloneObject)(args);
-        if (args.types) {
-            context.enter('.types', () => {
-                initArgs.types = [];
-                let i = 0;
-                for (const t of args.types) {
-                    context.enter(`[${i++}]`, () => {
-                        const base = this._createDataType(context, owner, t);
-                        initArgs.types.push(base);
-                    });
-                }
-            });
-        }
-        union_type_js_1.UnionType.apply(dataType, [owner, initArgs]);
-        return dataType;
-    }
-}
-exports.DataTypeFactory = DataTypeFactory;
-function preferName(initArgs) {
-    return typeof initArgs === 'object'
-        ? initArgs.name
-            ? initArgs.name
-            : initArgs
-        : initArgs;
-}