@angular-wave/angular.ts 0.14.2 → 0.15.0

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

@@ -55,7 +55,7 @@ export class NgModelController {
    * @param {Element} $element
    * @param {ng.ParseService} $parse
    * @param {ng.AnimateService} $animate
-   * @param {*} $interpolate
+   * @param {ng.InterpolateService} $interpolate
    */
   constructor(
     $scope: ng.Scope,
@@ -64,7 +64,7 @@ export class NgModelController {
     $element: Element,
     $parse: ng.ParseService,
     $animate: ng.AnimateService,
-    $interpolate: any,
+    $interpolate: ng.InterpolateService,
   );
   /** @type {any} The actual value from the control's view  */
   $viewValue: any;
@@ -97,7 +97,7 @@ export class NgModelController {
   $error: {};
   $$success: {};
   $pending: any;
-  $name: any;
+  $name: string;
   $$parentForm: {
     $nonscope: boolean;
     $addControl: Function;
@@ -145,9 +145,9 @@ export class NgModelController {
   $$scope: ng.Scope;
   $$attr: ng.Attributes;
   $$element: Element;
-  $$animate: import("../../interface.ts").AnimateService;
+  $$animate: import("../../animations/interface.ts").AnimateService;
   $$parse: import("../../core/parse/interface.ts").ParseService;
-  $$exceptionHandler: import("../../interface.ts").ExceptionHandler;
+  $$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
   $$hasNativeValidators: boolean;
   $$classCache: {};
   $$eventRemovers: Set<any>;

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

@@ -1,11 +1,8 @@
-export function ngRefDirective($parse: any): {
-  priority: number;
-  restrict: string;
-  compile(
-    tElement: any,
-    tAttrs: any,
-  ): (scope: any, element: any, attrs: any) => void;
-};
+/**
+ * @param {ng.ParseService} $parse
+ * @return {ng.Directive}
+ */
+export function ngRefDirective($parse: ng.ParseService): ng.Directive;
 export namespace ngRefDirective {
   let $inject: string[];
 }

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

@@ -1,11 +1,9 @@
 /**
  * TODO // Add type for animate service
  * @param {*}  $animate
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngRepeatDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngRepeatDirective($animate: any): ng.Directive;
 export namespace ngRepeatDirective {
   let $inject: string[];
 }

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

@@ -1,10 +1,10 @@
 /**
  * @param {ng.TemplateCacheService} $templateCache
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 export function scriptDirective(
   $templateCache: ng.TemplateCacheService,
-): import("../../interface.ts").Directive;
+): ng.Directive;
 export namespace scriptDirective {
   let $inject: string[];
 }

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

@@ -2,14 +2,13 @@
  * @returns {import('../../interface.ts').Directive}
  */
 export function selectDirective(): import("../../interface.ts").Directive;
-export function optionDirective($interpolate: any): {
-  restrict: string;
-  priority: number;
-  compile(
-    element: any,
-    attr: any,
-  ): (scope: any, elemParam: any, attrParam: any) => void;
-};
+/**
+ * @param {ng.InterpolateService} $interpolate
+ * @returns {ng.Directive}
+ */
+export function optionDirective(
+  $interpolate: ng.InterpolateService,
+): ng.Directive;
 export namespace optionDirective {
   let $inject: string[];
 }

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

@@ -25,7 +25,7 @@ export const requiredDirective: (
   | string
   | ((
       $parse: import("../../core/parse/interface.ts").ParseService,
-    ) => import("../../interface.ts").Directive)
+    ) => ng.Directive)
 )[];
 /**
  * @param {String|RegExp} ngPattern AngularTS expression that must evaluate to a `RegExp` or a `String`
@@ -70,7 +70,7 @@ export const patternDirective: (
   | string
   | ((
       $parse: import("../../core/parse/interface.ts").ParseService,
-    ) => import("../../interface.ts").Directive)
+    ) => ng.Directive)
 )[];
 /**
  * @param {string} ngMaxlength AngularTS expression that must evaluate to a `Number` or `String`

package/@types/injection-tokens.d.ts

@@ -11,13 +11,14 @@ export function provider(services: string[]): string[];
  * ```js
  *
  * myDirective.$inject = [
- *   angular.$injectTokens.$animate,
- *   angular.$injectTokens.$templateRequest,
+ *   angular.$t.$animate,
+ *   angular.$t.$templateRequest,
  * ];
  *
  * function myDirective($animate, $templateRequest) { ... }
  *
  * ```
+ * @private
  * @type Readonly<Record<string, string>>
  */
 export const $injectTokens: Readonly<Record<string, string>>;

package/@types/interface.d.ts

@@ -1,25 +1,53 @@
-export * from "./animations/interface.ts";
-export * from "./services/http/interface.ts";
-export * from "./services/log/interface.ts";
-export * from "./services/log/log.js";
-export * from "./services/location/interface.ts";
-export * from "./services/location/location.js";
-export * from "./services/pubsub/pubsub.js";
-export * from "./services/template-cache/template-cache.js";
-export * from "./index.js";
-export * from "./angular.js";
-export * from "./core/di/internal-injector.js";
-export * from "./core/scope/scope.js";
-export * from "./services/cookie/cookie.js";
-export * from "./services/cookie/interface.ts";
-export * from "./services/exception/exception.ts";
-export * from "./services/exception/interface.ts";
-export * from "./core/parse/interface.ts";
-export * from "./filters/interface.ts";
-export * from "./core/filter/filter.js";
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 import { NgModelController } from "./directive/model/model.js";
+export declare const PublicInjectionTokens: {
+  readonly $angular: "$angular";
+  readonly $attrs: "$attrs";
+  readonly $scope: "$scope";
+  readonly $element: "$element";
+  readonly $anchorScroll: "$anchorScroll";
+  readonly $animate: "$animate";
+  readonly $animateCss: "$animateCss";
+  readonly $aria: "$aria";
+  readonly $compile: "$compile";
+  readonly $cookie: "$cookie";
+  readonly $controller: "$controller";
+  readonly $document: "$document";
+  readonly $eventBus: "$eventBus";
+  readonly $exceptionHandler: "$exceptionHandler";
+  readonly $filter: "$filter";
+  readonly $http: "$http";
+  readonly $httpParamSerializer: "$httpParamSerializer";
+  readonly $interpolate: "$interpolate";
+  readonly $location: "$location";
+  readonly $log: "$log";
+  readonly $viewScroll: "$viewScroll";
+  readonly $parse: "$parse";
+  readonly $rest: "$rest";
+  readonly $rootScope: "$rootScope";
+  readonly $rootElement: "$rootElement";
+  readonly $router: "$router";
+  readonly $sce: "$sce";
+  readonly $sceDelegate: "$sceDelegate";
+  readonly $state: "$state";
+  readonly $stateRegistry: "$stateRegistry";
+  readonly $sse: "$sse";
+  readonly $templateCache: "$templateCache";
+  readonly $templateFactory: "$templateFactory";
+  readonly $templateRequest: "$templateRequest";
+  readonly $transitions: "$transitions";
+  readonly $urlConfig: "$urlConfig";
+  readonly $url: "$url";
+  readonly $view: "$view";
+  readonly $window: "$window";
+  readonly $provide: "$provide";
+  readonly $injector: "$injector";
+  readonly $compileProvider: "$compileProvider";
+  readonly $animateProvider: "$animateProvider";
+  readonly $filterProvider: "$filterProvider";
+  readonly $controllerProvider: "$controllerProvider";
+};
 /**
  * Configuration options for the AngularTS bootstrap process.
  *
@@ -350,7 +378,7 @@ export interface DirectivePrePost {
 export type DirectiveLinkFn<T> = (
   scope: Scope,
   element: HTMLElement,
-  attrs: Attributes & Record<string, any>,
+  attrs: ng.Attributes,
   controller?: TController<T>,
   transclude?: (...args: any[]) => any,
 ) => void;
@@ -358,8 +386,8 @@ export type DirectiveLinkFn<T> = (
  * A compile function used to prepare directives before linking.
  */
 export type DirectiveCompileFn = (
-  templateElement?: HTMLElement,
-  templateAttributes?: Attributes & Record<string, any>,
+  templateElement: HTMLElement,
+  templateAttributes: Attributes & Record<string, any>,
   transclude?: (...args: any[]) => any,
 ) => void | DirectiveLinkFn<any> | DirectivePrePost;
 /**

package/@types/namespace.d.ts

@@ -8,12 +8,15 @@ import {
 } from "./core/scope/interface.ts";
 import { NgModule as TNgModule } from "./core/di/ng-module/ng-module.js";
 import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
+import { AnchorScrollProvider as TAnchorScrollProvider } from "./services/anchor-scroll/anchor-scroll.js";
 import {
-  AnchorScrollProvider as TAnchorScrollProvider,
+  AnchorScrollFunction as TAnchorScrollFunction,
   AnchorScrollService as TAnchorScrollService,
-} from "./services/anchor-scroll/anchor-scroll.js";
+  AnchorScrollObject as TAnchorScrollObject,
+} from "./services/anchor-scroll/interface.ts";
 import { ControllerService as TControllerService } from "./core/controller/interface.ts";
 import { ExceptionHandler as TExceptionHandler } from "./services/exception/interface.ts";
+import { ExceptionHandlerProvider as TExceptionHandlerProvider } from "./services/exception/exception.js";
 import { ParseService as TParseService } from "./core/parse/interface.ts";
 import { TemplateRequestService as TTemplateRequestService } from "./services/template-request/interface.ts";
 import { HttpParamSerializer as THttpParamSerializer } from "./services/http/interface.ts";
@@ -46,6 +49,7 @@ import {
   ControllerConstructor as TControllerConstructor,
   Injectable as TInjectable,
   Expression as TExpression,
+  PublicInjectionTokens,
 } from "./interface.ts";
 import {
   SseService as TSseService,
@@ -89,6 +93,20 @@ import {
 import { RestService as TRestService } from "./services/rest/rest.js";
 import { ServiceProvider as TServiceProvider } from "./interface.ts";
 import { NgModelController as TNgModelController } from "./directive/model/model.js";
+import { RouterProvider as TRouterProvider } from "./router/router.ts";
+import { TransitionProvider as TTransitionProvider } from "./router/transition/transition-service.js";
+import { AnimateProvider as TAnimateProvider } from "./animations/animate.js";
+import { UrlService as TUrlService } from "./router/url/url-service.js";
+import { LocationProvider as TLocationProvider } from "./services/location/location.js";
+import { ViewService as TViewService } from "./router/view/view.js";
+import {
+  BuiltStateDeclaration as TBuiltStateDeclaration,
+  StateDeclaration as TStateDeclaration,
+} from "./router/state/interface.ts";
+import { StateObject as TStateObject } from "./router/state/state-object.js";
+import { StateRegistryProvider as TStateRegistryProvider } from "./router/state/state-registry.js";
+import { ViewScrollService as TViewScrollService } from "./router/scroll/interface.ts";
+import { HookRegistry } from "./router/transition/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -98,9 +116,9 @@ declare global {
   }
   export namespace ng {
     type Angular = TAngular;
-    type Attributes = TAttributes & Record<string, any>;
+    type Attributes = TAttributes & Record<string, string>;
     type Directive<TController = any> = TDirective<TController>;
-    type DirectiveFactory = TDirectiveFactory & Function;
+    type DirectiveFactory = TDirectiveFactory;
     type AnnotatedDirectiveFactory = TAnnotatedDirectiveFactory;
     type Component = TComponent & Record<string, any>;
     type Controller = TController;
@@ -115,11 +133,16 @@ declare global {
     type BoundTranscludeFn = TBoundTranscludeFn;
     type LinkFnMapping = TLinkFnMapping;
     type AnchorScrollProvider = TAnchorScrollProvider;
-    type InterpolateProvider = TInterpolateProvider;
+    type AnimateProvider = TAnimateProvider;
+    type FilterProvider = TFilterProvider;
+    type ExceptionHandlerProvider = TExceptionHandlerProvider;
     type HttpParamSerializerProvider = THttpParamSerializerProvider;
+    type InterpolateProvider = TInterpolateProvider;
+    type LocationProvider = TLocationProvider;
     type SceProvider = TSceProvider;
     type SceDelegateProvider = TSceDelegateProvider;
-    type FilterProvider = TFilterProvider;
+    type TransitionProvider = TTransitionProvider;
+    type RouterProvider = TRouterProvider;
     type AnchorScrollService = TAnchorScrollService;
     type AnimateService = TAnimateService;
     type CompileService = TCompileFn;
@@ -140,16 +163,23 @@ declare global {
     type PubSubService = TPubSub;
     type RootElementService = Element;
     type RootScopeService = TScope & Record<string, any>;
+    type RouterService = TRouterProvider;
     type StateService = TStateProvider;
+    type StateRegistryService = TStateRegistryProvider;
     type SseService = TSseService;
     type SseConfig = TSseConfig;
+    type TransitionService = TransitionProvider & HookRegistry;
     type TemplateCacheService = Map<string, string>;
     type TemplateRequestService = TTemplateRequestService;
+    type UrlService = TUrlService;
+    type ViewService = TViewService;
+    type ViewScrollService = TViewScrollService;
     type ErrorHandlingConfig = TErrorHandlingConfig;
     type ListenerFn = TListenerFn;
     type Listener = TListener;
     type DocumentService = Document;
     type WindowService = Window;
+    type AngularServie = Angular;
     type WorkerConfig = TWorkerConfig;
     type WorkerConnection = TWorkerConnection;
     type Injectable<
@@ -170,5 +200,11 @@ declare global {
     type Expression = TExpression;
     type NgModelController = TNgModelController;
     type Validator = TValidator;
+    type StateDeclaration = TStateDeclaration;
+    type BuiltStateDeclaration = TBuiltStateDeclaration;
+    type StateObject = TStateObject;
+    type AnchorScrollFunction = TAnchorScrollFunction;
+    type AnchorScrollObject = TAnchorScrollObject;
+    type InjectionTokens = typeof PublicInjectionTokens;
   }
 }

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

@@ -1,45 +1,47 @@
+/**
+ * @param {ng.StateService} $stateService
+ * @param {ng.StateRegistryService} $stateRegistry
+ * @param {ng.TransitionService} $transitions
+ * @returns {ng.Directive}
+ */
 export function $StateRefDirective(
-  $stateService: any,
-  $stateRegistry: any,
-  $transitions: any,
-): {
-  restrict: string;
-  require: string[];
-  link: (scope: any, element: any, attrs: any, ngSrefActive: any) => void;
-};
+  $stateService: ng.StateService,
+  $stateRegistry: ng.StateRegistryService,
+  $transitions: ng.TransitionService,
+): ng.Directive;
 export namespace $StateRefDirective {
   let $inject: string[];
 }
 /**
- * @param $state
- * @param $stateRegistry
- * @param $transitions
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.StateService} $state
+ * @param {ng.StateRegistryService} $stateRegistry
+ * @param {ng.TransitionService} $transitions
+ * @returns {ng.Directive}
  */
 export function $StateRefDynamicDirective(
-  $state: any,
-  $stateRegistry: any,
-  $transitions: any,
-): import("../../interface.ts").Directive;
+  $state: ng.StateService,
+  $stateRegistry: ng.StateRegistryService,
+  $transitions: ng.TransitionService,
+): ng.Directive;
 export namespace $StateRefDynamicDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };
 }
 /**
- * @param {*} $state
- * @param {import('../router.js').Router} $router
- * @param {*} $interpolate
+ * @param {ng.StateService} $state
+ * @param {ng.RouterService} $router
+ * @param {ng.InterpolateService} $interpolate
  * @param {*} $stateRegistry
  * @param {*} $transitions
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
 export function $StateRefActiveDirective(
-  $state: any,
-  $router: import("../router.js").Router,
-  $interpolate: any,
+  $state: ng.StateService,
+  $router: ng.RouterService,
+  $interpolate: ng.InterpolateService,
   $stateRegistry: any,
   $transitions: any,
-): import("../../interface.ts").Directive;
+): ng.Directive;
 export namespace $StateRefActiveDirective {
   let $inject_2: string[];
   export { $inject_2 as $inject };

package/@types/router/directives/view-directive.d.ts

@@ -1,138 +1,34 @@
+/**
+ * @param {ng.ViewService} $view
+ * @param {ng.AnimateService} $animate
+ * @param {ng.AnchorScrollService} $viewScroll
+ * @param {ng.InterpolateService} $interpolate
+ * @returns {ng.Directive}
+ */
+export function $ViewDirective(
+  $view: ng.ViewService,
+  $animate: ng.AnimateService,
+  $viewScroll: ng.AnchorScrollService,
+  $interpolate: ng.InterpolateService,
+): ng.Directive;
+export namespace $ViewDirective {
+  let $inject: string[];
+}
+/**
+ * @param {ng.CompileService} $compile
+ * @param {ng.ControllerService} $controller
+ * @param {ng.TransitionService} $transitions
+ * @returns
+ */
 export function $ViewDirectiveFill(
-  $compile: any,
-  $controller: any,
-  $transitions: any,
+  $compile: ng.CompileService,
+  $controller: ng.ControllerService,
+  $transitions: ng.TransitionService,
 ): {
   priority: number;
   compile(tElement: any): (scope: any, $element: any) => void;
 };
 export namespace $ViewDirectiveFill {
-  let $inject: string[];
+  let $inject_1: string[];
+  export { $inject_1 as $inject };
 }
-/**
- * `ng-view`: A viewport directive which is filled in by a view from the active state.
- *
- * ### Attributes
- *
- * - `name`: (Optional) A view name.
- *   The name should be unique amongst the other views in the same state.
- *   You can have views of the same name that live in different states.
- *   The ng-view can be targeted in a View using the name ([[StateDeclaration.views]]).
- *
- * - `autoscroll`: an expression. When it evaluates to true, the `ng-view` will be scrolled into view when it is activated.
- *   Uses [[$viewScroll]] to do the scrolling.
- *
- * - `onload`: Expression to evaluate whenever the view updates.
- *
- * #### Example:
- * A view can be unnamed or named.
- * ```html
- * <!-- Unnamed -->
- * <div ng-view></div>
- *
- * <!-- Named -->
- * <div ng-view="viewName"></div>
- *
- * <!-- Named (different style) -->
- * <ng-view name="viewName"></ng-view>
- * ```
- *
- * You can only have one unnamed view within any template (or root html). If you are only using a
- * single view and it is unnamed then you can populate it like so:
- *
- * ```html
- * <div ng-view></div>
- * $stateProvider.state("home", {
- *   template: "<h1>HELLO!</h1>"
- * })
- * ```
- *
- * The above is a convenient shortcut equivalent to specifying your view explicitly with the
- * [[StateDeclaration.views]] config property, by name, in this case an empty name:
- *
- * ```js
- * $stateProvider.state("home", {
- *   views: {
- *     "": {
- *       template: "<h1>HELLO!</h1>"
- *     }
- *   }
- * })
- * ```
- *
- * But typically you'll only use the views property if you name your view or have more than one view
- * in the same template. There's not really a compelling reason to name a view if its the only one,
- * but you could if you wanted, like so:
- *
- * ```html
- * <div ng-view="main"></div>
- * ```
- *
- * ```js
- * $stateProvider.state("home", {
- *   views: {
- *     "main": {
- *       template: "<h1>HELLO!</h1>"
- *     }
- *   }
- * })
- * ```
- *
- * Really though, you'll use views to set up multiple views:
- *
- * ```html
- * <div ng-view></div>
- * <div ng-view="chart"></div>
- * <div ng-view="data"></div>
- * ```
- *
- * ```js
- * $stateProvider.state("home", {
- *   views: {
- *     "": {
- *       template: "<h1>HELLO!</h1>"
- *     },
- *     "chart": {
- *       template: "<chart_thing/>"
- *     },
- *     "data": {
- *       template: "<data_thing/>"
- *     }
- *   }
- * })
- * ```
- *
- * #### Examples for `autoscroll`:
- * ```html
- * <!-- If autoscroll present with no expression,
- *      then scroll ng-view into view -->
- * <ng-view autoscroll/>
- *
- * <!-- If autoscroll present with valid expression,
- *      then scroll ng-view into view if expression evaluates to true -->
- * <ng-view autoscroll='true'/>
- * <ng-view autoscroll='false'/>
- * <ng-view autoscroll='scopeVariable'/>
- * ```
- *
- * Resolve data:
- *
- * The resolved data from the state's `resolve` block is placed on the scope as `$resolve` (this
- * can be customized using [[ViewDeclaration.resolveAs]]).  This can be then accessed from the template.
- *
- * Note that when `controllerAs` is being used, `$resolve` is set on the controller instance *after* the
- * controller is instantiated.  The `$onInit()` hook can be used to perform initialization code which
- * depends on `$resolve` data.
- *
- * #### Example:
- * ```js
- * $stateProvider.state('home', {
- *   template: '<my-component user="$resolve.user"></my-component>',
- *   resolve: {
- *     user: function(UserService) { return UserService.fetchUser(); }
- *   }
- * });
- * ```
- */
-/** @type {import("../../interface.ts").AnnotatedDirectiveFactory} */
-export const ngView: import("../../interface.ts").AnnotatedDirectiveFactory;

package/@types/router/glob/glob.d.ts

@@ -64,15 +64,11 @@ export class Glob {
   /**
    * @type {string}
    */
-  text: string;
-  /**
-   * @type {string[]}
-   */
-  glob: string[];
+  _text: string;
   /**
    * @type {RegExp}
    */
-  regexp: RegExp;
+  _regexp: RegExp;
   /**
    * @param {string} name
    * @return {boolean}

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?: {}): {};

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

@@ -5,7 +5,7 @@
  * This is where we hold the global mutable state such as current state, current
  * params, current transition, etc.
  */
-export class Router {
+export class RouterProvider {
   /**
    * Current parameter values
    *

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

@@ -0,0 +1,3 @@
+export type ViewScrollService =
+  | ng.AnchorScrollService
+  | ((el: Element) => void | Promise<void>);