@opra/common/document/factory/data-type.factory.d.ts

Opra common package

import type { Combine, ThunkAsync, Type } from 'ts-gems';
import { ResponsiveMap } from '../../helpers/index.js';
import { OpraSchema } from '../../schema/index.js';
import { DocumentElement } from '../common/document-element.js';
import { DocumentInitContext } from '../common/document-init-context.js';
import { ApiField } from '../data-type/api-field.js';
import { ArrayType } from '../data-type/array-type.js';
import { ComplexType } from '../data-type/complex-type.js';
import { DataType } from '../data-type/data-type.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';
import { UnionType } from '../data-type/union-type.js';
/**
 *
 * @namespace DataTypeFactory
 */
export declare namespace DataTypeFactory {
    type DataTypeSources = ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray | object>[] | Record<string, OpraSchema.DataType>;
    type DataTypeThunk = Type | EnumType.EnumObject | EnumType.EnumArray | object;
    interface ArrayTypeInit extends Combine<{
        _instance?: ArrayType;
        type: (string | SimpleTypeInit | ComplexTypeInit | MappedTypeInit | MixinTypeInit | UnionTypeInit | ArrayTypeInit)[];
    }, ArrayType.InitArguments> {
    }
    interface ComplexTypeInit extends Combine<{
        _instance?: ComplexType;
        base?: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
        fields?: Record<string, ApiFieldInit>;
        additionalFields?: boolean | string | DataTypeFactory.DataTypeInitArguments | ['error'] | ['error', string];
    }, ComplexType.InitArguments> {
    }
    interface EnumTypeInit extends Combine<{
        _instance?: MappedType;
        base?: string | EnumTypeInit;
    }, EnumType.InitArguments> {
    }
    interface MappedTypeInit extends Combine<{
        _instance?: MappedType;
        base: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
    }, MappedType.InitArguments> {
    }
    interface MixinTypeInit extends Combine<{
        _instance?: MixinType;
        types: (string | ComplexTypeInit | MappedTypeInit | MixinTypeInit)[];
    }, MixinType.InitArguments> {
    }
    interface SimpleTypeInit extends Combine<{
        _instance?: SimpleType;
        base?: string | SimpleTypeInit;
    }, SimpleType.InitArguments> {
    }
    interface UnionTypeInit extends Combine<{
        _instance?: MixinType;
        types: (string | ComplexTypeInit | MappedTypeInit | MixinTypeInit)[];
    }, UnionType.InitArguments> {
    }
    interface ApiFieldInit extends Combine<{
        type: string | DataTypeInitArguments;
    }, ApiField.InitArguments> {
    }
    type DataTypeInitArguments = ComplexTypeInit | EnumTypeInit | MappedTypeInit | MixinTypeInit | SimpleTypeInit | UnionTypeInit | ArrayTypeInit;
    interface Context extends DocumentInitContext {
        importQueue?: ResponsiveMap<any>;
        initArgsMap?: ResponsiveMap<DataTypeInitArguments>;
    }
}
/**
 *
 * @class DataTypeFactory
 */
export declare class DataTypeFactory {
    static createDataType(context: DocumentInitContext | undefined, owner: DocumentElement, thunk: DataTypeFactory.DataTypeThunk): Promise<DataType | undefined>;
    static resolveDataType(context: DocumentInitContext | undefined, owner: DocumentElement, v: any): Promise<DataType>;
    /**
     *
     * @param context
     * @param target
     * @param types
     */
    static addDataTypes(context: DocumentInitContext | undefined, target: DocumentElement, types: DataTypeFactory.DataTypeSources): Promise<void>;
    /**
     *
     * @param context
     * @param owner
     * @param types
     */
    static createAllDataTypes(context: DocumentInitContext | undefined, owner: DocumentElement, types: DataTypeFactory.DataTypeSources): Promise<DataType[] | undefined>;
    /**
     *
     * @param ctx
     * @param owner
     * @param types
     */
    protected static _prepareAllInitArgs(ctx: DocumentInitContext, owner: DocumentElement, types: DataTypeFactory.DataTypeSources): Promise<DataTypeFactory.DataTypeInitArguments[] | void>;
    /**
     *
     * @param context
     * @param owner
     * @param thunk
     * @param checkCircularDeps
     * @protected
     */
    protected static _importDataTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, thunk: string | Type | OpraSchema.DataType | object, checkCircularDeps?: boolean): Promise<DataTypeFactory.DataTypeInitArguments | string | void>;
    protected static _prepareDataTypeArgs(context: DataTypeFactory.Context, initArgs: DataTypeFactory.DataTypeInitArguments, metadata: OpraSchema.DataTypeBase | DataType.Metadata): Promise<void>;
    protected static _prepareArrayTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.ArrayTypeInit, metadata: (ArrayType.Metadata | OpraSchema.ArrayType) & {
        ctor?: Type;
    }): Promise<void>;
    protected static _prepareComplexTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.ComplexTypeInit, metadata: ComplexType.Metadata | OpraSchema.ComplexType): Promise<void>;
    protected static _prepareEnumTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.EnumTypeInit, metadata: EnumType.Metadata | OpraSchema.EnumType): Promise<void>;
    protected static _prepareSimpleTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.SimpleTypeInit, metadata: SimpleType.Metadata | OpraSchema.SimpleType): Promise<void>;
    protected static _prepareMappedTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.MappedTypeInit, metadata: DataTypeFactory.MappedTypeInit | OpraSchema.MappedType): Promise<void>;
    protected static _prepareMixinTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.MixinTypeInit, metadata: (MixinType.Metadata | OpraSchema.MixinType) & {
        ctor?: Type;
    }): Promise<void>;
    protected static _prepareUnionTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.UnionTypeInit, metadata: (UnionType.Metadata | OpraSchema.UnionType) & {
        ctor?: Type;
    }): Promise<void>;
    protected static _createDataType(context: DocumentInitContext & {
        initArgsMap?: ResponsiveMap<DataTypeFactory.DataTypeInitArguments>;
    }, owner: DocumentElement, args: DataTypeFactory.DataTypeInitArguments | string): ArrayType | ComplexType | EnumType | MappedType | MixinType | SimpleType | UnionType | undefined;
    protected static _createArrayType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.ArrayTypeInit): ArrayType;
    protected static _createComplexType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.ComplexTypeInit): ComplexType;
    protected static _createEnumType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.EnumTypeInit): EnumType;
    protected static _createMappedType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.MappedTypeInit): MappedType;
    protected static _createMixinType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.MixinTypeInit): MixinType;
    protected static _createSimpleType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.SimpleTypeInit): SimpleType;
    protected static _createUnionType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.UnionTypeInit): UnionType;
}