bobe 0.0.31 → 0.0.33

package/dist/index.d.ts

@@ -1,78 +1,6 @@
+import { Queue } from 'bobe-shared';
 import { Store, Scope, Signal, Computed, Effect, SignalNode } from 'aoye';
 export * from 'aoye';
-import { Queue } from 'bobe-shared';
-
-declare class Tokenizer {
-    private hook;
-    useDedentAsEof: boolean;
-    /** 缩进大小 默认 2 */
-    TabSize: number;
-    /** 缩进字符 */
-    Tab: string;
-    /** Eof 标识符的值 */
-    static EofId: string;
-    static DedentId: string;
-    /** 当前 token */
-    token: Token;
-    /** 回车后需要判断缩进 */
-    needIndent: boolean;
-    /** 用于跳过第一个节点前的空白字符串，以及生成基础缩进 */
-    isFirstToken: boolean;
-    /** 代码 */
-    code: string;
-    /** 记录历史缩进的长度，相对于行首 */
-    dentStack: number[];
-    /** 当前字符 index */
-    i: number;
-    handledTokens: Token[];
-    /**
-     * 有些标识符能产生多个 token
-     * 例如 dedent
-     * parent1
-     *   child
-     *     subChild
-     * parent2 <- 产生两个 dedent
-     */
-    waitingTokens: Queue<Token>;
-    constructor(hook: Hook, useDedentAsEof: boolean);
-    consume(): Token;
-    resume(_snapshot: ReturnType<Tokenizer['snapshot']>): void;
-    snapshot(keys?: (keyof Tokenizer)[]): Partial<Tokenizer>;
-    skip(): string;
-    setCode(code: string): void;
-    tokenize(): void;
-    isEof(): boolean;
-    private setToken;
-    nextToken(): Token;
-    condExp(): Token;
-    /**
-     * 解析到 for 时使用这个方法获取 for 后方的子表达式
-     * 表达式通过 “;” 分割
-     * // 最多可有三个表达式
-     * for arr ; item index; item.key
-     * @returns {boolean} 是否含有 key
-     */
-    jsExp(): Token;
-    peekChar(): string;
-    private assignment;
-    private pipe;
-    private dynamic;
-    private brace;
-    private newLine;
-    private getDentValue;
-    private dent;
-    private shorterThanBaseDentEof;
-    private identifier;
-    private str;
-    private number;
-    private eof;
-    /** 模板字符串动态节点的占位符 */
-    HookId: string;
-    /** 模板字符串动态节点索引 */
-    hookI: number;
-    _hook: (props: Partial<HookProps>) => [HookType | undefined, any, hookI?: any];
-    init(fragments: string | string[]): void;
-}
 
 declare class Interpreter {
     private tokenizer;
@@ -80,8 +8,8 @@ declare class Interpreter {
     constructor(tokenizer: Tokenizer);
     isLogicNode(node: any): number;
     ctx: ProgramCtx;
-    rootComponent: ComponentNode | null;
-    program(root: any, componentNode?: ComponentNode, before?: any, ctxProvider?: any): ComponentNode;
+    rootComponent: ComponentNode$1 | null;
+    program(root: any, componentNode?: ComponentNode$1, before?: any, ctxProvider?: any): ComponentNode$1;
     insertAfterAnchor(name?: string): {
         name: string;
         nextSibling: any;
@@ -119,7 +47,7 @@ declare class Interpreter {
      *  */
     onePropParsed(data: Store, node: any, key: string, value: any, valueIsMapKey: boolean, isFn: boolean, hookI?: number): void;
     oneRealPropParsed: Interpreter['onePropParsed'];
-    componentOrFragmentDeclaration(ComponentOrRender: BobeUI | typeof Store, ctx: ProgramCtx): ComponentNode;
+    componentOrFragmentDeclaration(ComponentOrRender: BobeUI | typeof Store, ctx: ProgramCtx): ComponentNode$1;
     getFn(data: any, expression: string | number): any;
     condDeclaration(ctx: ProgramCtx): IfNode;
     removeLogicNode(node: LogicNode): void;
@@ -203,7 +131,9 @@ declare enum TokenType {
     Pipe = 32,
     Eof = 64,
     InsertionExp = 128,
-    Semicolon = 256
+    Semicolon = 256,
+    /** 仅编译时可解析 */
+    StaticInsExp = 512
 }
 declare enum FakeType {
     If = 1,
@@ -216,10 +146,21 @@ declare enum FakeType {
 }
 type NodeSortBit = number;
 type BaseType = string | number | boolean | undefined | null;
+interface SourceLocation {
+    start: Position;
+    end: Position;
+    source: string;
+}
+interface Position {
+    line: number;
+    column: number;
+    offset: number;
+}
 type Token = {
     type: TokenType;
     typeName: string;
     value: BaseType;
+    loc: SourceLocation;
 };
 type HookProps = {
     /** 通过哪个 HookId 进入的 */
@@ -263,7 +204,7 @@ type ForNode = Omit<LogicNode, 'data'> & {
     arrSignal: Signal<any[]> | Computed<any[]>;
     effect: Effect;
     i: number;
-    owner: ComponentNode | FragmentNode;
+    owner: ComponentNode$1 | FragmentNode$1;
     prevSibling: any;
     vars: string[];
 };
@@ -279,16 +220,239 @@ type IfNode = LogicNode & {
     snapshot: ReturnType<Tokenizer['snapshot']>;
     effect: Effect;
     preCond: IfNode | null;
-    owner: ComponentNode | FragmentNode;
+    owner: ComponentNode$1 | FragmentNode$1;
+};
+type FragmentNode$1 = LogicNode & {
+    tokenizer: Tokenizer;
 };
-type FragmentNode = LogicNode & {
+type ComponentNode$1 = LogicNode & {
     tokenizer: Tokenizer;
 };
-type ComponentNode = LogicNode & {
+
+declare class Tokenizer {
+    private hook;
+    useDedentAsEof: boolean;
+    /** 缩进大小 默认 2 */
+    TabSize: number;
+    /** 缩进字符 */
+    Tab: string;
+    /** Eof 标识符的值 */
+    static EofId: string;
+    static DedentId: string;
+    /** 当前 token */
+    token: Token;
+    /** 回车后需要判断缩进 */
+    needIndent: boolean;
+    /** 用于跳过第一个节点前的空白字符串，以及生成基础缩进 */
+    isFirstToken: boolean;
+    /** 代码 */
+    code: string;
+    /** 记录历史缩进的长度，相对于行首 */
+    dentStack: number[];
+    /** 当前字符 index */
+    i: number;
+    line: number;
+    column: number;
+    preCol: number;
+    preI: number;
+    needLoc: boolean;
+    handledTokens: Token[];
+    /**
+     * 有些标识符能产生多个 token
+     * 例如 dedent
+     * parent1
+     *   child
+     *     subChild
+     * parent2 <- 产生两个 dedent
+     */
+    waitingTokens: Queue<Token>;
+    /** 当前文件路径 */
+    source: string;
+    constructor(hook: Hook, useDedentAsEof: boolean);
+    private next;
+    getCurrentPos(): Position;
+    resume(_snapshot: ReturnType<Tokenizer['snapshot']>): void;
+    snapshot(keys?: (keyof Tokenizer)[]): Partial<Tokenizer>;
+    skip(): string;
+    setCode(code: string): void;
+    tokenize(): void;
+    isEof(): boolean;
+    private setToken;
+    nextToken(): Token;
+    condExp(): Token;
+    /**
+     * 解析到 for 时使用这个方法获取 for 后方的子表达式
+     * 表达式通过 “;” 分割
+     * // 最多可有三个表达式
+     * for arr ; item index; item.key
+     * @returns {boolean} 是否含有 key
+     */
+    jsExp(): Token;
+    peekChar(): string;
+    private assignment;
+    private pipe;
+    private staticIns;
+    private brace;
+    private newLine;
+    private getDentValue;
+    private dent;
+    private shorterThanBaseDentEof;
+    private identifier;
+    private str;
+    private number;
+    private eof;
+    /** 模板字符串动态节点的占位符 */
+    HookId: string;
+    /** 模板字符串动态节点索引 */
+    hookI: number;
+    _hook: (props: Partial<HookProps>) => [HookType | undefined, any, hookI?: any];
+    init(fragments: string | string[]): void;
+}
+
+declare enum NodeType {
+    Element = "Element",// 真实DOM节点
+    Text = "Text",// 文本节点
+    Interpolation = "Interpolation",// 插值节点
+    Property = "Property",// 属性节点
+    PropertyKey = "PropertyKey",// 属性节点
+    StaticValue = "StaticValue",// 静态值
+    DynamicValue = "DynamicValue",// 动态值（JS表达式）
+    Program = "Program",// 程序根节点
+    If = "If",
+    Else = "Else",
+    Fail = "Fail",
+    For = "For",
+    Component = "Component",
+    Fragment = "Fragment"
+}
+type ASTNodeType = NodeType;
+interface BaseNode {
+    type: ASTNodeType;
+    loc?: SourceLocation;
+}
+interface Program extends BaseNode {
+    type: NodeType.Program;
+    body: TemplateNode[];
+}
+type TemplateNode = ElementNode | TextNode | InterpolationNode | ConditionalNode | LoopNode | ComponentNode | FragmentNode;
+interface ElementNode extends BaseNode {
+    type: NodeType.Element;
+    tagName: string;
+    props: Property[];
+    children: TemplateNode[];
+}
+interface TextNode extends BaseNode {
+    type: NodeType.Text;
+    value: string;
+}
+interface InterpolationNode extends BaseNode {
+    type: NodeType.Interpolation;
+    expression: string;
+}
+interface Property extends BaseNode {
+    type: NodeType.Property;
+    key: PropertyKeyNode;
+    value?: PropertyValue;
+}
+type PropertyValue = StaticValue | DynamicValue;
+interface StaticValue extends BaseNode {
+    type: NodeType.StaticValue;
+    value: string | number | boolean;
+}
+interface PropertyKeyNode extends BaseNode {
+    type: NodeType.PropertyKey;
+    key: string;
+}
+interface DynamicValue extends BaseNode {
+    type: NodeType.DynamicValue;
+    value: string;
+}
+interface ConditionalNode extends BaseNode {
+    type: NodeType.If | NodeType.Else | NodeType.Fail;
+    condition: string;
+    consequent: TemplateNode[];
+    children?: TemplateNode[];
+}
+interface LoopNode extends BaseNode {
+    type: NodeType.For;
+    collection: string;
+    item: string;
+    index?: string;
+    key?: string;
+    children: TemplateNode[];
+}
+interface ComponentNode extends BaseNode {
+    type: NodeType.Component;
+    componentName: string;
+    props: Property[];
+    children?: TemplateNode[];
+}
+interface FragmentNode extends BaseNode {
+    type: NodeType.Fragment;
+    nodes: TemplateNode[];
+}
+
+declare class Compiler {
     tokenizer: Tokenizer;
+    hooks: ParseHooks;
+    constructor(tokenizer: Tokenizer, hooks?: ParseHooks);
+    /**
+     * 编译程序入口，生成AST
+     */
+    parseProgram(): Program;
+    handleChildren(): TemplateNode[];
+    /**
+     * 解析模板节点
+     */
+    private templateNode;
+    /**
+     * 解析元素节点
+     */
+    parseComponentNode(node?: ComponentNode): ComponentNode;
+    /**
+     * 解析元素节点
+     */
+    parseElementNode(node?: ElementNode): ElementNode;
+    /**
+     * 解析条件节点（if/else/fail）
+     */
+    parseConditionalNode(node?: ConditionalNode): ConditionalNode;
+    /**
+     * 解析循环节点（for）
+     */
+    parseLoopNode(node?: LoopNode): LoopNode;
+    /**
+     * 解析首行和扩展行的属性
+     */
+    private headerLineAndExtensions;
+    /**
+     * 解析属性列表
+     */
+    private attributeList;
+    parseProperty(node?: Property): Property;
+    /**
+     * 根据值类型创建属性 key 节点
+     */
+    parsePropertyKey(node?: PropertyKeyNode): PropertyKeyNode;
+    /**
+     * 根据值类型创建属性值节点
+     */
+    parsePropertyValue(node?: PropertyValue): PropertyValue;
+}
+type PickParseProps<T> = {
+    [K in keyof T as K extends `parse${string}` ? K : never]: T[K];
 };
+type ParseProps = PickParseProps<Compiler>;
+type ParseHooks = Partial<{
+    [K in keyof ParseProps]: {
+        enter?: (this: Compiler, ...args: Parameters<ParseProps[K]>) => void;
+        leave?: (this: Compiler, ...args: Parameters<ParseProps[K]>) => void;
+        propsAdded?: (this: Compiler, ...args: Parameters<ParseProps[K]>) => void;
+    };
+}>;
 
 declare function bobe(fragments: TemplateStringsArray, ...values: any[]): BobeUI;
-declare function customRender(option: CustomRenderConf): <T>(Ctor: typeof Store, root: any) => (ComponentNode | Store)[];
+declare function customRender(option: CustomRenderConf): <T>(Ctor: typeof Store, root: any) => (ComponentNode$1 | Store)[];
 
-export { bobe, customRender };
+export { Compiler, NodeType, Tokenizer, bobe, customRender };
+export type { ASTNodeType, BaseNode, ComponentNode, ConditionalNode, DynamicValue, ElementNode, FragmentNode, InterpolationNode, LoopNode, Program, Property, PropertyKeyNode, PropertyValue, StaticValue, TemplateNode, TextNode };