vsn 1.0.1 → 1.0.3

package/dist/index.d.cts

@@ -19,6 +19,9 @@ declare enum TokenType {
     While = "While",
     Try = "Try",
     Catch = "Catch",
+    Assert = "Assert",
+    Break = "Break",
+    Continue = "Continue",
     LBrace = "LBrace",
     RBrace = "RBrace",
     LParen = "LParen",
@@ -34,7 +37,9 @@ declare enum TokenType {
     Greater = "Greater",
     Less = "Less",
     Plus = "Plus",
+    PlusPlus = "PlusPlus",
     Minus = "Minus",
+    MinusMinus = "MinusMinus",
     Tilde = "Tilde",
     Star = "Star",
     Slash = "Slash",
@@ -112,17 +117,19 @@ interface ExecutionContext {
     element?: Element;
     returnValue?: any;
     returning?: boolean;
+    breaking?: boolean;
+    continuing?: boolean;
 }
 interface CFSNode {
     type: string;
     prepare(context: ExecutionContext): Promise<void>;
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare abstract class BaseNode implements CFSNode {
     type: string;
     constructor(type: string);
     prepare(_context: ExecutionContext): Promise<void>;
-    evaluate(_context: ExecutionContext): Promise<any>;
+    evaluate(_context: ExecutionContext): any;
 }
 declare class ProgramNode extends BaseNode {
     behaviors: BehaviorNode[];
@@ -148,7 +155,7 @@ declare class UseNode extends BaseNode {
 declare class BlockNode extends BaseNode {
     statements: CFSNode[];
     constructor(statements: CFSNode[]);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class SelectorNode extends BaseNode {
     selectorText: string;
@@ -157,51 +164,75 @@ declare class SelectorNode extends BaseNode {
 declare class BehaviorNode extends BaseNode {
     selector: SelectorNode;
     body: BlockNode;
-    constructor(selector: SelectorNode, body: BlockNode);
-}
-declare class StateEntryNode extends BaseNode {
-    name: string;
-    value: ExpressionNode;
-    important: boolean;
-    constructor(name: string, value: ExpressionNode, important: boolean);
-}
-declare class StateBlockNode extends BaseNode {
-    entries: StateEntryNode[];
-    constructor(entries: StateEntryNode[]);
+    flags: BehaviorFlags;
+    flagArgs: BehaviorFlagArgs;
+    constructor(selector: SelectorNode, body: BlockNode, flags?: BehaviorFlags, flagArgs?: BehaviorFlagArgs);
 }
 declare class OnBlockNode extends BaseNode {
     eventName: string;
     args: string[];
     body: BlockNode;
-    modifiers: string[];
-    constructor(eventName: string, args: string[], body: BlockNode, modifiers?: string[]);
+    flags: DeclarationFlags;
+    flagArgs: DeclarationFlagArgs;
+    constructor(eventName: string, args: string[], body: BlockNode, flags?: DeclarationFlags, flagArgs?: DeclarationFlagArgs);
 }
 declare class AssignmentNode extends BaseNode {
     target: AssignmentTarget;
     value: ExpressionNode;
-    operator: "=" | "+=" | "-=" | "*=" | "/=";
-    constructor(target: AssignmentTarget, value: ExpressionNode, operator?: "=" | "+=" | "-=" | "*=" | "/=");
-    evaluate(context: ExecutionContext): Promise<any>;
+    operator: "=" | "+=" | "-=" | "*=" | "/=" | "++" | "--";
+    prefix: boolean;
+    constructor(target: AssignmentTarget, value: ExpressionNode, operator?: "=" | "+=" | "-=" | "*=" | "/=" | "++" | "--", prefix?: boolean);
+    evaluate(context: ExecutionContext): any;
     private applyCompoundAssignment;
+    private applyIncrement;
+    private resolveAssignmentTarget;
+    private resolveIndexPath;
+    private resolveTargetPath;
     private assignTarget;
+    private assignDirectiveTarget;
 }
 declare class ReturnNode extends BaseNode {
     value?: ExpressionNode | undefined;
     constructor(value?: ExpressionNode | undefined);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
+}
+declare class BreakNode extends BaseNode {
+    constructor();
+    evaluate(context: ExecutionContext): any;
+}
+declare class ContinueNode extends BaseNode {
+    constructor();
+    evaluate(context: ExecutionContext): any;
+}
+declare class AssertError extends Error {
+    constructor(message?: string);
+}
+declare class AssertNode extends BaseNode {
+    test: ExpressionNode;
+    constructor(test: ExpressionNode);
+    evaluate(context: ExecutionContext): any;
 }
 declare class IfNode extends BaseNode {
     test: ExpressionNode;
     consequent: BlockNode;
     alternate?: BlockNode | undefined;
     constructor(test: ExpressionNode, consequent: BlockNode, alternate?: BlockNode | undefined);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class WhileNode extends BaseNode {
     test: ExpressionNode;
     body: BlockNode;
     constructor(test: ExpressionNode, body: BlockNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
+}
+declare class ForEachNode extends BaseNode {
+    target: IdentifierExpression;
+    iterable: ExpressionNode;
+    kind: "in" | "of";
+    body: BlockNode;
+    constructor(target: IdentifierExpression, iterable: ExpressionNode, kind: "in" | "of", body: BlockNode);
+    evaluate(context: ExecutionContext): any;
+    private getEntries;
 }
 declare class ForNode extends BaseNode {
     init: CFSNode | undefined;
@@ -209,14 +240,14 @@ declare class ForNode extends BaseNode {
     update: CFSNode | undefined;
     body: BlockNode;
     constructor(init: CFSNode | undefined, test: ExpressionNode | undefined, update: CFSNode | undefined, body: BlockNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class TryNode extends BaseNode {
     body: BlockNode;
     errorName: string;
     handler: BlockNode;
     constructor(body: BlockNode, errorName: string, handler: BlockNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class FunctionDeclarationNode extends BaseNode {
     name: string;
@@ -230,7 +261,7 @@ declare class FunctionExpression extends BaseNode {
     body: BlockNode;
     isAsync: boolean;
     constructor(params: FunctionParam[], body: BlockNode, isAsync?: boolean);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
     private applyParams;
     private restoreParams;
 }
@@ -244,6 +275,12 @@ interface DeclarationFlagArgs {
     debounce?: number;
     [key: string]: any;
 }
+interface BehaviorFlags {
+    [key: string]: boolean | undefined;
+}
+interface BehaviorFlagArgs {
+    [key: string]: any;
+}
 declare class DeclarationNode extends BaseNode {
     target: DeclarationTarget;
     operator: ":" | ":=" | ":<" | ":>";
@@ -252,9 +289,9 @@ declare class DeclarationNode extends BaseNode {
     flagArgs: DeclarationFlagArgs;
     constructor(target: DeclarationTarget, operator: ":" | ":=" | ":<" | ":>", value: ExpressionNode, flags: DeclarationFlags, flagArgs: DeclarationFlagArgs);
 }
-type ExpressionNode = IdentifierExpression | LiteralExpression | TemplateExpression | UnaryExpression | BinaryExpression | MemberExpression | CallExpression | ArrayExpression | ObjectExpression | IndexExpression | FunctionExpression | AwaitExpression | TernaryExpression | DirectiveExpression | QueryExpression;
+type ExpressionNode = AssignmentNode | IdentifierExpression | LiteralExpression | TemplateExpression | UnaryExpression | BinaryExpression | MemberExpression | CallExpression | ArrayExpression | ObjectExpression | IndexExpression | FunctionExpression | AwaitExpression | TernaryExpression | DirectiveExpression | QueryExpression;
 type DeclarationTarget = IdentifierExpression | DirectiveExpression;
-type AssignmentTarget = IdentifierExpression | DirectiveExpression | ArrayPattern | ObjectPattern;
+type AssignmentTarget = IdentifierExpression | MemberExpression | IndexExpression | DirectiveExpression | ArrayPattern | ObjectPattern;
 type FunctionParam = {
     name: string;
     defaultValue?: ExpressionNode;
@@ -264,7 +301,7 @@ type PatternNode = IdentifierExpression | ArrayPattern | ObjectPattern;
 declare class IdentifierExpression extends BaseNode {
     name: string;
     constructor(name: string);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class SpreadElement extends BaseNode {
     value: ExpressionNode;
@@ -292,40 +329,44 @@ declare class ObjectPattern extends BaseNode {
 declare class LiteralExpression extends BaseNode {
     value: string | number | boolean | null;
     constructor(value: string | number | boolean | null);
-    evaluate(): Promise<any>;
+    evaluate(): any;
 }
 declare class TemplateExpression extends BaseNode {
     parts: ExpressionNode[];
     constructor(parts: ExpressionNode[]);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class UnaryExpression extends BaseNode {
     operator: string;
     argument: ExpressionNode;
     constructor(operator: string, argument: ExpressionNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class BinaryExpression extends BaseNode {
     operator: string;
     left: ExpressionNode;
     right: ExpressionNode;
     constructor(operator: string, left: ExpressionNode, right: ExpressionNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class TernaryExpression extends BaseNode {
     test: ExpressionNode;
     consequent: ExpressionNode;
     alternate: ExpressionNode;
     constructor(test: ExpressionNode, consequent: ExpressionNode, alternate: ExpressionNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class MemberExpression extends BaseNode {
     target: ExpressionNode;
     property: string;
     optional: boolean;
     constructor(target: ExpressionNode, property: string, optional?: boolean);
-    evaluate(context: ExecutionContext): Promise<any>;
-    resolve(context: ExecutionContext): Promise<{
+    evaluate(context: ExecutionContext): any;
+    resolve(context: ExecutionContext): {
+        value: any;
+        target?: any;
+        optional?: boolean;
+    } | undefined | Promise<{
         value: any;
         target?: any;
         optional?: boolean;
@@ -343,14 +384,14 @@ declare class CallExpression extends BaseNode {
     callee: ExpressionNode;
     args: ExpressionNode[];
     constructor(callee: ExpressionNode, args: ExpressionNode[]);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
     private resolveCallee;
 }
 type ArrayElement = ExpressionNode | SpreadElement;
 declare class ArrayExpression extends BaseNode {
     elements: ArrayElement[];
     constructor(elements: ArrayElement[]);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 type ObjectEntry = {
     key: string;
@@ -366,46 +407,51 @@ type ObjectEntry = {
 declare class ObjectExpression extends BaseNode {
     entries: ObjectEntry[];
     constructor(entries: ObjectEntry[]);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class IndexExpression extends BaseNode {
     target: ExpressionNode;
     index: ExpressionNode;
     constructor(target: ExpressionNode, index: ExpressionNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
+    private normalizeIndexKey;
 }
 declare class DirectiveExpression extends BaseNode {
     kind: "attr" | "style";
     name: string;
     constructor(kind: "attr" | "style", name: string);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class AwaitExpression extends BaseNode {
     argument: ExpressionNode;
     constructor(argument: ExpressionNode);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 declare class QueryExpression extends BaseNode {
     direction: "self" | "descendant" | "ancestor";
     selector: string;
     constructor(direction: "self" | "descendant" | "ancestor", selector: string);
-    evaluate(context: ExecutionContext): Promise<any>;
+    evaluate(context: ExecutionContext): any;
 }
 
 declare class Parser {
     private stream;
     private source;
     private customFlags;
+    private behaviorFlags;
     private allowImplicitSemicolon;
     private awaitStack;
+    private functionDepth;
     constructor(input: string, options?: {
         customFlags?: Set<string>;
+        behaviorFlags?: Set<string>;
     });
     static parseInline(code: string): BlockNode;
     parseProgram(): ProgramNode;
     parseInlineBlock(): BlockNode;
     private parseBehavior;
     private parseSelector;
+    private parseBehaviorFlags;
     private parseUseStatement;
     private parseUseFlags;
     private wrapErrors;
@@ -413,9 +459,7 @@ declare class Parser {
     private getLineSnippet;
     private parseBlock;
     private parseStatement;
-    private parseStateBlock;
     private parseOnBlock;
-    private parseOnModifiers;
     private parseAssignment;
     private parseExpression;
     private parsePipeExpression;
@@ -429,6 +473,8 @@ declare class Parser {
     private parseMultiplicativeExpression;
     private parseAdditiveExpression;
     private parseUnaryExpression;
+    private parsePostfixExpression;
+    private createIncrementNode;
     private parseCallExpression;
     private parsePrimaryExpression;
     private parseArrayExpression;
@@ -447,10 +493,12 @@ declare class Parser {
     private parseDeclarationOperator;
     private parseFlags;
     private parseCustomFlagArg;
+    private parseCustomFlagLiteral;
+    private parseCustomFlagArray;
+    private parseCustomFlagObject;
     private isDeclarationStart;
     private isAssignmentStart;
     private isAssignmentOperatorStart;
-    private isCallStart;
     private isExpressionStatementStart;
     private isFunctionDeclarationStart;
     private isArrowFunctionStart;
@@ -458,8 +506,11 @@ declare class Parser {
     private isFunctionExpressionAssignmentStart;
     private parseExpressionStatement;
     private parseIfBlock;
+    private parseConditionalBody;
     private parseWhileBlock;
     private parseForBlock;
+    private detectForEachKind;
+    private parseForEachTarget;
     private parseForClause;
     private parseAssignmentExpression;
     private parseAssignmentOperator;
@@ -468,8 +519,10 @@ declare class Parser {
     private parseDestructBlock;
     private parseQueryExpression;
     private parseFunctionDeclaration;
-    private parseFunctionBlock;
     private parseReturnStatement;
+    private parseAssertStatement;
+    private parseBreakStatement;
+    private parseContinueStatement;
     private parseArrowFunctionExpression;
     private parseFunctionParams;
     private readSelectorUntil;
@@ -482,6 +535,7 @@ declare class Scope {
     private root;
     private listeners;
     private anyListeners;
+    isEachItem: boolean;
     constructor(parent?: Scope | undefined);
     createChild(): Scope;
     get(key: string): any;
@@ -499,6 +553,33 @@ declare class Scope {
     private findNearestScopeWithKey;
 }
 
+interface RegisteredBehavior {
+    id: number;
+    hash: string;
+    selector: string;
+    rootSelector: string;
+    parentSelector?: string;
+    specificity: number;
+    order: number;
+    construct?: BlockNode;
+    destruct?: BlockNode;
+    onBlocks: {
+        event: string;
+        body: BlockNode;
+        flags: DeclarationFlags;
+        flagArgs: DeclarationFlagArgs;
+        args: string[];
+    }[];
+    declarations: DeclarationNode[];
+    functions: FunctionBinding[];
+    flags: BehaviorFlags;
+    flagArgs: BehaviorFlagArgs;
+}
+type FunctionBinding = {
+    name: string;
+    params: FunctionParam[];
+    body: BlockNode;
+};
 type AttributeHandler = {
     id: string;
     match: (name: string) => boolean;
@@ -513,6 +594,40 @@ type FlagApplyContext = {
 };
 type FlagHandler = {
     onApply?: (context: FlagApplyContext) => void;
+    transformValue?: (context: FlagApplyContext, value: any) => any;
+    onEventBind?: (context: EventFlagContext) => EventBindPatch | void;
+    onEventBefore?: (context: EventFlagContext) => boolean | void;
+    onEventAfter?: (context: EventFlagContext) => void;
+    transformEventArgs?: (context: EventFlagContext, args: any[]) => any[];
+};
+type BehaviorModifierHandler = {
+    onBind?: (context: BehaviorModifierContext) => void | Promise<void>;
+    onConstruct?: (context: BehaviorModifierContext) => void | Promise<void>;
+    onDestruct?: (context: BehaviorModifierContext) => void | Promise<void>;
+    onUnbind?: (context: BehaviorModifierContext) => void | Promise<void>;
+};
+type BehaviorModifierContext = {
+    name: string;
+    args: any;
+    element: Element;
+    scope: Scope;
+    rootScope: Scope | undefined;
+    behavior: RegisteredBehavior;
+    engine: Engine;
+};
+type EventBindPatch = {
+    listenerTarget?: EventTarget;
+    options?: AddEventListenerOptions;
+    debounceMs?: number;
+};
+type EventFlagContext = {
+    name: string;
+    args: any;
+    element: Element;
+    scope: Scope;
+    rootScope: Scope | undefined;
+    event: Event | undefined;
+    engine: Engine;
 };
 type EngineOptions = {
     diagnostics?: boolean;
@@ -529,18 +644,19 @@ declare class Engine {
     private eachBindings;
     private lifecycleBindings;
     private behaviorRegistry;
+    private behaviorRegistryHashes;
     private behaviorBindings;
     private behaviorListeners;
     private behaviorId;
     private codeCache;
     private behaviorCache;
     private observer;
-    private observerRoot;
     private attributeHandlers;
     private globals;
     private importantFlags;
     private inlineDeclarations;
     private flagHandlers;
+    private behaviorModifiers;
     private pendingAdded;
     private pendingRemoved;
     private pendingUpdated;
@@ -549,13 +665,20 @@ declare class Engine {
     private diagnostics;
     private logger;
     private pendingUses;
+    private pendingAutoBindToScope;
+    private scopeWatchers;
+    private executionStack;
+    private groupProxyCache;
     constructor(options?: EngineOptions);
+    private getGroupTargetScope;
+    private getGroupProxy;
     mount(root: HTMLElement): Promise<void>;
     unmount(element: Element): void;
     registerBehaviors(source: string): void;
     registerGlobal(name: string, value: any): void;
     registerGlobals(values: Record<string, any>): void;
     registerFlag(name: string, handler?: FlagHandler): void;
+    registerBehaviorModifier(name: string, handler?: BehaviorModifierHandler): void;
     getRegistryStats(): {
         behaviorCount: number;
         behaviorCacheSize: number;
@@ -585,6 +708,14 @@ declare class Engine {
     private renderEach;
     private attachBindInputHandler;
     private parseBindDirection;
+    private resolveBindConfig;
+    private isFormControl;
+    private hasScopeValue;
+    private hasElementValue;
+    private coerceInt;
+    private coerceFloat;
+    private isInEachScope;
+    private flushAutoBindQueue;
     private hasVsnAttributes;
     private markInlineDeclaration;
     private isInlineDeclaration;
@@ -592,10 +723,12 @@ declare class Engine {
     private watch;
     private watchWithDebounce;
     private watchAllScopes;
+    private trackScopeWatcher;
+    private cleanupScopeWatchers;
+    private cleanupBehaviorListeners;
     private parseOnAttribute;
-    private parseEventDescriptor;
-    private matchesKeyModifiers;
-    private matchesTargetModifiers;
+    private parseInlineFlags;
+    private parseInlineFlagArg;
     private describeElement;
     private logDiagnostic;
     private emitError;
@@ -603,8 +736,13 @@ declare class Engine {
     private attachOnHandler;
     private attachBehaviorOnHandler;
     private attachGetHandler;
-    private applyEventModifiers;
-    private getListenerOptions;
+    private getEventBindingConfig;
+    private applyEventFlagBefore;
+    private applyEventFlagAfter;
+    private applyEventFlagArgTransforms;
+    private matchesKeyFlag;
+    private withExecutionElement;
+    getCurrentElement(): Element | undefined;
     private execute;
     private executeBlock;
     private safeExecute;
@@ -631,6 +769,9 @@ declare class Engine {
     private applyBehaviorDeclarations;
     private applyBehaviorDeclaration;
     private applyCustomFlags;
+    private applyCustomFlagTransforms;
+    private applyBehaviorModifierHook;
+    private behaviorHasModifierHooks;
     private applyDirectiveFromScope;
     private applyDirectiveFromExpression;
     private applyDirectiveToScope;
@@ -647,4 +788,4 @@ declare const VERSION = "0.1.0";
 declare function parseCFS(source: string): ProgramNode;
 declare function autoMount(root?: HTMLElement | Document): Engine | null;
 
-export { type ArrayElement, ArrayExpression, ArrayPattern, type ArrayPatternElement, AssignmentNode, type AssignmentTarget, AwaitExpression, BaseNode, BehaviorNode, BinaryExpression, BlockNode, type CFSNode, CallExpression, type DeclarationFlagArgs, type DeclarationFlags, DeclarationNode, type DeclarationTarget, DirectiveExpression, Engine, type ExecutionContext, type ExpressionNode, ForNode, FunctionDeclarationNode, FunctionExpression, type FunctionParam, IdentifierExpression, IfNode, IndexExpression, Lexer, LiteralExpression, MemberExpression, type ObjectEntry, ObjectExpression, ObjectPattern, type ObjectPatternEntry, OnBlockNode, Parser, type PatternNode, ProgramNode, QueryExpression, RestElement, ReturnNode, SelectorNode, SpreadElement, StateBlockNode, StateEntryNode, TemplateExpression, TernaryExpression, TokenType, TryNode, UnaryExpression, type UseFlagArgs, type UseFlags, UseNode, VERSION, WhileNode, autoMount, parseCFS };
+export { type ArrayElement, ArrayExpression, ArrayPattern, type ArrayPatternElement, AssertError, AssertNode, AssignmentNode, type AssignmentTarget, AwaitExpression, BaseNode, type BehaviorFlagArgs, type BehaviorFlags, BehaviorNode, BinaryExpression, BlockNode, BreakNode, type CFSNode, CallExpression, ContinueNode, type DeclarationFlagArgs, type DeclarationFlags, DeclarationNode, type DeclarationTarget, DirectiveExpression, Engine, type ExecutionContext, type ExpressionNode, ForEachNode, ForNode, FunctionDeclarationNode, FunctionExpression, type FunctionParam, IdentifierExpression, IfNode, IndexExpression, Lexer, LiteralExpression, MemberExpression, type ObjectEntry, ObjectExpression, ObjectPattern, type ObjectPatternEntry, OnBlockNode, Parser, type PatternNode, ProgramNode, QueryExpression, RestElement, ReturnNode, SelectorNode, SpreadElement, TemplateExpression, TernaryExpression, TokenType, TryNode, UnaryExpression, type UseFlagArgs, type UseFlags, UseNode, VERSION, WhileNode, autoMount, parseCFS };