@angular-wave/angular.ts 0.15.2 → 0.16.0

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

@@ -7,10 +7,11 @@ export const PURITY_ABSOLUTE: 1;
 export const PURITY_RELATIVE: 2;
 export class ASTInterpreter {
   /**
-   * @param {function(any):any} $filter
+   * @param {ng.FilterService} $filter
    */
-  constructor($filter: (arg0: any) => any);
-  _$filter: (arg0: any) => any;
+  constructor($filter: ng.FilterService);
+  /** @type {ng.FilterService} */
+  _$filter: ng.FilterService;
   /**
    * Compiles the AST into a function.
    * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.

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

@@ -1,28 +1,16 @@
-/**
- * @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.
- */
 /**
  * Represents a lexer that tokenizes input text. The Lexer takes the original expression string and returns an array of tokens parsed from that string.
  * For example, the string "a + b" would result in tokens for a, +, and b.
  */
 export class Lexer {
-  /**
-   * Creates an instance of Lexer.
-   * @param {LexerOptions} options - Lexer options.
-   */
-  constructor(options: LexerOptions);
-  /** @type {LexerOptions} */
-  _options: LexerOptions;
+  _text: string;
+  _index: number;
   /**
    * 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;
   /** @type {Array<Token>} */
   _tokens: Array<Token>;
   /**
@@ -62,12 +50,6 @@ export class Lexer {
    * @returns {boolean} True if character is a valid identifier continuation, false otherwise.
    */
   _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;
   /**
    * Peeks at the next multicharacter sequence in the text.
    * @returns {string} Next multicharacter sequence.
@@ -107,13 +89,3 @@ export class Lexer {
   _handleUnicodeEscape(): string;
 }
 export type Token = import("./token.ts").Token;
-export type LexerOptions = {
-  /**
-   * - 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.
-   */
-  isIdentifierContinue?: (ch: string, codePoint: number) => boolean;
-};

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

@@ -1,36 +1,3 @@
-export function constantWatchDelegate(
-  scope: any,
-  listener: any,
-  objectEquality: any,
-  parsedExpression: any,
-): any;
 export class ParseProvider {
-  /**
-   * Allows defining the set of characters that are allowed in AngularTS 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
-   * a given character is a valid character to be a follow-up identifier character. The functions
-   * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
-   * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
-   * mind that the `string` parameter can be two characters long depending on the character
-   * representation. It is expected for the function to return `true` or `false`, whether that
-   * character is allowed or not.
-   *
-   * 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
-   *   a valid identifier start character.
-   * @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,
-    identifierContinue?: (arg0: any) => boolean,
-  ) => ParseProvider;
-  $get: (
-    | string
-    | (($filter: (any: any) => any) => import("./interface.ts").ParseService)
-  )[];
+  $get: (string | (($filter: ng.FilterService) => ng.ParseService))[];
 }

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

@@ -1,7 +1,3 @@
-/**
- * @typedef {Object} ParsedAST
- * @property {import("../ast/ast-node.d.ts").ASTNode} ast - AST representation of expression
- */
 /**
  * @constructor
  */
@@ -9,11 +5,11 @@ export class Parser {
   /**
    *
    * @param {import('../lexer/lexer.js').Lexer} lexer
-   * @param {function(any):any} $filter
+   * @param {ng.FilterService} $filter
    */
   constructor(
     lexer: import("../lexer/lexer.js").Lexer,
-    $filter: (arg0: any) => any,
+    $filter: ng.FilterService,
   );
   /** @type {AST} */
   _ast: AST;
@@ -24,13 +20,6 @@ export class Parser {
    * @returns {import("../interface.ts").CompiledExpression}
    */
   _parse(exp: string): import("../interface.ts").CompiledExpression;
-  #private;
 }
-export type ParsedAST = {
-  /**
-   * - AST representation of expression
-   */
-  ast: import("../ast/ast-node.d.ts").ASTNode;
-};
 import { AST } from "../ast/ast.js";
 import { ASTInterpreter } from "../interpreter.js";

package/@types/core/sanitize/sanitize-uri.d.ts

@@ -1,9 +1,9 @@
 /** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider */
 /**
  * Private service to sanitize uris for links and images. Used by $compile.
- * @implements {ServiceProvider}
+ * @extends {ServiceProvider}
  */
-export class SanitizeUriProvider implements ServiceProvider {
+export class SanitizeUriProvider {
   /**
    * @private
    * @type {RegExp}

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

@@ -1,5 +1,6 @@
 import type { CompiledExpression } from "../parse/interface.ts";
 export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
+export type NonScope = string[] | boolean | undefined;
 export interface Listener {
   originalTarget: any;
   listenerFn: ListenerFn;

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

@@ -3,20 +3,24 @@
  * Creates a deep proxy for the target object, intercepting property changes
  * and recursively applying proxies to nested objects.
  *
- * @param {Object} target - The object to be wrapped in a proxy.
+ * @param {Object & {$nonscope?: import("./interface.ts").NonScope} & Record<string, any>} target - The object to be wrapped in a proxy.
  * @param {Scope} [context] - The context for the handler, used to track listeners.
  * @returns {Scope|Object} - A proxy that intercepts operations on the target object,
  *                                     or the original value if the target is not an object.
  */
-export function createScope(target?: any, context?: Scope): Scope | any;
+export function createScope(
+  target?: any & {
+    $nonscope?: import("./interface.ts").NonScope;
+  } & Record<string, any>,
+  context?: Scope,
+): Scope | any;
 /**
- * @ignore
  * Checks if a target should be excluded from scope observability
  * @param {any} target
  * @returns {boolean}
  */
 export function isNonScope(target: any): boolean;
-/** @ignore @type {Function[]}*/
+/** @ignore @type {Function[]} */
 export const $postUpdateQueue: Function[];
 export class RootScopeProvider {
   rootScope: any;
@@ -80,7 +84,8 @@ export class Scope {
   private _scheduled;
   $scopename: any;
   /** @private */
-  private propertyMap;
+  /** @type {Record<any, any>} */
+  propertyMap: Record<any, any>;
   /**
    * Intercepts and handles property assignments on the target object. If a new value is
    * an object, it will be recursively proxied.

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

@@ -62,7 +62,7 @@ export const PENDING_CLASS: "ng-pending";
  *  - `week`
  *  - `month`
  *
- * @description
+ *
  * `FormController` keeps track of all its controls and nested forms as well as the state of them,
  * such as being valid/invalid or dirty/pristine.
  *
@@ -101,13 +101,13 @@ export class FormController {
   $invalid: boolean;
   $submitted: boolean;
   /** @type {FormController|Object} */
-  $$parentForm: FormController | any;
-  $$element: Element;
-  $$animate: import("../../animations/interface.ts").AnimateService;
+  _parentForm: FormController | any;
+  _element: Element;
+  _animate: import("../../animations/interface.ts").AnimateService;
   $error: {};
-  $$success: {};
+  _success: {};
   $pending: any;
-  $$classCache: {};
+  _classCache: {};
   $target: {};
   /**
    * Rollback all form controls pending updates to the `$modelValue`.
@@ -237,41 +237,9 @@ export class FormController {
 }
 export const formDirective: (
   | string
-  | (($parse: any) => {
-      name: string;
-      restrict: string;
-      require: string[];
-      controller: typeof FormController;
-      compile: (
-        formElement: any,
-        attr: any,
-      ) => {
-        pre: (
-          scope: any,
-          formElementParam: any,
-          attrParam: any,
-          ctrls: any,
-        ) => void;
-      };
-    })
+  | (($parse: ng.ParseService) => ng.Directive)
 )[];
 export const ngFormDirective: (
   | string
-  | (($parse: any) => {
-      name: string;
-      restrict: string;
-      require: string[];
-      controller: typeof FormController;
-      compile: (
-        formElement: any,
-        attr: any,
-      ) => {
-        pre: (
-          scope: any,
-          formElementParam: any,
-          attrParam: any,
-          ctrls: any,
-        ) => void;
-      };
-    })
+  | (($parse: ng.ParseService) => ng.Directive)
 )[];

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

@@ -71,7 +71,7 @@ export class NgModelController {
   /** @type {any} The value in the model that the control is bound to. */
   $modelValue: any;
   /** @type {any} */
-  $$rawModelValue: any;
+  _rawModelValue: any;
   /** @type {import("./interface.ts").ModelValidators} */
   $validators: import("./interface.ts").ModelValidators;
   /** @type {import("./interface.ts").AsyncModelValidators} */
@@ -95,10 +95,10 @@ export class NgModelController {
   /** @type {boolean} */
   $invalid: boolean;
   $error: {};
-  $$success: {};
+  _success: {};
   $pending: any;
   $name: string;
-  $$parentForm: {
+  _parentForm: {
     $nonscope: boolean;
     $addControl: Function;
     $getControls: () => any[];
@@ -113,7 +113,7 @@ export class NgModelController {
     _setSubmitted: Function;
   };
   $options: {
-    $$options: import("../model-options/model-options.js").ModelOptionsConfig;
+    _options: import("../model-options/model-options.js").ModelOptionsConfig;
     getOption(name: string):
       | string
       | boolean
@@ -123,8 +123,8 @@ export class NgModelController {
         };
     createChild(options: ModelOptionsConfig): /*elided*/ any;
   };
-  $$updateEvents: string;
-  $$updateEventHandler(ev: any): void;
+  _updateEvents: string;
+  _updateEventHandler(ev: any): void;
   _parsedNgModel: import("../../core/parse/interface.ts").CompiledExpression;
   _parsedNgModelAssign: (context: any, value: any) => any;
   /**
@@ -135,26 +135,26 @@ export class NgModelController {
     | import("../../core/parse/interface.ts").CompiledExpression
     | ((arg0: ng.Scope) => any);
   _ngModelSet: (context: any, value: any) => any;
-  $$pendingDebounce: number;
-  $$parserValid: boolean;
+  _pendingDebounce: number;
+  _parserValid: boolean;
   /** @type {string} */
-  $$parserName: string;
+  _parserName: string;
   /** @type {number} */
-  $$currentValidationRunId: number;
+  _currentValidationRunId: number;
   /** @type {ng.Scope} */
-  $$scope: ng.Scope;
-  $$attr: ng.Attributes;
-  $$element: Element;
-  $$animate: import("../../animations/interface.ts").AnimateService;
-  $$parse: import("../../core/parse/interface.ts").ParseService;
-  $$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
-  $$hasNativeValidators: boolean;
-  $$classCache: {};
-  $$eventRemovers: Set<any>;
+  _scope: ng.Scope;
+  _attr: ng.Attributes;
+  _element: Element;
+  _animate: import("../../animations/interface.ts").AnimateService;
+  _parse: import("../../core/parse/interface.ts").ParseService;
+  _exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
+  _hasNativeValidators: boolean;
+  _classCache: {};
+  _eventRemovers: Set<any>;
   set(object: any, property: any): void;
   unset(object: any, property: any): void;
   $setValidity(validationErrorKey: any, state: any): void;
-  $$initGetterSetters(): void;
+  _initGetterSetters(): void;
   /**
    * Called when the view needs to be updated. It is expected that the user of the ng-model
    * directive will implement this method.
@@ -187,7 +187,7 @@ export class NgModelController {
    * @returns {boolean} True if `value` is "empty".
    */
   $isEmpty(value: any): boolean;
-  $$updateEmptyClasses(value: any): void;
+  _updateEmptyClasses(value: any): void;
   /**
    * Sets the control to its pristine state.
    *
@@ -316,7 +316,7 @@ export class NgModelController {
    * `$modelValue`, i.e. either the last parsed value or the last value set from the scope.
    */
   $validate(): void;
-  $$runValidators(modelValue: any, viewValue: any, doneCallback: any): void;
+  _runValidators(modelValue: any, viewValue: any, doneCallback: any): void;
   /**
    * Commit a pending update to the `$modelValue`.
    *
@@ -325,9 +325,9 @@ export class NgModelController {
    * usually handles calling this in response to input events.
    */
   $commitViewValue(): void;
-  $$lastCommittedViewValue: any;
-  $$parseAndValidate(): void;
-  $$writeModelToScope(): void;
+  _lastCommittedViewValue: any;
+  _parseAndValidate(): void;
+  _writeModelToScope(): void;
   /**
    * Update the view value.
    *
@@ -376,7 +376,7 @@ export class NgModelController {
    * @param {string} [trigger] Event that triggered the update.
    */
   $setViewValue(value: any, trigger?: string): void;
-  $$debounceViewValueCommit(trigger: any): void;
+  _debounceViewValueCommit(trigger: any): void;
   /**
    *
    * Override the current model options settings programmatically.
@@ -513,11 +513,15 @@ export class NgModelController {
   /**
    * This method is called internally to run the $formatters on the $modelValue
    */
-  $$format(): any;
+  _format(): any;
   /**
+   * @ignore
    * This method is called internally when the bound scope value changes.
    */
-  $$setModelValue(modelValue: any): void;
-  $$removeAllEventListeners(): void;
-  $$setUpdateOnEvents(): void;
+  _setModelValue(modelValue: any): void;
+  /**
+   * @ignore
+   */
+  _removeAllEventListeners(): void;
+  _setUpdateOnEvents(): void;
 }

package/@types/directive/model-options/model-options.d.ts

@@ -27,7 +27,6 @@ export type ModelOptionsConfig = {
   updateOnDefault?: boolean;
 };
 /**
- * @description
  * A container for the options set by the {@link ngModelOptions} directive
  */
 declare class ModelOptions {
@@ -37,7 +36,7 @@ declare class ModelOptions {
    */
   constructor(options: ModelOptionsConfig);
   /** @type {ModelOptionsConfig} */
-  $$options: ModelOptionsConfig;
+  _options: ModelOptionsConfig;
   /**
    * Returns the value of the given option
    * @param {string} name the name of the option to retrieve

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

@@ -32,7 +32,7 @@ export const requiredDirective: (
  *                                      parsable into a `RegExp`, or a `RegExp` literal. See above for
  *                                      more details.
  *
- * @description
+ *
  *
  * ngPattern adds the pattern {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
  * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
@@ -68,16 +68,14 @@ export const requiredDirective: (
  */
 export const patternDirective: (
   | string
-  | ((
-      $parse: import("../../core/parse/interface.ts").ParseService,
-    ) => ng.Directive)
+  | (($parse: ng.ParseService) => ng.Directive)
 )[];
 /**
  * @param {string} ngMaxlength AngularTS expression that must evaluate to a `Number` or `String`
  *                                 parsable into a `Number`. Used as value for the `maxlength`
  *                                 {@link ngModel.NgModelController#$validators validator}.
  *
- * @description
+ *
  *
  * ngMaxlength adds the maxlength {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
  * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
@@ -112,7 +110,7 @@ export const maxlengthDirective: (
  *                                 parsable into a `Number`. Used as value for the `minlength`
  *                                 {@link ngModel.NgModelController#$validators validator}.
  *
- * @description
+ *
  *
  * ngMinlength adds the minlength {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
  * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
@@ -139,7 +137,7 @@ export const maxlengthDirective: (
  */
 export const minlengthDirective: (
   | string
-  | (($parse: any) => {
+  | (($parse: ng.ParseService) => {
       restrict: string;
       require: string;
       link(scope: any, elm: any, attr: any, ctrl: any): void;

package/@types/filters/order-by.d.ts

@@ -1,7 +1,8 @@
 /**
+ * @param {ng.ParseService} $parse
  * @returns {ng.FilterFn}
  */
-export function orderByFilter($parse: any): ng.FilterFn;
+export function orderByFilter($parse: ng.ParseService): ng.FilterFn;
 export namespace orderByFilter {
   let $inject: string[];
 }

package/@types/interface.d.ts

@@ -44,6 +44,7 @@ export declare const PublicInjectionTokens: {
   readonly $url: "$url";
   readonly $view: "$view";
   readonly $window: "$window";
+  readonly $websocket: "$websocket";
   readonly $provide: "$provide";
   readonly $injector: "$injector";
   readonly $compileProvider: "$compileProvider";
@@ -429,9 +430,9 @@ export interface Directive<TController = any> {
   templateUrl?: string | ((element: Element, attrs: Attributes) => string);
   /** Enables transclusion or configures named slots */
   transclude?: boolean | string | Record<string, string>;
-  /** Internal hook for directive compilation state */
-  $$addStateInfo?: (...args: any[]) => any;
   count?: number;
+  /** Internal hook for directive compilation state */
+  _addStateInfo?: (...args: any[]) => any;
 }
 export type DirectiveFactoryFn = (
   ...args: any[]

package/@types/namespace.d.ts

@@ -2,6 +2,7 @@ export { angular } from "./index.js";
 import { Angular as TAngular } from "./angular.js";
 import { Attributes as TAttributes } from "./core/compile/attributes.js";
 import { Scope as TScope } from "./core/scope/scope.js";
+import { ProviderCache as TProviderCache } from "./core/di/interface.ts";
 import {
   ListenerFn as TListenerFn,
   Listener as TListener,
@@ -46,6 +47,7 @@ import {
   PubSub as TPubSub,
 } from "./services/pubsub/pubsub.js";
 import {
+  AnnotatedFactory as TAnnotatedFactory,
   Directive as TDirective,
   DirectiveFactory as TDirectiveFactory,
   AnnotatedDirectiveFactory as TAnnotatedDirectiveFactory,
@@ -73,14 +75,17 @@ import {
   TranscludeFn as TTranscludeFn,
   LinkFnMapping as TLinkFnMapping,
   CompositeLinkFn as TCompositeLinkFn,
-} from "./core/compile/inteface.ts";
+} from "./core/compile/interface.ts";
 import {
   WorkerConnection as TWorkerConnection,
   WorkerConfig as TWorkerConfig,
 } from "./directive/worker/interface.ts";
 import { Provider as TProvideService } from "./interface.ts";
 import { Location as TLocationService } from "./services/location/location.js";
-import { AnimateService as TAnimateService } from "./animations/interface.ts";
+import {
+  AnimateService as TAnimateService,
+  AnimationOptions as TAnimationOptions,
+} from "./animations/interface.ts";
 import {
   StorageBackend as TStorageBackend,
   StorageType as TStorageType,
@@ -116,9 +121,14 @@ import {
   SCEService as TSCEService,
   SCEDelegateService as TSCEDelegateService,
 } from "./services/sce/interface.ts";
+import {
+  WebSocketConfig as TWebSocketConfig,
+  WebSocketService as TWebSocketService,
+} from "./services/websocket/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
+    $nonscope?: readonly string[] | boolean | undefined;
   }
   interface Window {
     angular: TAngular;
@@ -185,6 +195,7 @@ declare global {
     type UrlService = TUrlService;
     type ViewService = TViewService;
     type ViewScrollService = TViewScrollService;
+    type AnimationOptions = TAnimationOptions;
     type ErrorHandlingConfig = TErrorHandlingConfig;
     type ListenerFn = TListenerFn;
     type Listener = TListener;
@@ -198,6 +209,8 @@ declare global {
         | ((...args: any[]) => any)
         | (abstract new (...args: any[]) => any),
     > = TInjectable<T>;
+    type AnnotatedFactory<T extends (...args: any[]) => any> =
+      TAnnotatedFactory<T>;
     type StorageBackend = TStorageBackend;
     type StorageType = TStorageType;
     type StreamConnectionConfig = TStreamConnectionConfig;
@@ -220,5 +233,8 @@ declare global {
     type ScopeEvent = TScopeEvent;
     type RequestShortcutConfig = TRequestShortcutConfig;
     type HttpProviderDefaults = THttpProviderDefaults;
+    type ProviderCache = TProviderCache;
+    type WebSocketConfig = TWebSocketConfig;
+    type WebSocketService = TWebSocketService;
   }
 }

package/@types/router/state/state-object.d.ts

@@ -7,9 +7,9 @@
  *
  * This class prototypally inherits from the corresponding [[StateDeclaration]].
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
- * @implements {ng.StateDeclaration}
+ * @extends {ng.StateDeclaration}
  */
-export class StateObject implements ng.StateDeclaration {
+export class StateObject {
   /**
    * @param {import('./interface.ts').StateDeclaration} config
    */

package/@types/router/state/state-service.d.ts

@@ -1,3 +1,4 @@
+export function silentRejection<E = unknown>(error: E): Promise<never>;
 /**
  * Provides services related to ng-router states.
  *

package/@types/router/template-factory.d.ts

@@ -14,11 +14,11 @@ export class TemplateFactoryProvider {
     | ((
         $http: ng.HttpService,
         $templateCache: ng.TemplateCacheService,
-        $templateRequest: any,
+        $templateRequest: ng.TemplateRequestService,
         $injector: import("../core/di/internal-injector.js").InjectorService,
       ) => this)
   )[];
-  $templateRequest: any;
+  $templateRequest: import("../services/template-request/interface.ts").TemplateRequestService;
   $http: import("../services/http/interface.ts").HttpService;
   $templateCache: ng.TemplateCacheService;
   $injector: import("../core/di/internal-injector.js").InjectorService;
@@ -62,10 +62,9 @@ export class TemplateFactoryProvider {
    * @param {string|Function} url url of the template to load, or a function
    * that returns a url.
    * @param {Object} params Parameters to pass to the url function.
-   * @return {string|Promise.<string>} The template html as a string, or a promise
-   * for that string.
+   * @return {Promise<string>}
    */
-  fromUrl(url: string | Function, params: any): string | Promise<string>;
+  fromUrl(url: string | Function, params: any): Promise<string>;
   /**
    * Creates a template by invoking an injectable provider function.
    *