@angular-wave/angular.ts 0.14.3 → 0.15.1

package/@types/interface.d.ts

@@ -1,25 +1,56 @@
-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 interface Constructor<T = any> {
+  new (...args: any[]): T;
+}
+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.
  *
@@ -348,9 +379,9 @@ export interface DirectivePrePost {
  * A link function executed during directive linking.
  */
 export type DirectiveLinkFn<T> = (
-  scope: Scope,
+  scope: ng.Scope,
   element: HTMLElement,
-  attrs: Attributes & Record<string, any>,
+  attrs: ng.Attributes,
   controller?: TController<T>,
   transclude?: (...args: any[]) => any,
 ) => void;
@@ -358,8 +389,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;
 /**
@@ -434,6 +465,24 @@ export type CloneAttachFunction = (
   clonedElement?: Element,
   scope?: Scope,
 ) => any;
+export interface TemplateLinkingFunction {
+  (
+    scope: ng.Scope,
+    cloneAttachFn?: CloneAttachFunction,
+    options?: TemplateLinkingFunctionOptions,
+  ): Element;
+}
+export interface TemplateLinkingFunctionOptions {
+  parentBoundTranscludeFn?: TranscludeFunctionObject | undefined;
+  transcludeControllers?:
+    | {
+        [controller: string]: {
+          instance: Controller;
+        };
+      }
+    | undefined;
+  futureParentElement?: Element | undefined;
+}
 /**
  * Configuration for ngModel behavior.
  */

package/@types/namespace.d.ts

@@ -5,15 +5,19 @@ import { Scope as TScope } from "./core/scope/scope.js";
 import {
   ListenerFn as TListenerFn,
   Listener as TListener,
+  ScopeEvent as TScopeEvent,
 } 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 +50,7 @@ import {
   ControllerConstructor as TControllerConstructor,
   Injectable as TInjectable,
   Expression as TExpression,
+  PublicInjectionTokens,
 } from "./interface.ts";
 import {
   SseService as TSseService,
@@ -89,6 +94,24 @@ 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";
+import {
+  SCEService as TSCEService,
+  SCEDelegateService as TSCEDelegateService,
+} from "./services/sce/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -98,9 +121,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 +138,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 +168,25 @@ declare global {
     type PubSubService = TPubSub;
     type RootElementService = Element;
     type RootScopeService = TScope & Record<string, any>;
+    type RouterService = TRouterProvider;
     type StateService = TStateProvider;
+    type StateRegistryService = TStateRegistryProvider;
+    type SCEService = TSCEService;
+    type SCEDelegateService = TSCEDelegateService;
     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 AngularService = Angular;
     type WorkerConfig = TWorkerConfig;
     type WorkerConnection = TWorkerConnection;
     type Injectable<
@@ -170,5 +207,12 @@ 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;
+    type ScopeEvent = TScopeEvent;
   }
 }

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/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
    *
@@ -16,15 +16,17 @@ export class Router {
   /**
    * @type {number}
    */
-  lastStartedTransitionId: number;
+  _lastStartedTransitionId: number;
   /**
    * @type {Queue<import("./transition/transition.js").Transition>}
    */
-  transitionHistory: Queue<import("./transition/transition.js").Transition>;
+  _transitionHistory: Queue<import("./transition/transition.js").Transition>;
   /**
    * @type {Queue<import("./transition/transition.js").Transition>}
    */
-  successfulTransitions: Queue<import("./transition/transition.js").Transition>;
+  _successfulTransitions: Queue<
+    import("./transition/transition.js").Transition
+  >;
   /**
    * @type {import("./state/interface.ts").StateDeclaration|undefined}
    */

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

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

package/@types/router/scroll/view-scroll.d.ts

@@ -0,0 +1,8 @@
+export class ViewScrollProvider {
+  enabled: boolean;
+  useAnchorScroll(): void;
+  $get: (
+    | string
+    | (($anchorScroll: ng.AnchorScrollObject) => ng.ViewScrollService)
+  )[];
+}