@odoo/owl 3.0.0-alpha.13 → 3.0.0-alpha.15

package/dist/types/compiler/code_generator.d.ts

@@ -1,150 +1,150 @@
-import { AST, ASTComment, ASTComponent, ASTDebug, ASTDomNode, ASTLog, ASTMulti, ASTTCallSlot, ASTTCall, ASTTCallBlock, ASTText, ASTTForEach, ASTTif, ASTTKey, ASTTOut, ASTTPortal, ASTTranslation, ASTTranslationContext, ASTTSet, EventHandlers } from "./parser";
-type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
-export interface Config {
-    translateFn?: (s: string, translationCtx: string) => string;
-    translatableAttributes?: string[];
-    dev?: boolean;
-}
-export interface CodeGenOptions extends Config {
-    hasSafeContext?: boolean;
-    name?: string;
-    hasGlobalValues: boolean;
-}
-declare class BlockDescription {
-    static nextBlockId: number;
-    varName: string;
-    blockName: string;
-    dynamicTagName: string | null;
-    isRoot: boolean;
-    hasDynamicChildren: boolean;
-    children: BlockDescription[];
-    data: string[];
-    dom?: Node;
-    currentDom?: Element;
-    childNumber: number;
-    target: CodeTarget;
-    type: BlockType;
-    parentVar: string;
-    id: number;
-    constructor(target: CodeTarget, type: BlockType);
-    insertData(str: string, prefix?: string): number;
-    insert(dom: Node): void;
-    generateExpr(expr: string): string;
-    asXmlString(): string;
-}
-interface Context {
-    block: BlockDescription | null;
-    index: number | string;
-    forceNewBlock: boolean;
-    isLast?: boolean;
-    translate: boolean;
-    translationCtx: string;
-    tKeyExpr: string | null;
-    nameSpace?: string;
-    tModelSelectedExpr?: string;
-    ctxVar?: string;
-    inPreTag?: boolean;
-}
-declare class CodeTarget {
-    name: string;
-    indentLevel: number;
-    loopLevel: number;
-    code: string[];
-    hasRoot: boolean;
-    hasCache: boolean;
-    shouldProtectScope: boolean;
-    on: EventHandlers | null;
-    constructor(name: string, on?: EventHandlers | null);
-    addLine(line: string, idx?: number): void;
-    generateCode(): string;
-    currentKey(ctx: Context): string;
-}
-export declare class CodeGenerator {
-    blocks: BlockDescription[];
-    nextBlockId: number;
-    hasSafeContext: boolean;
-    isDebug: boolean;
-    targets: CodeTarget[];
-    target: CodeTarget;
-    templateName?: string;
-    dev: boolean;
-    translateFn: (s: string, translationCtx: string) => string;
-    translatableAttributes: string[];
-    ast: AST;
-    staticDefs: {
-        id: string;
-        expr: string;
-    }[];
-    slotNames: Set<String>;
-    helpers: Set<string>;
-    constructor(ast: AST, options: CodeGenOptions);
-    generateCode(): string;
-    compileInNewTarget(prefix: string, ast: AST, ctx: Context, on?: EventHandlers | null): string;
-    addLine(line: string, idx?: number): void;
-    define(varName: string, expr: string): void;
-    insertAnchor(block: BlockDescription, index?: number): void;
-    createBlock(parentBlock: BlockDescription | null, type: BlockType, ctx: Context): BlockDescription;
-    insertBlock(expression: string, block: BlockDescription, ctx: Context): void;
-    /**
-     * Captures variables that are used inside of an expression. This is useful
-     * because in compiled code, almost all variables are accessed through the ctx
-     * object. In the case of functions, that lookup in the context can be delayed
-     * which can cause issues if the value has changed since the function was
-     * defined.
-     *
-     * @param expr the expression to capture
-     * @param forceCapture whether the expression should capture its scope even if
-     *  it doesn't contain a function. Useful when the expression will be used as
-     *  a function body.
-     * @returns a new expression that uses the captured values
-     */
-    captureExpression(expr: string, forceCapture?: boolean): string;
-    translate(str: string, translationCtx: string): string;
-    /**
-     * @returns the newly created block name, if any
-     */
-    compileAST(ast: AST, ctx: Context): string | null;
-    compileDebug(ast: ASTDebug, ctx: Context): string | null;
-    compileLog(ast: ASTLog, ctx: Context): string | null;
-    compileComment(ast: ASTComment, ctx: Context): string;
-    compileText(ast: ASTText, ctx: Context): string;
-    generateHandlerCode(rawEvent: string, handler: string): string;
-    compileTDomNode(ast: ASTDomNode, ctx: Context): string;
-    compileTOut(ast: ASTTOut, ctx: Context): string;
-    compileTIfBranch(content: AST, block: BlockDescription, ctx: Context): void;
-    compileTIf(ast: ASTTif, ctx: Context, nextNode?: ASTDomNode): string;
-    compileTForeach(ast: ASTTForEach, ctx: Context): string;
-    compileTKey(ast: ASTTKey, ctx: Context): string | null;
-    compileMulti(ast: ASTMulti, ctx: Context): string | null;
-    compileTCall(ast: ASTTCall, ctx: Context): string;
-    compileTCallBlock(ast: ASTTCallBlock, ctx: Context): string;
-    compileTSet(ast: ASTTSet, ctx: Context): null;
-    generateComponentKey(currentKey?: string): string;
-    /**
-     * Formats a prop name and value into a string suitable to be inserted in the
-     * generated code. For example:
-     *
-     * Name              Value            Result
-     * ---------------------------------------------------------
-     * "number"          "state"          "number: ctx['state']"
-     * "something"       ""               "something: undefined"
-     * "some-prop"       "state"          "'some-prop': ctx['state']"
-     * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
-     */
-    formatProp(name: string, value: string, attrsTranslationCtx: {
-        [name: string]: string;
-    } | null, translationCtx: string): string;
-    formatPropObject(obj: {
-        [prop: string]: any;
-    }, attrsTranslationCtx: {
-        [name: string]: string;
-    } | null, translationCtx: string): string[];
-    getPropString(props: string[], dynProps: string | null): string;
-    compileComponent(ast: ASTComponent, ctx: Context): string;
-    wrapWithEventCatcher(expr: string, on: EventHandlers): string;
-    compileTCallSlot(ast: ASTTCallSlot, ctx: Context): string;
-    compileTTranslation(ast: ASTTranslation, ctx: Context): string | null;
-    compileTTranslationContext(ast: ASTTranslationContext, ctx: Context): string | null;
-    compileTPortal(ast: ASTTPortal, ctx: Context): string;
-}
-export {};
+import { AST, ASTComment, ASTComponent, ASTDebug, ASTDomNode, ASTLog, ASTMulti, ASTTCallSlot, ASTTCall, ASTTCallBlock, ASTText, ASTTForEach, ASTTif, ASTTKey, ASTTOut, ASTTPortal, ASTTranslation, ASTTranslationContext, ASTTSet, EventHandlers } from "./parser";
+type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
+export interface Config {
+    translateFn?: (s: string, translationCtx: string) => string;
+    translatableAttributes?: string[];
+    dev?: boolean;
+}
+export interface CodeGenOptions extends Config {
+    hasSafeContext?: boolean;
+    name?: string;
+    hasGlobalValues: boolean;
+}
+declare class BlockDescription {
+    static nextBlockId: number;
+    varName: string;
+    blockName: string;
+    dynamicTagName: string | null;
+    isRoot: boolean;
+    hasDynamicChildren: boolean;
+    children: BlockDescription[];
+    data: string[];
+    dom?: Node;
+    currentDom?: Element;
+    childNumber: number;
+    target: CodeTarget;
+    type: BlockType;
+    parentVar: string;
+    id: number;
+    constructor(target: CodeTarget, type: BlockType);
+    insertData(str: string, prefix?: string): number;
+    insert(dom: Node): void;
+    generateExpr(expr: string): string;
+    asXmlString(): string;
+}
+interface Context {
+    block: BlockDescription | null;
+    index: number | string;
+    forceNewBlock: boolean;
+    isLast?: boolean;
+    translate: boolean;
+    translationCtx: string;
+    tKeyExpr: string | null;
+    nameSpace?: string;
+    tModelSelectedExpr?: string;
+    ctxVar?: string;
+    inPreTag?: boolean;
+}
+declare class CodeTarget {
+    name: string;
+    indentLevel: number;
+    loopLevel: number;
+    code: string[];
+    hasRoot: boolean;
+    hasCache: boolean;
+    shouldProtectScope: boolean;
+    on: EventHandlers | null;
+    constructor(name: string, on?: EventHandlers | null);
+    addLine(line: string, idx?: number): void;
+    generateCode(): string;
+    currentKey(ctx: Context): string;
+}
+export declare class CodeGenerator {
+    blocks: BlockDescription[];
+    nextBlockId: number;
+    hasSafeContext: boolean;
+    isDebug: boolean;
+    targets: CodeTarget[];
+    target: CodeTarget;
+    templateName?: string;
+    dev: boolean;
+    translateFn: (s: string, translationCtx: string) => string;
+    translatableAttributes: string[];
+    ast: AST;
+    staticDefs: {
+        id: string;
+        expr: string;
+    }[];
+    slotNames: Set<String>;
+    helpers: Set<string>;
+    constructor(ast: AST, options: CodeGenOptions);
+    generateCode(): string;
+    compileInNewTarget(prefix: string, ast: AST, ctx: Context, on?: EventHandlers | null): string;
+    addLine(line: string, idx?: number): void;
+    define(varName: string, expr: string): void;
+    insertAnchor(block: BlockDescription, index?: number): void;
+    createBlock(parentBlock: BlockDescription | null, type: BlockType, ctx: Context): BlockDescription;
+    insertBlock(expression: string, block: BlockDescription, ctx: Context): void;
+    /**
+     * Captures variables that are used inside of an expression. This is useful
+     * because in compiled code, almost all variables are accessed through the ctx
+     * object. In the case of functions, that lookup in the context can be delayed
+     * which can cause issues if the value has changed since the function was
+     * defined.
+     *
+     * @param expr the expression to capture
+     * @param forceCapture whether the expression should capture its scope even if
+     *  it doesn't contain a function. Useful when the expression will be used as
+     *  a function body.
+     * @returns a new expression that uses the captured values
+     */
+    captureExpression(expr: string, forceCapture?: boolean): string;
+    translate(str: string, translationCtx: string): string;
+    /**
+     * @returns the newly created block name, if any
+     */
+    compileAST(ast: AST, ctx: Context): string | null;
+    compileDebug(ast: ASTDebug, ctx: Context): string | null;
+    compileLog(ast: ASTLog, ctx: Context): string | null;
+    compileComment(ast: ASTComment, ctx: Context): string;
+    compileText(ast: ASTText, ctx: Context): string;
+    generateHandlerCode(rawEvent: string, handler: string): string;
+    compileTDomNode(ast: ASTDomNode, ctx: Context): string;
+    compileTOut(ast: ASTTOut, ctx: Context): string;
+    compileTIfBranch(content: AST, block: BlockDescription, ctx: Context): void;
+    compileTIf(ast: ASTTif, ctx: Context, nextNode?: ASTDomNode): string;
+    compileTForeach(ast: ASTTForEach, ctx: Context): string;
+    compileTKey(ast: ASTTKey, ctx: Context): string | null;
+    compileMulti(ast: ASTMulti, ctx: Context): string | null;
+    compileTCall(ast: ASTTCall, ctx: Context): string;
+    compileTCallBlock(ast: ASTTCallBlock, ctx: Context): string;
+    compileTSet(ast: ASTTSet, ctx: Context): null;
+    generateComponentKey(currentKey?: string): string;
+    /**
+     * Formats a prop name and value into a string suitable to be inserted in the
+     * generated code. For example:
+     *
+     * Name              Value            Result
+     * ---------------------------------------------------------
+     * "number"          "state"          "number: ctx['state']"
+     * "something"       ""               "something: undefined"
+     * "some-prop"       "state"          "'some-prop': ctx['state']"
+     * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
+     */
+    formatProp(name: string, value: string, attrsTranslationCtx: {
+        [name: string]: string;
+    } | null, translationCtx: string): string;
+    formatPropObject(obj: {
+        [prop: string]: any;
+    }, attrsTranslationCtx: {
+        [name: string]: string;
+    } | null, translationCtx: string): string[];
+    getPropString(props: string[], dynProps: string | null): string;
+    compileComponent(ast: ASTComponent, ctx: Context): string;
+    wrapWithEventCatcher(expr: string, on: EventHandlers): string;
+    compileTCallSlot(ast: ASTTCallSlot, ctx: Context): string;
+    compileTTranslation(ast: ASTTranslation, ctx: Context): string | null;
+    compileTTranslationContext(ast: ASTTranslationContext, ctx: Context): string | null;
+    compileTPortal(ast: ASTTPortal, ctx: Context): string;
+}
+export {};

package/dist/types/compiler/index.d.ts

@@ -1,13 +1,13 @@
-import type { TemplateSet } from "../runtime/template_set";
-import type { BDom } from "../runtime/blockdom";
-import { Config } from "./code_generator";
-export type CustomDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
-export type Template = (context: any, vnode: any, key?: string) => BDom;
-export type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
-interface CompileOptions extends Config {
-    name?: string;
-    customDirectives?: CustomDirectives;
-    hasGlobalValues: boolean;
-}
-export declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
-export {};
+import type { TemplateSet } from "../runtime/template_set";
+import type { BDom } from "../runtime/blockdom";
+import { Config } from "./code_generator";
+export type CustomDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
+export type Template = (context: any, vnode: any, key?: string) => BDom;
+export type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
+interface CompileOptions extends Config {
+    name?: string;
+    customDirectives?: CustomDirectives;
+    hasGlobalValues: boolean;
+}
+export declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
+export {};

package/dist/types/compiler/inline_expressions.d.ts

@@ -1,59 +1,59 @@
-export interface QWebVar {
-    id: string;
-    expr: string;
-    value?: string;
-    hasBody?: boolean;
-}
-type TKind = "LEFT_BRACE" | "RIGHT_BRACE" | "LEFT_BRACKET" | "RIGHT_BRACKET" | "LEFT_PAREN" | "RIGHT_PAREN" | "COMMA" | "VALUE" | "TEMPLATE_STRING" | "SYMBOL" | "OPERATOR" | "COLON";
-interface Token {
-    type: TKind;
-    value: string;
-    originalValue?: string;
-    size?: number;
-    varName?: string;
-    replace?: Function;
-    isLocal?: boolean;
-}
-/**
- * Convert a javascript expression (as a string) into a list of tokens. For
- * example: `tokenize("1 + b")` will return:
- * ```js
- *  [
- *   {type: "VALUE", value: "1"},
- *   {type: "OPERATOR", value: "+"},
- *   {type: "SYMBOL", value: "b"}
- * ]
- * ```
- */
-export declare function tokenize(expr: string): Token[];
-/**
- * This is the main function exported by this file. This is the code that will
- * process an expression (given as a string) and returns another expression with
- * proper lookups in the context.
- *
- * Usually, this kind of code would be very simple to do if we had an AST (so,
- * if we had a javascript parser), since then, we would only need to find the
- * variables and replace them.  However, a parser is more complicated, and there
- * are no standard builtin parser API.
- *
- * Since this method is applied to simple javasript expressions, and the work to
- * be done is actually quite simple, we actually can get away with not using a
- * parser, which helps with the code size.
- *
- * Here is the heuristic used by this method to determine if a token is a
- * variable:
- * - by default, all symbols are considered a variable
- * - unless the previous token is a dot (in that case, this is a property: `a.b`)
- * - or if the previous token is a left brace or a comma, and the next token is
- *   a colon (in that case, this is an object key: `{a: b}`)
- *
- * Some specific code is also required to support arrow functions. If we detect
- * the arrow operator, then we add the current (or some previous tokens) token to
- * the list of variables so it does not get replaced by a lookup in the context
- */
-export declare function compileExprToArray(expr: string): Token[];
-export declare function compileExpr(expr: string): string;
-export declare const INTERP_REGEXP: RegExp;
-export declare function replaceDynamicParts(s: string, replacer: (s: string) => string): string;
-export declare function interpolate(s: string): string;
-export {};
+export interface QWebVar {
+    id: string;
+    expr: string;
+    value?: string;
+    hasBody?: boolean;
+}
+type TKind = "LEFT_BRACE" | "RIGHT_BRACE" | "LEFT_BRACKET" | "RIGHT_BRACKET" | "LEFT_PAREN" | "RIGHT_PAREN" | "COMMA" | "VALUE" | "TEMPLATE_STRING" | "SYMBOL" | "OPERATOR" | "COLON";
+interface Token {
+    type: TKind;
+    value: string;
+    originalValue?: string;
+    size?: number;
+    varName?: string;
+    replace?: Function;
+    isLocal?: boolean;
+}
+/**
+ * Convert a javascript expression (as a string) into a list of tokens. For
+ * example: `tokenize("1 + b")` will return:
+ * ```js
+ *  [
+ *   {type: "VALUE", value: "1"},
+ *   {type: "OPERATOR", value: "+"},
+ *   {type: "SYMBOL", value: "b"}
+ * ]
+ * ```
+ */
+export declare function tokenize(expr: string): Token[];
+/**
+ * This is the main function exported by this file. This is the code that will
+ * process an expression (given as a string) and returns another expression with
+ * proper lookups in the context.
+ *
+ * Usually, this kind of code would be very simple to do if we had an AST (so,
+ * if we had a javascript parser), since then, we would only need to find the
+ * variables and replace them.  However, a parser is more complicated, and there
+ * are no standard builtin parser API.
+ *
+ * Since this method is applied to simple javasript expressions, and the work to
+ * be done is actually quite simple, we actually can get away with not using a
+ * parser, which helps with the code size.
+ *
+ * Here is the heuristic used by this method to determine if a token is a
+ * variable:
+ * - by default, all symbols are considered a variable
+ * - unless the previous token is a dot (in that case, this is a property: `a.b`)
+ * - or if the previous token is a left brace or a comma, and the next token is
+ *   a colon (in that case, this is an object key: `{a: b}`)
+ *
+ * Some specific code is also required to support arrow functions. If we detect
+ * the arrow operator, then we add the current (or some previous tokens) token to
+ * the list of variables so it does not get replaced by a lookup in the context
+ */
+export declare function compileExprToArray(expr: string): Token[];
+export declare function compileExpr(expr: string): string;
+export declare const INTERP_REGEXP: RegExp;
+export declare function replaceDynamicParts(s: string, replacer: (s: string) => string): string;
+export declare function interpolate(s: string): string;
+export {};