@angular-wave/angular.ts 0.14.2 → 0.14.3

package/@types/angular.d.ts

@@ -1,7 +1,8 @@
 export class Angular {
-  $cache: Map<number, import("./interface.ts").ExpandoStore>;
-  /** @type {ng.PubSubService} */
-  $eventBus: ng.PubSubService;
+  /** @public */
+  public $cache: Map<number, import("./interface.ts").ExpandoStore>;
+  /** @public @type {ng.PubSubService} */
+  public $eventBus: ng.PubSubService;
   /**
    * @type {string} `version` from `package.json`
    */

package/@types/animations/interface.d.ts

@@ -9,13 +9,13 @@ export type RafScheduler = {
   /**
    * Internal queue of scheduled task arrays.
    */
-  queue: Array<Array<() => void>>;
+  _queue: Array<Array<() => void>>;
   /**
    * Waits until the animation frame is quiet before running the provided function.
    * Cancels any previous animation frame requests.
    * @param fn - The function to run when the frame is quiet.
    */
-  waitUntilQuiet(fn: () => void): void;
+  _waitUntilQuiet(fn: () => void): void;
 };
 export interface AnimationHost {
   /** Pause animation. */

package/@types/animations/queue/animate-queue.d.ts

@@ -12,7 +12,6 @@ export class AnimateQueueProvider {
         $rootScope: ng.RootScopeService,
         $injector: ng.InjectorService,
         $$animation: any,
-        $templateRequest: ng.TemplateRequestService,
       ) => import("../queue/interface.ts").AnimateQueueService)
   )[];
 }

package/@types/animations/raf-scheduler.d.ts

@@ -10,19 +10,19 @@ export class RafSchedulerProvider {
    * Internal task queue, where each item is an array of functions to run.
    * @type {Array<Array<() => void>>}
    */
-  queue: Array<Array<() => void>>;
+  _queue: Array<Array<() => void>>;
   /**
    * ID of the currently scheduled animation frame (if any).
    * Used for cancellation and tracking.
    * @type {number|null}
    */
-  cancelFn: number | null;
+  _cancelFn: number | null;
   /**
    * Processes the next batch of tasks in the animation frame.
    * Executes the first group of functions in the queue, then
    * schedules the next frame if needed.
    */
-  nextTick(): void;
+  _nextTick(): void;
   /**
    * Returns the scheduler function.
    * This function allows tasks to be queued for execution on future animation frames.

package/@types/animations/runner/animate-runner.d.ts

@@ -17,20 +17,23 @@ export class AnimateRunner {
    * @param {AnimateRunner[]} runners - Runners to execute in order.
    * @param {(ok: boolean) => void} callback - Invoked when all complete or one fails.
    */
-  static chain(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  static _chain(
+    runners: AnimateRunner[],
+    callback: (ok: boolean) => void,
+  ): void;
   /**
    * Waits for all animation runners to complete before invoking the callback.
    *
    * @param {AnimateRunner[]} runners - Active runners to wait for.
    * @param {(ok: boolean) => void} callback - Called when all runners complete.
    */
-  static all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  static _all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
   /**
    * @param {import("../interface.ts").AnimationHost} [host] - Optional animation host.
    */
   constructor(host?: import("../interface.ts").AnimationHost);
   /** @type {import("../interface.ts").AnimationHost} */
-  host: import("../interface.ts").AnimationHost;
+  _host: import("../interface.ts").AnimationHost;
   /** @type {Array<(ok: boolean) => void>} */
   _doneCallbacks: Array<(ok: boolean) => void>;
   /** @type {RunnerState} */
@@ -92,8 +95,8 @@ export class AnimateRunner {
  */
 type RunnerState = number;
 declare namespace RunnerState {
-  let INITIAL: number;
-  let PENDING: number;
-  let DONE: number;
+  let _INITIAL: number;
+  let _PENDING: number;
+  let _DONE: number;
 }
 export {};

package/@types/core/compile/attributes.d.ts

@@ -1,7 +1,6 @@
 export class Attributes {
   static $nonscope: boolean;
   /**
-   * @param {ng.RootScopeService} $rootScope
    * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
@@ -9,17 +8,15 @@ export class Attributes {
    * @param {Object} [attributesToCopy]
    */
   constructor(
-    $rootScope: ng.RootScopeService,
     $animate: ng.AnimateService,
     $exceptionHandler: ng.ExceptionHandlerService,
     $sce: any,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
-  $rootScope: ng.RootScopeService;
-  $animate: import("../../interface.ts").AnimateService;
-  $exceptionHandler: import("../../interface.ts").ExceptionHandler;
-  $sce: any;
+  _$animate: import("../../interface.ts").AnimateService;
+  _$exceptionHandler: import("../../interface.ts").ExceptionHandler;
+  _$sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */
   $nodeRef: import("../../shared/noderef.js").NodeRef;

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

@@ -113,7 +113,7 @@ export class CompileProvider {
    *
    * @param {string} elementName The element name or '*' to match any element.
    * @param {string} propertyName The DOM property name.
-   * @param {string} ctx The {@link $sce} security context in which this value is safe for use, e.g. `$sce.URL`
+   * @param {string} ctx The {@link _$sce} security context in which this value is safe for use, e.g. `$sce.URL`
    * @returns {object} `this` for chaining
    */
   addPropertySecurityContext: (

package/@types/core/di/ng-module/ng-module.d.ts

@@ -16,26 +16,27 @@ export class NgModule {
     configFn?: ng.Injectable<any>,
   );
   /**
+   * @public
    * Name of the current module.
    * @type {string}
    */
-  name: string;
+  public name: string;
   /**
    * Array of module names that this module depends on.
    * @type {string[]}
    */
-  requires: string[];
+  _requires: string[];
   /**
    * Holds a collection of tasks, required to instantiate an angular component
    * @type {!Array<Array<*>>}
    */
-  invokeQueue: Array<Array<any>>;
+  _invokeQueue: Array<Array<any>>;
   /** @type {!Array<Array<*>>} */
-  configBlocks: Array<Array<any>>;
+  _configBlocks: Array<Array<any>>;
   /** @type {!Array.<ng.Injectable<any>>} */
-  runBlocks: Array<ng.Injectable<any>>;
-  services: any[];
-  restDefinitions: any[];
+  _runBlocks: Array<ng.Injectable<any>>;
+  _services: any[];
+  _restDefinitions: any[];
   /**
    * @param {string} name
    * @param {any} object - Allows undefined

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

@@ -10,7 +10,7 @@ export class FilterProvider {
    * @param {ng.ProvideService} $provide
    */
   constructor($provide: ng.ProvideService);
-  $provide: import("../../interface.ts").Provider;
+  _$provide: import("../../interface.ts").Provider;
   /**
    * Register a filter a config phase;
    * @param {string} name

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/interpreter.d.ts

@@ -17,18 +17,6 @@ export class ASTInterpreter {
    * @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;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.
@@ -211,20 +199,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 +213,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/router/common/trace.d.ts

@@ -1,10 +1,10 @@
 export type Category = number;
 export namespace Category {
-  let RESOLVE: number;
-  let TRANSITION: number;
-  let HOOK: number;
-  let UIVIEW: number;
-  let VIEWCONFIG: number;
+  let _RESOLVE: number;
+  let _TRANSITION: number;
+  let _HOOK: number;
+  let _UIVIEW: number;
+  let _VIEWCONFIG: number;
 }
 /**
  * Prints ng-router Transition trace information to the console.

package/@types/router/params/interface.d.ts

@@ -381,7 +381,7 @@ export interface Replace {
  *   pattern: new RegExp("[0-9]+(?:-[0-9]+)*")
  *
  *   // Ensure that the (decoded) object is an array, and that all its elements are numbers
- *   is: (obj) => Array.isArray(obj) &&
+ *   is: (obj) => isArray(obj) &&
  *       obj.reduce((acc, item) => acc && typeof item === 'number', true),
  *
  *   // Compare two arrays of integers
@@ -514,7 +514,7 @@ export interface ParamTypeDefinition {
    * input is an array of ints:
    *
    * ```
-   * is: (val) => Array.isArray(val) && array.reduce((acc, x) => acc && parseInt(val, 10) === val, true)
+   * is: (val) => isArray(val) && array.reduce((acc, x) => acc && parseInt(val, 10) === val, true)
    * ```
    *
    * If your type decodes the URL parameter value to a custom string, check that the string matches

package/@types/router/params/param.d.ts

@@ -1,8 +1,8 @@
 export type DefType = number;
 export namespace DefType {
-  let PATH: number;
-  let SEARCH: number;
-  let CONFIG: number;
+  let _PATH: number;
+  let _SEARCH: number;
+  let _CONFIG: number;
 }
 export class Param {
   static values(params: any, values?: {}): {};