@angular-wave/angular.ts 0.0.49 → 0.0.50

package/types/core/parser/lexer.d.ts

@@ -1,17 +1,17 @@
 /**
  * @typedef {Object} LexerOptions
- * @property {(ch: string, codePoint: number) => boolean} [isIdentifierStart] Custom function to determine if a character is a valid identifier start.
- * @property {(ch: string, codePoint: number) => boolean} [isIdentifierContinue] Custom function to determine if a character is a valid identifier continuation.
+ * @property {(ch: string, codePoint: number) => boolean} [isIdentifierStart] - Custom function to determine if a character is a valid identifier start.
+ * @property {(ch: string, codePoint: number) => boolean} [isIdentifierContinue] - Custom function to determine if a character is a valid identifier continuation.
  */
 /**
  * Represents a token produced by the lexer.
  * @typedef {Object} Token
- * @property {number} index Index of the token.
- * @property {string} text Text of the token.
- * @property {boolean} [identifier] Indicates if token is an identifier.
- * @property {boolean} [constant] Indicates if token is a constant.
- * @property {string|number} [value] Value of the token if it's a constant.
- * @property {boolean} [operator] Indicates if token is an operator.
+ * @property {number} index - Index of the token.
+ * @property {string} text - Text of the token.
+ * @property {boolean} [identifier] - Indicates if token is an identifier.
+ * @property {boolean} [constant] - Indicates if token is a constant.
+ * @property {string|number} [value] - Value of the token if it's a constant.
+ * @property {boolean} [operator] - Indicates if token is an operator.
  */
 /**
  * Represents a lexer that tokenizes input text. The Lexer takes the original expression string and returns an array of tokens parsed from that string.
@@ -20,7 +20,7 @@
 export class Lexer {
     /**
      * Creates an instance of Lexer.
-     * @param {LexerOptions} options Lexer options.
+     * @param {LexerOptions} options - Lexer options.
      */
     constructor(options: LexerOptions);
     /** @type {LexerOptions} */
@@ -114,11 +114,11 @@ export class Lexer {
 }
 export type LexerOptions = {
     /**
-     * Custom function to determine if a character is a valid identifier start.
+     * - Custom function to determine if a character is a valid identifier start.
      */
     isIdentifierStart?: (ch: string, codePoint: number) => boolean;
     /**
-     * Custom function to determine if a character is a valid identifier continuation.
+     * - Custom function to determine if a character is a valid identifier continuation.
      */
     isIdentifierContinue?: (ch: string, codePoint: number) => boolean;
 };
@@ -127,27 +127,27 @@ export type LexerOptions = {
  */
 export type Token = {
     /**
-     * Index of the token.
+     * - Index of the token.
      */
     index: number;
     /**
-     * Text of the token.
+     * - Text of the token.
      */
     text: string;
     /**
-     * Indicates if token is an identifier.
+     * - Indicates if token is an identifier.
      */
     identifier?: boolean;
     /**
-     * Indicates if token is a constant.
+     * - Indicates if token is a constant.
      */
     constant?: boolean;
     /**
-     * Value of the token if it's a constant.
+     * - Value of the token if it's a constant.
      */
     value?: string | number;
     /**
-     * Indicates if token is an operator.
+     * - Indicates if token is an operator.
      */
     operator?: boolean;
 };

package/types/core/parser/parse.d.ts

@@ -13,11 +13,6 @@ export class $ParseProvider {
      **/
     addLiteral: (literalName: string, literalValue: any) => void;
     /**
-     * @ngdoc method
-     * @name $parseProvider#setIdentifierFns
-     *
-     * @description
-     *
      * Allows defining the set of characters that are allowed in AngularJS expressions. The function
      * `identifierStart` will get called to know if a given character is a valid character to be the
      * first character for an identifier. The function `identifierContinue` will get called to know if
@@ -31,30 +26,34 @@ export class $ParseProvider {
      * Since this function will be called extensively, keep the implementation of these functions fast,
      * as the performance of these functions have a direct impact on the expressions parsing speed.
      *
-     * @param {function(any):boolean=} identifierStart The function that will decide whether the given character is
+     * @param {function(any):boolean} [identifierStart] The function that will decide whether the given character is
      *   a valid identifier start character.
-     * @param {function(any):boolean=} identifierContinue The function that will decide whether the given character is
+     * @param {function(any):boolean} [identifierContinue] The function that will decide whether the given character is
      *   a valid identifier continue character.
+     * @returns {$ParseProvider}
      */
-    setIdentifierFns: (identifierStart?: ((arg0: any) => boolean) | undefined, identifierContinue?: ((arg0: any) => boolean) | undefined) => this;
+    setIdentifierFns: (identifierStart?: (arg0: any) => boolean, identifierContinue?: (arg0: any) => boolean) => $ParseProvider;
     $get: (string | (($filter: any) => {
         (exp: any, interceptorFn: any): any;
-        $$getAst: (exp: any) => {
-            type: string;
-            body: {
-                type: string;
-                expression: any;
-            }[];
-        };
+        $$getAst: (exp: string) => import("./ast").ASTNode;
     }))[];
 }
-export function inputsWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
-export function oneTimeWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
-export function chainInterceptors(first: any, second: any): {
-    (value: any): any;
-    $stateful: any;
-    $$pure: any;
-};
+export function constantWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
+/**
+ * @typedef {function} CompiledExpression
+ * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
+ * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
+ * @returns {any}
+ * @property {boolean} literal - Indicates if the expression is a literal.
+ * @property {boolean} constant - Indicates if the expression is constant.
+ * @property {function(any, any): any} assign - Assigns a value to a context. If value is not provided,
+ * undefined is gonna be used since the implementation
+ * does not check the parameter. Let's force a value for consistency. If consumer
+ * wants to undefine it, pass the undefined value explicitly.
+ */
+/**
+ * @typedef {function(string|function(import('../scope/scope').Scope):any, function(any, import('../scope/scope').Scope, any):any=, boolean=): CompiledExpression} ParseService
+ */
 export const $parseMinErr: (arg0: string, ...arg1: any[]) => Error;
 export namespace literals {
     let _true: boolean;
@@ -65,4 +64,5 @@ export namespace literals {
     export { _null as null };
     export let undefined: any;
 }
-export type ParseService = (arg0: string | ((arg0: import("../scope/scope").Scope) => any), arg1: ((arg0: any, arg1: import("../scope/scope").Scope, arg2: any) => any) | undefined, arg2: boolean | undefined) => import("../../types").CompiledExpression;
+export type CompiledExpression = Function;
+export type ParseService = (arg0: string | ((arg0: import("../scope/scope").Scope) => any), arg1: ((arg0: any, arg1: import("../scope/scope").Scope, arg2: any) => any) | undefined, arg2: boolean | undefined) => CompiledExpression;

package/types/core/parser/parser.d.ts

@@ -1,3 +1,12 @@
+/**
+ * @typedef {Object} ParsedAST
+ * @property {import("./ast").ASTNode} ast - AST representation of expression
+ * @property {boolean} oneTime - True if expression should be evaluated only once
+ */
+/**
+ * @typedef {Object} ParserOptions
+ * @property {function(string):any} literals
+ */
 /**
  * @constructor
  */
@@ -5,24 +14,38 @@ export class Parser {
     /**
      *
      * @param {import('./lexer').Lexer} lexer
-     * @param {*} $filter
-     * @param {*} options
+     * @param {function(any):any} $filter
+     * @param {ParserOptions} options
      */
-    constructor(lexer: import("./lexer").Lexer, $filter: any, options: any);
+    constructor(lexer: import("./lexer").Lexer, $filter: (arg0: any) => any, options: ParserOptions);
+    /** @type {AST} */
     ast: AST;
-    astCompiler: ASTInterpreter | ASTCompiler;
-    parse(text: any): any;
-    getAst(exp: any): {
-        ast: {
-            type: string;
-            body: {
-                type: string;
-                expression: any;
-            }[];
-        };
-        oneTime: boolean;
-    };
+    /** @type {ASTInterpreter} */
+    astCompiler: ASTInterpreter;
+    /**
+     *
+     * @param {string} exp - Expression to be parsed
+     * @returns
+     */
+    parse(exp: string): any;
+    /**
+     * @param {string} exp - Expression to be parsed
+     * @returns {ParsedAST}
+     */
+    getAst(exp: string): ParsedAST;
 }
+export type ParsedAST = {
+    /**
+     * - AST representation of expression
+     */
+    ast: import("./ast").ASTNode;
+    /**
+     * - True if expression should be evaluated only once
+     */
+    oneTime: boolean;
+};
+export type ParserOptions = {
+    literals: (arg0: string) => any;
+};
 import { AST } from "./ast";
 import { ASTInterpreter } from "./interpreter";
-import { ASTCompiler } from "./compiler";

package/types/core/parser/shared.d.ts

@@ -11,7 +11,13 @@ export function ifDefined(v: any, d: any): any;
 export function plusFn(l: any, r: any): any;
 export function isStateless($filter: any, filterName: any): boolean;
 export function isPure(node: any, parentIsPure: any): any;
-export function findConstantAndWatchExpressions(ast: any, $filter: any, parentIsPure: any): void;
+/**
+ * Decorates ast with constant, toWatch, and isPure properties
+ * @param {import("./ast").ASTNode} ast
+ * @param {function(any):any} $filter
+ * @param {*} parentIsPure
+ */
+export function findConstantAndWatchExpressions(ast: import("./ast").ASTNode, $filter: (arg0: any) => any, parentIsPure: any): void;
 export function getInputs(body: any): any;
 export function isAssignable(ast: any): boolean;
 export function assignableAST(ast: any): {

package/types/shared/jqlite/jqlite.d.ts

@@ -66,16 +66,16 @@ export class JQLite {
     /**
      * Gets or sets data on a parent element
      * @param {string} name
-     * @param {any} value
+     * @param {any} [value]
      * @returns {JQLite|any}
      */
-    inheritedData(name: string, value: any): JQLite | any;
+    inheritedData(name: string, value?: any): JQLite | any;
     /**
      * Gets or sets innerHTML on the first element in JQLite collection
-     * @param {string} value
+     * @param {string} [value]
      * @returns {JQLite|any|undefined}
      */
-    html(value: string): JQLite | any | undefined;
+    html(value?: string): JQLite | any | undefined;
     /**
      * Get the combined text contents of each element in the JQLite collection
      * or set the text contents of all elements.

package/types/types.d.ts

@@ -1,6 +1,6 @@
 export type BootstrapConfig = any;
 export type Injectable<T_1> = Function | Array<string | Function>;
-export type CompiledExpression = any | ((arg0: any, arg1: any | undefined) => any);
+export type CompiledExpression = Function;
 export type ComponentOptions = any;
 export type ControllerConstructor = Function;
 export type OnChangesObject = any;