@ibyar/expressions 0.5.4 → 0.5.6

package/api/definition/function.d.ts

@@ -1,34 +1,15 @@
-import type { CanDeclareExpression, ExpressionEventPath, ExpressionNode, NodeDeserializer, VisitNodeType } from '../expression.js';
-import type { Stack } from '../../scope/stack.js';
+import type { DeclarationExpression, ExpressionEventPath, ExpressionNode, NodeDeserializer, VisitNodeType } from '../expression.js';
+import { Stack } from '../../scope/stack.js';
 import { Scope } from '../../scope/scope.js';
 import { AbstractExpressionNode } from '../abstract.js';
-export declare enum FunctionKind {
-    NORMAL = "NORMAL",
-    ASYNC = "ASYNC",
-    GENERATOR = "GENERATOR",
-    ASYNC_GENERATOR = "ASYNC_GENERATOR",
-    CONCISE = "CONCISE",
-    ASYNC_CONCISE = "ASYNC_CONCISE",
-    CONCISE_GENERATOR = "CONCISE_GENERATOR",
-    ASYNC_CONCISE_GENERATOR = "ASYNC_CONCISE_GENERATOR",
-    STATIC_CONCISE = "STATIC_CONCISE",
-    STATIC_ASYNC_CONCISE = "STATIC_ASYNC_CONCISE",
-    STATIC_CONCISE_GENERATOR = "STATIC_CONCISE_GENERATOR",
-    STATIC_ASYNC_CONCISE_GENERATOR = "STATIC_ASYNC_CONCISE_GENERATOR",
-    DERIVED_CONSTRUCTOR = "DERIVED_CONSTRUCTOR",
-    BASE_CONSTRUCTOR = "BASE_CONSTRUCTOR"
-}
-export declare enum ArrowFunctionType {
-    NORMAL = "NORMAL",
-    ASYNC = "ASYNC"
-}
+import { Identifier } from './values.js';
 export declare class Param extends AbstractExpressionNode {
     private identifier;
     private defaultValue?;
     static fromJSON(node: Param, deserializer: NodeDeserializer): Param;
     static visit(node: Param, visitNode: VisitNodeType): void;
-    constructor(identifier: CanDeclareExpression, defaultValue?: ExpressionNode | undefined);
-    getIdentifier(): CanDeclareExpression;
+    constructor(identifier: DeclarationExpression, defaultValue?: ExpressionNode | undefined);
+    getIdentifier(): DeclarationExpression;
     getDefaultValue(): ExpressionNode | undefined;
     shareVariables(scopeList: Scope<any>[]): void;
     set(stack: Stack, value: Function): void;
@@ -38,56 +19,64 @@ export declare class Param extends AbstractExpressionNode {
     toString(): string;
     toJson(): object;
 }
-export declare abstract class FunctionBaseExpression extends AbstractExpressionNode {
+export declare abstract class BaseFunctionExpression extends AbstractExpressionNode {
     private sharedVariables;
     shareVariables(scopeList: Scope<any>[]): void;
     initFunctionScope(stack: Stack): Scope<any>[];
     clearFunctionScope(stack: Stack, innerScopes: Scope<any>[]): void;
 }
-export declare class FunctionExpression extends FunctionBaseExpression {
+export declare class FunctionExpression extends BaseFunctionExpression {
     protected params: ExpressionNode[];
-    protected body: ExpressionNode[];
-    protected kind: FunctionKind;
-    protected id?: CanDeclareExpression | undefined;
-    protected rest?: boolean | undefined;
-    protected generator?: boolean | undefined;
+    protected body: ExpressionNode;
+    protected async: boolean;
+    protected generator: boolean;
+    protected id?: Identifier | undefined;
     static fromJSON(node: FunctionExpression, deserializer: NodeDeserializer): FunctionExpression;
     static visit(node: FunctionExpression, visitNode: VisitNodeType): void;
-    constructor(params: ExpressionNode[], body: ExpressionNode[], kind: FunctionKind, id?: CanDeclareExpression | undefined, rest?: boolean | undefined, generator?: boolean | undefined);
+    constructor(params: ExpressionNode[], body: ExpressionNode, async: boolean, generator: boolean, id?: Identifier | undefined);
     getParams(): ExpressionNode[];
-    getBody(): ExpressionNode[];
-    getKind(): FunctionKind;
-    getId(): CanDeclareExpression | undefined;
-    getRest(): boolean | undefined;
+    getBody(): ExpressionNode;
+    getGenerator(): boolean;
+    getId(): Identifier | undefined;
+    getAsync(): boolean;
     set(stack: Stack, value: Function): void;
     setParameter(stack: Stack, args: any[]): void;
     get(stack: Stack): Function;
+    private getAsyncFunction;
+    private getGeneratorFunction;
+    private getAsyncGeneratorFunction;
+    private getFunction;
     dependency(computed?: true): ExpressionNode[];
     dependencyPath(computed?: true): ExpressionEventPath[];
     toString(): string;
+    paramsAndBodyToString(): string;
     toJson(): object;
 }
-export declare class FunctionDeclaration extends FunctionExpression {
+export declare class FunctionDeclaration extends FunctionExpression implements DeclarationExpression {
     static fromJSON(node: FunctionDeclaration, deserializer: NodeDeserializer): FunctionDeclaration;
     static visit(node: FunctionDeclaration, visitNode: VisitNodeType): void;
-    protected id?: CanDeclareExpression;
-    constructor(params: ExpressionNode[], body: ExpressionNode[], kind: FunctionKind, id?: CanDeclareExpression, rest?: boolean, generator?: boolean);
+    protected id: Identifier;
+    constructor(params: ExpressionNode[], body: ExpressionNode, async: boolean, generator: boolean, id: Identifier);
+    get(stack: Stack): Function;
+    declareVariable(stack: Stack, value: Function): void;
 }
-export declare class ArrowFunctionExpression extends FunctionBaseExpression {
+export declare class ArrowFunctionExpression extends BaseFunctionExpression {
     private params;
     private body;
-    private kind;
-    private rest?;
-    private generator?;
+    private expression;
+    private async;
     static fromJSON(node: ArrowFunctionExpression, deserializer: NodeDeserializer): ArrowFunctionExpression;
     static visit(node: ArrowFunctionExpression, visitNode: VisitNodeType): void;
-    constructor(params: ExpressionNode[], body: ExpressionNode | ExpressionNode[], kind: ArrowFunctionType, rest?: boolean | undefined, generator?: boolean | undefined);
+    private generator;
+    constructor(params: ExpressionNode[], body: ExpressionNode | ExpressionNode[], expression: boolean, async: boolean);
     getParams(): ExpressionNode[];
     getBody(): ExpressionNode | ExpressionNode[];
-    getRest(): boolean | undefined;
+    getExpression(): boolean;
     set(stack: Stack, value: Function): void;
     private setParameter;
-    get(stack: Stack): Function;
+    get(stack: Stack): void | ((...args: any[]) => any);
+    private getAsyncArrowFunction;
+    private getArrowFunction;
     dependency(computed?: true): ExpressionNode[];
     dependencyPath(computed?: true): ExpressionEventPath[];
     toString(): string;