@angular-wave/angular.ts 0.14.2 → 0.15.0

package/@types/core/parse/ast/ast.d.ts

@@ -7,8 +7,8 @@ export class AST {
    */
   constructor(lexer: import("../lexer/lexer.js").Lexer);
   /** @type {import('../lexer/lexer.js').Lexer} */
-  lexer: import("../lexer/lexer.js").Lexer;
-  selfReferential: {
+  _lexer: import("../lexer/lexer.js").Lexer;
+  _selfReferential: {
     this: {
       type: number;
     };
@@ -16,149 +16,140 @@ export class AST {
       type: number;
     };
   };
+  _index: number;
   /**
    * Parses the input text and generates an AST.
    * @param {string} text - The input text to parse.
    * @returns {ASTNode} The root node of the AST.
    */
-  ast(text: string): ASTNode;
-  text: string;
-  tokens: import("../lexer/token.js").Token[];
+  _ast(text: string): ASTNode;
+  _text: string;
+  _tokens: import("../lexer/token.js").Token[];
   /**
    * Parses a program.
    * @returns {ASTNode} The program node.
    */
-  program(): ASTNode;
+  _program(): ASTNode;
   /**
    * Parses an expression statement.
    * @returns {ASTNode} The expression statement node.
    */
-  expressionStatement(): ASTNode;
+  _expressionStatement(): ASTNode;
   /**
    * Parses a filter chain.
    * @returns {ASTNode} The filter chain node.
    */
-  filterChain(): ASTNode;
+  _filterChain(): ASTNode;
   /**
    * Parses an assignment expression.
    * @returns {ASTNode} The assignment expression node.
    */
-  assignment(): ASTNode;
+  _assignment(): ASTNode;
   /**
    * Parses a ternary expression.
    * @returns {ASTNode} The ternary expression node.
    */
-  ternary(): ASTNode;
+  _ternary(): ASTNode;
   /**
    * Parses a logical OR expression.
    * @returns {ASTNode} The logical OR expression node.
    */
-  logicalOR(): ASTNode;
+  _logicalOR(): ASTNode;
   /**
    * Parses a logical AND expression.
    * @returns {ASTNode} The logical AND expression node.
    */
-  logicalAND(): ASTNode;
+  _logicalAND(): ASTNode;
   /**
    * Parses an equality expression.
    * @returns {ASTNode} The equality expression node.
    */
-  equality(): ASTNode;
+  _equality(): ASTNode;
   /**
    * Parses a relational expression.
    * @returns {ASTNode} The relational expression node.
    */
-  relational(): ASTNode;
+  _relational(): ASTNode;
   /**
    * Parses an additive expression.
    * @returns {ASTNode} The additive expression node.
    */
-  additive(): ASTNode;
+  _additive(): ASTNode;
   /**
    * Parses a multiplicative expression.
    * @returns {ASTNode} The multiplicative expression node.
    */
-  multiplicative(): ASTNode;
+  _multiplicative(): ASTNode;
   /**
    * Parses a unary expression.
    * @returns {ASTNode} The unary expression node.
    */
-  unary(): ASTNode;
+  _unary(): ASTNode;
   /**
    * Parses a primary expression.
    * @returns {ASTNode} The primary expression node.
    */
-  primary(): ASTNode;
+  _primary(): ASTNode;
   /**
    * Parses a filter.
    * @param {ASTNode} baseExpression - The base expression to apply the filter to.
    * @returns {ASTNode} The filter node.
    */
-  filter(baseExpression: ASTNode): ASTNode;
+  _filter(baseExpression: ASTNode): ASTNode;
   /**
    * Parses function arguments.
    * @returns {ASTNode[]} The arguments array.
    */
-  parseArguments(): ASTNode[];
+  _parseArguments(): ASTNode[];
   /**
    * Parses an identifier.
    * @returns {ASTNode} The identifier node.
    */
-  identifier(): ASTNode;
+  _identifier(): ASTNode;
   /**
    * Parses a constant.
    * @returns {ASTNode} The constant node.
    */
-  constant(): ASTNode;
+  _constant(): ASTNode;
   /**
    * Parses an array declaration.
    * @returns {ASTNode} The array declaration node.
    */
-  arrayDeclaration(): ASTNode;
+  _arrayDeclaration(): ASTNode;
   /**
    * Parses an object.
    * @returns {ASTNode} The object node.
    */
-  object(): ASTNode;
+  _object(): ASTNode;
   /**
    * Throws a syntax error.
    * @param {string} msg - The error message.
    * @param {import("../lexer/lexer.js").Token} [token] - The token that caused the error.
    */
-  throwError(msg: string, token?: import("../lexer/lexer.js").Token): void;
+  _throwError(msg: string, token?: import("../lexer/lexer.js").Token): void;
   /**
    * Consumes a token if it matches the expected type.
    * @param {string} [e1] - The expected token type.
    * @returns {import("../lexer/lexer.js").Token} The consumed token.
    */
-  consume(e1?: string): import("../lexer/lexer.js").Token;
+  _consume(e1?: string): import("../lexer/lexer.js").Token;
   /**
    * Returns the next token without consuming it.
    * @returns {import("../lexer/lexer.js").Token} The next token.
    */
-  peekToken(): import("../lexer/lexer.js").Token;
+  _peekToken(): import("../lexer/lexer.js").Token;
   /**
    * Checks if the next token matches any of the expected types.
    * @param {...string} [expected] - The expected token types.
    * @returns {import('../lexer/lexer.js').Token|boolean} The next token if it matches, otherwise false.
    */
-  peek(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
-  /**
-   * Checks if the token at the specified index matches any of the expected types.
-   * @param {number} i - The index to check.
-   * @param {...string} [expected] - The expected token types.
-   * @returns {import("../lexer/lexer.js").Token|boolean} The token at the specified index if it matches, otherwise false.
-   */
-  peekAhead(
-    i: number,
-    ...expected: string[]
-  ): import("../lexer/lexer.js").Token | boolean;
+  _peek(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
   /**
    * Consumes the next token if it matches any of the expected types.
    * @param {...string} [expected] - The expected token types.
    * @returns {import("../lexer/lexer.js").Token|boolean} The consumed token if it matches, otherwise false.
    */
-  expect(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
+  _expect(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
 }
 export type ASTNode = import("./ast-node.ts").ASTNode;
 export type Token = import("../lexer/token.js").Token;

package/@types/core/parse/ast-type.d.ts

@@ -1,20 +1,20 @@
 export type ASTType = number;
 export namespace ASTType {
-  let Program: number;
-  let ExpressionStatement: number;
-  let AssignmentExpression: number;
-  let ConditionalExpression: number;
-  let LogicalExpression: number;
-  let BinaryExpression: number;
-  let UnaryExpression: number;
-  let CallExpression: number;
-  let MemberExpression: number;
-  let Identifier: number;
-  let Literal: number;
-  let ArrayExpression: number;
-  let Property: number;
-  let ObjectExpression: number;
-  let ThisExpression: number;
-  let LocalsExpression: number;
+  let _Program: number;
+  let _ExpressionStatement: number;
+  let _AssignmentExpression: number;
+  let _ConditionalExpression: number;
+  let _LogicalExpression: number;
+  let _BinaryExpression: number;
+  let _UnaryExpression: number;
+  let _CallExpression: number;
+  let _MemberExpression: number;
+  let _Identifier: number;
+  let _Literal: number;
+  let _ArrayExpression: number;
+  let _Property: number;
+  let _ObjectExpression: number;
+  let _ThisExpression: number;
+  let _LocalsExpression: number;
   let NGValueParameter: number;
 }

package/@types/core/parse/interface.d.ts

@@ -41,7 +41,7 @@ export interface CompiledExpressionProps {
  * Evaluates the compiled expression.
  */
 export type CompiledExpressionFunction = (
-  context?: Scope,
+  context?: Scope | typeof Proxy<Scope>,
   locals?: object,
   assign?: any,
 ) => any;

package/@types/core/parse/interpreter.d.ts

@@ -10,25 +10,15 @@ export class ASTInterpreter {
    * @param {function(any):any} $filter
    */
   constructor($filter: (arg0: any) => any);
-  $filter: (arg0: any) => any;
+  _$filter: (arg0: any) => any;
   /**
    * Compiles the AST into a function.
-   * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
+   * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.
    * @returns {import("./interface.ts").CompiledExpression}
    */
-  compile(ast: any): import("./interface.ts").CompiledExpression;
-  /**
-   * Recurses the AST nodes.
-   * @param {import("./ast/ast").ASTNode} ast - The AST node.
-   * @param {Object} [context] - The context.
-   * @param {boolean|1} [create] - The create flag.
-   * @returns {import("./interface.ts").CompiledExpressionFunction} The recursive function.
-   */
-  recurse(
-    ast: any,
-    context?: any,
-    create?: boolean | 1,
-  ): import("./interface.ts").CompiledExpressionFunction;
+  compile(
+    ast: import("./ast/ast.js").ASTNode,
+  ): import("./interface.ts").CompiledExpression;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.
@@ -211,20 +201,6 @@ export class ASTInterpreter {
     context?: any,
     create?: boolean | 1,
   ): import("./interface.ts").CompiledExpressionFunction;
-  /**
-   * Returns the value of a computed member expression.
-   * @param {function} left - The left operand function.
-   * @param {function} right - The right operand function.
-   * @param {Object} [context] - The context.
-   * @param {boolean|1} [create] - Whether to create the member if it does not exist.
-   * @returns {function} The function returning the computed member value.
-   */
-  computedMember(
-    left: Function,
-    right: Function,
-    context?: any,
-    create?: boolean | 1,
-  ): Function;
   /**
    * Returns the value of a non-computed member expression.
    * @param {function} left - The left operand function.
@@ -239,6 +215,7 @@ export class ASTInterpreter {
     context?: any,
     create?: boolean | 1,
   ): Function;
+  #private;
 }
 export type DecoratedASTNode = any & {
   isPure: boolean | number;

package/@types/core/parse/lexer/lexer.d.ts

@@ -14,71 +14,71 @@ export class Lexer {
    */
   constructor(options: LexerOptions);
   /** @type {LexerOptions} */
-  options: LexerOptions;
+  _options: LexerOptions;
   /**
    * Tokenizes the input text.
    * @param {string} text Input text to lex.
    * @returns {Array<Token>} Array of tokens.
    */
-  lex(text: string): Array<Token>;
-  text: string;
-  index: number;
+  _lex(text: string): Array<Token>;
+  _text: string;
+  _index: number;
   /** @type {Array<Token>} */
-  tokens: Array<Token>;
+  _tokens: Array<Token>;
   /**
    * Checks if a character is contained in a set of characters.
    * @param {string} ch Character to check.
    * @param {string} chars Set of characters.
    * @returns {boolean} True if character is in the set, false otherwise.
    */
-  is(ch: string, chars: string): boolean;
+  _is(ch: string, chars: string): boolean;
   /**
    * Peeks at the next character in the text.
    * @param {number} [i=1] Number of characters to peek.
    * @returns {string|false} Next character or false if end of text.
    */
-  peek(i?: number): string | false;
+  _peek(i?: number): string | false;
   /**
    * Checks if a character is a number.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is a number, false otherwise.
    */
-  isNumber(ch: string): boolean;
+  _isNumber(ch: string): boolean;
   /**
    * Checks if a character is whitespace.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is whitespace, false otherwise.
    */
-  isWhitespace(ch: string): boolean;
+  _isWhitespace(ch: string): boolean;
   /**
    * Checks if a character is a valid identifier start.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is a valid identifier start, false otherwise.
    */
-  isIdentifierStart(ch: string): boolean;
+  _isIdentifierStart(ch: string): boolean;
   /**
    * Checks if a character is a valid identifier continuation.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is a valid identifier continuation, false otherwise.
    */
-  isIdentifierContinue(ch: string): boolean;
+  _isIdentifierContinue(ch: string): boolean;
   /**
    * Converts a character to its Unicode code point.
    * @param {string} ch Character to convert.
    * @returns {number} Unicode code point.
    */
-  codePointAt(ch: string): number;
+  _codePointAt(ch: string): number;
   /**
    * Peeks at the next multicharacter sequence in the text.
    * @returns {string} Next multicharacter sequence.
    */
-  peekMultichar(): string;
+  _peekMultichar(): string;
   /**
    * Checks if a character is an exponent operator.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is an exponent operator, false otherwise.
    */
-  isExpOperator(ch: string): boolean;
+  _isExpOperator(ch: string): boolean;
   /**
    * Throws a lexer error.
    * @param {string} error Error message.
@@ -86,25 +86,25 @@ export class Lexer {
    * @param {number} [end] End index.
    * @throws {Error} Lexer error.
    */
-  throwError(error: string, start?: number, end?: number): void;
+  _throwError(error: string, start?: number, end?: number): void;
   /**
    * Reads and tokenizes a number from the text.
    * @return {void}
    */
-  readNumber(): void;
+  _readNumber(): void;
   /**
    * Reads and tokenizes an identifier from the text.
    */
-  readIdent(): void;
+  _readIdent(): void;
   /**
    * Reads and tokenizes a string from the text.
    * @param {string} quote Quote character used for the string.
    */
-  readString(quote: string): void;
+  _readString(quote: string): void;
   /**
    * @returns {string}
    */
-  handleUnicodeEscape(): string;
+  _handleUnicodeEscape(): string;
 }
 export type Token = import("./token.ts").Token;
 export type LexerOptions = {

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

@@ -16,20 +16,15 @@ export class Parser {
     $filter: (arg0: any) => any,
   );
   /** @type {AST} */
-  ast: AST;
+  _ast: AST;
   /** @type {ASTInterpreter} */
-  astCompiler: ASTInterpreter;
+  _astCompiler: ASTInterpreter;
   /**
-   *
    * @param {string} exp - Expression to be parsed
    * @returns {import("../interface.ts").CompiledExpression}
    */
-  parse(exp: string): import("../interface.ts").CompiledExpression;
-  /**
-   * @param {string} exp - Expression to be parsed
-   * @returns {ParsedAST}
-   */
-  getAst(exp: string): ParsedAST;
+  _parse(exp: string): import("../interface.ts").CompiledExpression;
+  #private;
 }
 export type ParsedAST = {
   /**

package/@types/core/scope/interface.d.ts

@@ -1,10 +1,4 @@
 import type { CompiledExpression } from "../parse/interface.ts";
-import { Scope } from "./scope.js";
-export interface AsyncQueueTask {
-  handler: Scope;
-  fn: (...args: any[]) => any;
-  locals: Record<string, any>;
-}
 export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
 export interface Listener {
   originalTarget: any;

package/@types/core/scope/scope.d.ts

@@ -1,5 +1,5 @@
-export function nextId(): number;
 /**
+ * @private
  * Creates a deep proxy for the target object, intercepting property changes
  * and recursively applying proxies to nested objects.
  *
@@ -16,12 +16,8 @@ export function createScope(target?: any, context?: Scope): Scope;
  * @returns {boolean}
  */
 export function isNonScope(target: any): boolean;
-/**
- * Decorator for excluding objects from scope observability
- */
-export const NONSCOPE: "$nonscope";
-export const $postUpdateQueue: any[];
-export let rootScope: any;
+/** @ignore @type {Function[]}*/
+export const $postUpdateQueue: Function[];
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
@@ -53,7 +49,7 @@ export class Scope {
   $$listeners: Map<string, Function[]>;
   /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
   foreignListeners: Map<string, Array<import("./interface.ts").Listener>>;
-  /** @type {Set<ProxyConstructor>} */
+  /** @type {Set<Proxy<ng.Scope>>} */
   foreignProxies: Set<ProxyConstructor>;
   /** @type {WeakMap<Object, Array<string>>} */
   objectListeners: WeakMap<any, Array<string>>;
@@ -65,8 +61,8 @@ export class Scope {
       fn: Function;
     }
   >;
-  /** Current proxy being operated on */
-  $proxy: any;
+  /** @type {Proxy<Scope>} Current proxy being operated on */
+  $proxy: ProxyConstructor;
   /** @type {Scope} The actual proxy */
   $handler: Scope;
   /** @type {*} Current target being called on */
@@ -100,7 +96,7 @@ export class Scope {
    * @param {Object} target - The target object.
    * @param {string} property - The name of the property being set.
    * @param {*} value - The new value being assigned to the property.
-   * @param {Proxy} proxy - The proxy intercepting property access
+   * @param {Proxy<Scope>} proxy - The proxy intercepting property access
    * @returns {boolean} - Returns true to indicate success of the operation.
    */
   set(
@@ -116,7 +112,7 @@ export class Scope {
    *
    * @param {Object} target - The target object.
    * @param {string|number|symbol} property - The name of the property being accessed.
-   * @param {Proxy} proxy - The proxy object being invoked
+   * @param {Proxy<Scope>} proxy - The proxy object being invoked
    * @returns {*} - The value of the property or a method if accessing `watch` or `sync`.
    */
   get(
@@ -182,6 +178,10 @@ export class Scope {
    * @returns {Scope|undefined}
    */
   $getById(id: string | number): Scope | undefined;
-  $searchByName(name: any): any;
+  /**
+   * @param {string} name
+   * @returns {ng.Scope|undefined}
+   */
+  $searchByName(name: string): ng.Scope | undefined;
   #private;
 }

package/@types/directive/attrs/attrs.d.ts

@@ -1,8 +1,5 @@
 export const REGEX_STRING_REGEXP: RegExp;
 /**
- * @type {Record<string, import("../../interface.ts").DirectiveFactory>}
+ * @type {Record<string, ng.DirectiveFactory>}
  */
-export const ngAttributeAliasDirectives: Record<
-  string,
-  import("../../interface.ts").DirectiveFactory
->;
+export const ngAttributeAliasDirectives: Record<string, ng.DirectiveFactory>;

package/@types/directive/class/class.d.ts

@@ -1,3 +1,3 @@
-export const ngClassDirective: ng.DirectiveFactory;
-export const ngClassOddDirective: ng.DirectiveFactory;
-export const ngClassEvenDirective: ng.DirectiveFactory;
+export const ngClassDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassOddDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassEvenDirective: import("../../interface.ts").DirectiveFactory;

package/@types/directive/controller/controller.d.ts

@@ -1,4 +1,4 @@
 /**
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngControllerDirective(): import("../../interface.ts").Directive;
+export function ngControllerDirective(): ng.Directive;

package/@types/directive/form/form.d.ts

@@ -78,17 +78,17 @@ export class FormController {
    * @param {ng.Attributes} $attrs
    * @param {ng.Scope} $scope
    * @param {ng.AnimateService} $animate
-   * @param {*} $interpolate
+   * @param {ng.InterpolateService} $interpolate
    */
   constructor(
     $element: Element,
     $attrs: ng.Attributes,
     $scope: ng.Scope,
     $animate: ng.AnimateService,
-    $interpolate: any,
+    $interpolate: ng.InterpolateService,
   );
   $$controls: any[];
-  $name: any;
+  $name: string;
   /**
    * @property {boolean} $dirty True if user has already interacted with the form.
    */
@@ -103,7 +103,7 @@ export class FormController {
   /** @type {FormController|Object} */
   $$parentForm: FormController | any;
   $$element: Element;
-  $$animate: import("../../interface.ts").AnimateService;
+  $$animate: import("../../animations/interface.ts").AnimateService;
   $error: {};
   $$success: {};
   $pending: any;

package/@types/directive/include/include.d.ts

@@ -1,14 +1,14 @@
 /**
  *
  * @param {ng.TemplateRequestService} $templateRequest
- * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
+ * @param {ng.AnchorScrollService} $anchorScroll
  * @param {ng.AnimateService} $animate
  * @param {ng.ExceptionHandlerService} $exceptionHandler
  * @returns {ng.Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: ng.TemplateRequestService,
-  $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
+  $anchorScroll: ng.AnchorScrollService,
   $animate: ng.AnimateService,
   $exceptionHandler: ng.ExceptionHandlerService,
 ): ng.Directive;
@@ -17,11 +17,11 @@ export namespace ngIncludeDirective {
 }
 /**
  * @param {ng.CompileService} $compile
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
 export function ngIncludeFillContentDirective(
   $compile: ng.CompileService,
-): import("../../interface.ts").Directive;
+): ng.Directive;
 export namespace ngIncludeFillContentDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };

package/@types/directive/messages/messages.d.ts

@@ -8,14 +8,15 @@ export function ngMessagesDirective(
 export namespace ngMessagesDirective {
   let $inject: string[];
 }
+/**
+ * @param {ng.TemplateRequestService} $templateRequest
+ * @param {ng.CompileService} $compile
+ * @returns {ng.Directive}
+ */
 export function ngMessagesIncludeDirective(
-  $templateRequest: any,
-  $compile: any,
-): {
-  restrict: string;
-  require: string;
-  link($scope: any, element: any, attrs: any): void;
-};
+  $templateRequest: ng.TemplateRequestService,
+  $compile: ng.CompileService,
+): ng.Directive;
 export namespace ngMessagesIncludeDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };
@@ -39,7 +40,7 @@ declare class NgMessageCtrl {
   $element: Element;
   $scope: ng.Scope;
   $attrs: ng.Attributes;
-  $animate: import("../../interface.ts").AnimateService;
+  $animate: import("../../animations/interface.ts").AnimateService;
   latestKey: number;
   nextAttachId: number;
   messages: {};