build-function/types/types.d.ts

The way to describe and build simple functions using JSON

import { SingleOrMulti } from "./helper-types";
export interface FunctionOptions {
    params?: SingleOrMulti<FunctionParameter>;
    body?: SingleOrMulti<FunctionStep>;
}
export interface NamedFunctionOptions extends FunctionOptions {
    name?: string;
}
export declare type ParameterType = "param" | "rest";
export interface ParameterDescriptor {
    id: string;
    type: ParameterType;
}
export declare type FunctionParameter = string | ParameterDescriptor;
export interface LiteralExpression {
    type: "literal";
    value: any;
}
export interface GetExpression {
    type: "get";
    id: string;
}
export interface SetExpression {
    type: "set";
    id: string;
    value: Expression;
}
export interface FunctionCallExpression {
    type: "call";
    func: Expression;
    args?: SingleOrMulti<SpreadableExpression>;
}
export interface TernaryExpression {
    type: "ternary";
    condition: Expression;
    then: Expression;
    otherwise: Expression;
}
export declare type RegularLogicOperator = "==" | "===" | "!=" | "!==" | ">" | ">=" | "<" | "<=";
export declare type SpecialLogicOperator = "&&" | "||";
export declare type RegularArithmeticOperator = "+" | "-" | "*" | "/" | "%";
export declare type SpecialArithmeticOperator = "**";
export declare type BitwiseOperator = "&" | "|" | "^" | "<<" | ">>" | ">>>";
export declare type SpecialOperator = SpecialLogicOperator | SpecialArithmeticOperator;
export declare type RegularOperator = RegularLogicOperator | RegularArithmeticOperator | BitwiseOperator;
export declare type MultiTermOperator = SpecialOperator | RegularOperator;
export declare type MultiTermExpressions = [Expression, Expression, ...Expression[]];
export interface OperationExpression {
    type: "oper";
    oper: MultiTermOperator;
    exp: MultiTermExpressions;
}
export declare type RegularTransformOperator = "!" | "!!" | "~";
export declare type SpecialTransformOperator = "typeof";
export declare type TransformOperator = SpecialTransformOperator | RegularTransformOperator;
export interface TransformExpression {
    type: "trans";
    oper: TransformOperator;
    exp: Expression;
}
export interface FunctionExpression extends FunctionOptions {
    type: "func";
}
export declare type Expression = LiteralExpression | GetExpression | SetExpression | FunctionCallExpression | TernaryExpression | OperationExpression | TransformExpression | FunctionExpression;
export declare type ExpresionType = Expression["type"];
export interface SpreadExpression {
    type: "spread";
    exp: Expression;
}
export declare type SpreadableExpression = Expression | SpreadExpression;
export interface DeclareWithValue {
    id: string;
    value?: Expression;
}
export declare type VariableDeclaration = string | DeclareWithValue;
export interface DeprecatedDeclareStatement {
    type: "declare";
    set: SingleOrMulti<VariableDeclaration>;
}
export interface LetStatement {
    type: "let";
    declare: SingleOrMulti<VariableDeclaration>;
}
export interface IfStatement {
    type: "if";
    condition: Expression;
    then?: SingleOrMulti<FunctionStep>;
    otherwise?: SingleOrMulti<FunctionStep>;
}
export interface ForStatement {
    type: "for";
    target: Expression;
    value?: string;
    index?: string;
    body?: SingleOrMulti<FunctionStep>;
}
export interface BreakStatement {
    type: "break";
}
export interface ReturnStatement {
    type: "return";
    value: Expression;
}
export interface TryStatement {
    type: "try";
    body?: SingleOrMulti<FunctionStep>;
    error?: string;
    catch?: SingleOrMulti<FunctionStep>;
}
export interface ThrowStatement {
    type: "throw";
    msg: string | Expression;
}
export declare type Statement = DeprecatedDeclareStatement | LetStatement | IfStatement | ForStatement | BreakStatement | ReturnStatement | TryStatement | ThrowStatement;
export declare type StatementType = Statement["type"];
export declare type FunctionStep = Statement | Expression;
export interface StepReturn {
    type: "return";
    value: Expression;
}
export interface StepThrow {
    type: "throw";
    msg: string;
}
export declare type StepNonLoopResult = StepReturn | StepThrow | void;
export declare type StepLoopResult = "break" | StepNonLoopResult;
export declare type EnvLib = Record<string, any>;
export interface Environment extends EnvLib {
    parent: Environment | null;
}
export interface EnvFound<V> {
    env: Environment;
    id: string;
}
export declare type EnvBasedPopulator<R> = (env: Environment, target: R) => R;
export declare type EnvBasedResolver<V extends any = any> = (env: Environment) => V;
export declare type ArgsLibPopulator = (input: any[], lib: EnvLib) => EnvLib;
export interface CompileCache {
    param?: Record<string, ArgsLibPopulator>;
    let?: Record<string, EnvBasedResolver<void>>;
    spread?: Record<string, EnvBasedPopulator<any[]>>;
    exp?: Record<string, EnvBasedResolver>;
    step?: Record<string, EnvBasedResolver>;
}