map-transform/dist/types.d.ts

Map and transform objects with mapping definitions

export type DictionaryValue = string | number | boolean | null | undefined;
export type DictionaryTuple = readonly [DictionaryValue, DictionaryValue];
export type Dictionary = DictionaryTuple[];
export interface Dictionaries {
    [key: string]: Dictionary;
}
export interface InitialState {
    target?: unknown;
    rev?: boolean;
    noDefaults?: boolean;
}
export interface State extends InitialState {
    context: unknown[];
    value: unknown;
    flip?: boolean;
    arr?: boolean;
    iterate?: boolean;
    index?: number;
    untouched?: boolean;
}
export interface Options {
    transformers?: {
        [key: string | symbol]: Transformer | AsyncTransformer;
    };
    pipelines?: {
        [key: string | symbol]: TransformDefinition;
    };
    dictionaries?: Dictionaries;
    nonvalues?: unknown[];
    fwdAlias?: string;
    revAlias?: string;
    modifyOperationObject?: (operation: Record<string, unknown>) => Record<string, unknown>;
    modifyGetValue?: (value: unknown, state: State, options: Options) => unknown;
}
export interface DataMapper<T extends InitialState | undefined = State> {
    (data: unknown, state?: T): Promise<unknown>;
}
export interface AsyncDataMapperWithState {
    (data: unknown, state: State): Promise<unknown>;
}
export interface DataMapperWithState {
    (data: unknown, state: State): unknown;
}
export interface AsyncDataMapperWithOptions {
    (options: Options): AsyncDataMapperWithState;
}
export interface DataMapperWithOptions {
    (options: Options): DataMapperWithState;
}
export interface StateMapper {
    (state: State): Promise<State>;
}
export interface NextStateMapper {
    (next: StateMapper): StateMapper;
}
export interface Operation {
    (options: Options): NextStateMapper;
}
export type TransformerProps = Record<string, unknown>;
export interface Transformer<T = TransformerProps> {
    (props: T): DataMapperWithOptions;
}
export interface AsyncTransformer<T = TransformerProps> {
    (props: T): AsyncDataMapperWithOptions;
}
export type Path = string;
export interface TransformOperation extends TransformerProps {
    $transform: string | symbol | DataMapperWithOptions | AsyncDataMapperWithOptions;
    $iterate?: boolean;
    $direction?: string;
}
export interface FilterOperation extends TransformerProps {
    $filter: string | symbol;
    $direction?: string;
}
export interface IfOperation extends TransformerProps {
    $if: TransformDefinition;
    $direction?: string;
    then?: TransformDefinition;
    else?: TransformDefinition;
}
export interface ApplyOperation extends TransformerProps {
    $apply: string | symbol;
    $iterate?: boolean;
    $direction?: string;
}
export interface AltOperation extends TransformerProps {
    $alt: TransformDefinition[];
    $iterate?: boolean;
    $direction?: string;
    $undefined?: unknown[];
}
export interface ConcatOperation extends TransformerProps {
    $concat: TransformDefinition[];
}
export interface ConcatRevOperation extends TransformerProps {
    $concatRev: TransformDefinition[];
}
export interface LookupOperation extends TransformerProps {
    $lookup: Path;
    path: Path;
}
export interface LookdownOperation extends TransformerProps {
    $lookdown: Path;
    path: Path;
}
export type OperationObject = TransformOperation | FilterOperation | IfOperation | ApplyOperation | AltOperation | ConcatOperation | ConcatRevOperation | LookupOperation | LookdownOperation;
export type Pipeline = (TransformObject | Operation | OperationObject | Path | Pipeline)[];
export interface TransformObject extends Record<string, unknown> {
    $iterate?: boolean;
    $modify?: boolean | Path;
    $noDefaults?: boolean;
    $flip?: boolean;
    $direction?: string;
}
export type TransformDefinition = TransformObject | Operation | OperationObject | Pipeline | Path | null;