@angular-wave/angular.ts 0.15.0 → 0.15.2

package/@types/namespace.d.ts

@@ -5,6 +5,7 @@ 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";
@@ -19,7 +20,11 @@ import { ExceptionHandler as TExceptionHandler } from "./services/exception/inte
 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";
+import {
+  HttpParamSerializer as THttpParamSerializer,
+  HttpProviderDefaults as THttpProviderDefaults,
+  RequestShortcutConfig as TRequestShortcutConfig,
+} from "./services/http/interface.ts";
 import { HttpParamSerializerProvider as THttpParamSerializerProvider } from "./services/http/http.js";
 import {
   FilterFactory as TFilterFactory,
@@ -107,6 +112,10 @@ 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;
@@ -166,6 +175,8 @@ declare global {
     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;
@@ -179,7 +190,7 @@ declare global {
     type Listener = TListener;
     type DocumentService = Document;
     type WindowService = Window;
-    type AngularServie = Angular;
+    type AngularService = Angular;
     type WorkerConfig = TWorkerConfig;
     type WorkerConnection = TWorkerConnection;
     type Injectable<
@@ -206,5 +217,8 @@ declare global {
     type AnchorScrollFunction = TAnchorScrollFunction;
     type AnchorScrollObject = TAnchorScrollObject;
     type InjectionTokens = typeof PublicInjectionTokens;
+    type ScopeEvent = TScopeEvent;
+    type RequestShortcutConfig = TRequestShortcutConfig;
+    type HttpProviderDefaults = THttpProviderDefaults;
   }
 }

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

@@ -16,15 +16,17 @@ export class RouterProvider {
   /**
    * @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

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

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

@@ -14,7 +14,9 @@ import {
 } from "../resolve/interface.ts";
 import { Resolvable } from "../resolve/resolvable.js";
 import { TargetState } from "./target-state.js";
+import { Glob } from "../glob/glob.js";
 export type StateOrName = string | StateDeclaration | StateObject;
+export type StateStore = Record<string, StateObject | BuiltStateDeclaration>;
 export interface TransitionPromise extends Promise<StateObject> {
   transition: Transition;
 }
@@ -826,6 +828,9 @@ export type BuiltStateDeclaration = StateDeclaration & {
   parent?: BuiltStateDeclaration | null;
   /** Optional inherited data */
   data?: any;
+  _stateObjectCache?: {
+    nameGlob: Glob;
+  } | null;
 };
 /**
  * The return type of a [[StateDeclaration.lazyLoad]] function

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

@@ -58,18 +58,22 @@ export function resolvablesBuilder(
 export class StateBuilder {
   /**
    * @param {import('./state-matcher.js').StateMatcher} matcher
-   * @param urlService
+   * @param {ng.UrlService} urlService
    */
   constructor(
     matcher: import("./state-matcher.js").StateMatcher,
-    urlService: any,
+    urlService: ng.UrlService,
   );
-  matcher: import("./state-matcher.js").StateMatcher;
-  $injector: any;
-  builders: {
+  _matcher: import("./state-matcher.js").StateMatcher;
+  _$injector: any;
+  _builders: {
     name: ((state: any) => any)[];
     self: (typeof selfBuilder)[];
-    parent: ((state: any) => any)[];
+    parent: ((
+      state: any,
+    ) =>
+      | import("./state-object.js").StateObject
+      | import("./interface.ts").BuiltStateDeclaration)[];
     data: (typeof dataBuilder)[];
     url: ((stateObject: any) => any)[];
     navigable: ((state: any) => any)[];

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

@@ -1,7 +1,15 @@
 export class StateMatcher {
-  constructor(_states: any);
-  _states: any;
+  /** @param {import("./interface.ts").StateStore} states */
+  constructor(states: import("./interface.ts").StateStore);
+  /** @type {import("./interface.ts").StateStore} */
+  _states: import("./interface.ts").StateStore;
   isRelative(stateName: any): boolean;
-  find(stateOrName: any, base: any, matchGlob?: boolean): any;
+  find(
+    stateOrName: any,
+    base: any,
+    matchGlob?: boolean,
+  ):
+    | import("./state-object.js").StateObject
+    | import("./interface.ts").BuiltStateDeclaration;
   resolvePath(name: any, base: any): string;
 }

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

@@ -1,4 +1,3 @@
-/** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
 /**
  * Internal representation of a ng-router state.
  *
@@ -8,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 {StateDeclaration}
+ * @implements {ng.StateDeclaration}
  */
-export class StateObject implements StateDeclaration {
+export class StateObject implements ng.StateDeclaration {
   /**
    * @param {import('./interface.ts').StateDeclaration} config
    */
@@ -27,7 +26,7 @@ export class StateObject implements StateDeclaration {
    * @type {ng.StateDeclaration|ng.BuiltStateDeclaration}
    */
   self: ng.StateDeclaration | ng.BuiltStateDeclaration;
-  __stateObjectCache: {
+  _stateObjectCache: {
     nameGlob: Glob;
   };
   /**
@@ -79,5 +78,4 @@ export namespace StateObject {
   /** Predicate which returns true if the object is an internal [[StateObject]] object */
   function isState(obj: any): boolean;
 }
-export type StateDeclaration = import("./interface.ts").StateDeclaration;
 import { Glob } from "../glob/glob.js";

package/@types/router/state/state-queue-manager.d.ts

@@ -1,21 +1,22 @@
 export class StateQueueManager {
   /**
    * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
-   * @param {*} urlServiceRules
-   * @param {Record<string, ng.StateObject>} states
+   * @param {import("../url/url-rules.js").UrlRules} urlServiceRules
+   * @param {import("./interface.ts").StateStore} states
    * @param {*} builder
    * @param {*} listeners
    */
   constructor(
     stateRegistry: import("./state-registry.js").StateRegistryProvider,
-    urlServiceRules: any,
-    states: Record<string, ng.StateObject>,
+    urlServiceRules: import("../url/url-rules.js").UrlRules,
+    states: import("./interface.ts").StateStore,
     builder: any,
     listeners: any,
   );
   stateRegistry: import("./state-registry.js").StateRegistryProvider;
-  urlServiceRules: any;
-  states: Record<string, StateObject>;
+  /** @type {import("../url/url-rules.js").UrlRules} */
+  urlServiceRules: import("../url/url-rules.js").UrlRules;
+  states: import("./interface.ts").StateStore;
   builder: any;
   listeners: any;
   /**
@@ -23,7 +24,12 @@ export class StateQueueManager {
    */
   queue: Array<StateObject>;
   register(stateDecl: any): StateObject;
-  flush(): Record<string, StateObject>;
-  attachRoute(state: any): void;
+  flush(): import("./interface.ts").StateStore;
+  /**
+   *
+   * @param {ng.StateDeclaration} state
+   * @returns {() => void} a function that deregisters the rule
+   */
+  attachRoute(state: ng.StateDeclaration): () => void;
 }
 import { StateObject } from "./state-object.js";

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

@@ -19,8 +19,8 @@ export class StateRegistryProvider {
     globals: ng.RouterService,
     viewService: ng.ViewService,
   );
-  /** @type {Record<string, import("./state-object.js").StateObject>} */
-  states: Record<string, import("./state-object.js").StateObject>;
+  /** @type {import("./interface.ts").StateStore} */
+  states: import("./interface.ts").StateStore;
   urlService: import("../url/url-service.js").UrlService;
   urlServiceRules: import("../url/url-rules.js").UrlRules;
   $injector: any;
@@ -115,7 +115,16 @@ export class StateRegistryProvider {
    * @return {ng.BuiltStateDeclaration[]}
    */
   getAll(): ng.BuiltStateDeclaration[];
-  get(stateOrName: any, base: any, ...args: any[]): any;
+  get(
+    stateOrName: any,
+    base: any,
+    ...args: any[]
+  ):
+    | import("./interface.ts").StateDeclaration
+    | (
+        | import("./interface.ts").StateDeclaration
+        | import("./interface.ts").BuiltStateDeclaration
+      )[];
   /**
    * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
    * More than one BuilderFunction can be registered for a given property.

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

@@ -34,8 +34,14 @@ export class StateProvider {
    * @deprecated This is a passthrough through to [[Router.$current]]
    */
   get $current(): import("./state-object.js").StateObject;
-  globals: import("../router.js").RouterProvider;
-  transitionService: import("../transition/transition-service.js").TransitionProvider;
+  /**
+   * @type {ng.RouterProvider}
+   */
+  globals: ng.RouterProvider;
+  /**
+   * @type {ng.TransitionProvider}
+   */
+  transitionService: ng.TransitionProvider;
   stateRegistry: any;
   /** @type {ng.UrlService} */
   urlService: ng.UrlService;

package/@types/router/transition/hook-registry.d.ts

@@ -16,12 +16,22 @@ export function matchState(
   criterion: any,
   transition: any,
 ): boolean;
-/** Return a registration function of the requested type. */
+/**
+ * Return a registration function of the requested type.
+ * @param {ng.TransitionProvider| import("./transition.js").Transition} hookSource
+ * @param {ng.TransitionProvider} transitionService
+ * @param {import("./transition-event-type.js").TransitionEventType} eventType
+ * @returns {( matchObject: any, callback: Function, options?: Record<string, any> ) => () => void }
+ */
 export function makeEvent(
-  registry: any,
-  transitionService: any,
-  eventType: any,
-): (matchObject: any, callback: any, options?: {}) => any;
+  hookSource: ng.TransitionProvider | import("./transition.js").Transition,
+  transitionService: ng.TransitionProvider,
+  eventType: import("./transition-event-type.js").TransitionEventType,
+): (
+  matchObject: any,
+  callback: Function,
+  options?: Record<string, any>,
+) => () => void;
 /**
  * The registration data for a registered transition hook
  */

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

@@ -29,8 +29,10 @@ export class Transition implements HookRegistry {
    * @type {import('../router.js').RouterProvider}
    */
   _globals: import("../router.js").RouterProvider;
-  _transitionService: import("./transition-service.js").TransitionProvider;
-  _deferred: any;
+  /** @type {ng.TransitionProvider} */
+  _transitionProvider: ng.TransitionProvider;
+  /** @type {PromiseWithResolvers<any>} */
+  _deferred: PromiseWithResolvers<any>;
   /**
    * This promise is resolved or rejected based on the outcome of the Transition.
    *

package/@types/router/url/url-rules.d.ts

@@ -14,89 +14,7 @@ export class UrlRules {
   _sortFn: typeof defaultRuleSortFn;
   _rules: any[];
   _id: number;
-  urlRuleFactory: UrlRuleFactory;
-  /**
-   * Defines the initial state, path, or behavior to use when the app starts.
-   *
-   * This rule defines the initial/starting state for the application.
-   *
-   * This rule is triggered the first time the URL is checked (when the app initially loads).
-   * The rule is triggered only when the url matches either `""` or `"/"`.
-   *
-   * Note: The rule is intended to be used when the root of the application is directly linked to.
-   * When the URL is *not* `""` or `"/"` and doesn't match other rules, the [[otherwise]] rule is triggered.
-   * This allows 404-like behavior when an unknown URL is deep-linked.
-   *
-   * #### Example:
-   * Start app at `home` state.
-   * ```js
-   * .initial({ state: 'home' });
-   * ```
-   *
-   * #### Example:
-   * Start app at `/home` (by url)
-   * ```js
-   * .initial('/home');
-   * ```
-   *
-   * #### Example:
-   * When no other url rule matches, go to `home` state
-   * ```js
-   * .initial((matchValue, url, router) => {
-   *   console.log('initial state');
-   *   return { state: 'home' };
-   * })
-   * ```
-   *
-   * @param handler The initial state or url path, or a function which returns the state or url path (or performs custom logic).
-   */
-  initial(handler: any): void;
-  /**
-   * Defines the state, url, or behavior to use when no other rule matches the URL.
-   *
-   * This rule is matched when *no other rule* matches.
-   * It is generally used to handle unknown URLs (similar to "404" behavior, but on the client side).
-   *
-   * - If `handler` a string, it is treated as a url redirect
-   *
-   * #### Example:
-   * When no other url rule matches, redirect to `/index`
-   * ```js
-   * .otherwise('/index');
-   * ```
-   *
-   * - If `handler` is an object with a `state` property, the state is activated.
-   *
-   * #### Example:
-   * When no other url rule matches, redirect to `home` and provide a `dashboard` parameter value.
-   * ```js
-   * .otherwise({ state: 'home', params: { dashboard: 'default' } });
-   * ```
-   *
-   * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[UIRouter]] object.
-   *   The function can perform actions, and/or return a value.
-   *
-   * #### Example:
-   * When no other url rule matches, manually trigger a transition to the `home` state
-   * ```js
-   * .otherwise((matchValue, urlParts, router) => {
-   *   router.stateService.go('home');
-   * });
-   * ```
-   *
-   * #### Example:
-   * When no other url rule matches, go to `home` state
-   * ```js
-   * .otherwise((matchValue, urlParts, router) => {
-   *   return { state: 'home' };
-   * });
-   * ```
-   *
-   * @param handler The url path to redirect to, or a function which returns the url path (or performs custom logic).
-   */
-  otherwise(handler: any): void;
-  _otherwiseFn: import("./url-rule.js").BaseUrlRule;
-  _sorted: boolean;
+  _urlRuleFactory: UrlRuleFactory;
   /**
    * Remove a rule previously registered
    *
@@ -113,9 +31,10 @@ export class UrlRules {
    * A rule should have a `match` function which returns truthy if the rule matched.
    * It should also have a `handler` function which is invoked if the rule is the best match.
    *
-   * @return a function that deregisters the rule
+   * @returns {() => void } a function that deregisters the rule
    */
   rule(rule: any): () => void;
+  _sorted: boolean;
   /**
    * Gets all registered rules
    *

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

@@ -5,13 +5,13 @@ export class UrlService {
   static $inject: string[];
   /**
    * @param {ng.LocationProvider} $locationProvider
-   * @param {import("../../router/state/state-service.js").StateProvider} stateService
+   * @param {import("../../router/state/state-service.js").StateProvider} stateProvider
    * @param {import("../router.js").RouterProvider} globals
    * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
    */
   constructor(
     $locationProvider: ng.LocationProvider,
-    stateService: import("../../router/state/state-service.js").StateProvider,
+    stateProvider: import("../../router/state/state-service.js").StateProvider,
     globals: import("../router.js").RouterProvider,
     urlConfigProvider: import("../../router/url/url-config.js").UrlConfigProvider,
   );
@@ -20,20 +20,21 @@ export class UrlService {
   /** @private */
   private _locationProvider;
   stateService: import("../../router/state/state-service.js").StateProvider;
-  /** Provides services related to the URL */
-  urlRuleFactory: UrlRuleFactory;
+  /** @type {UrlRuleFactory} Provides services related to the URL */
+  _urlRuleFactory: UrlRuleFactory;
   /**
    * The nested [[UrlRules]] API for managing URL rules and rewrites
+   * @ignore
    * @type {UrlRules}
    */
-  rules: UrlRules;
+  _rules: UrlRules;
   /**
    * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
    * @type {import("./url-config.js").UrlConfigProvider}
    */
-  config: import("./url-config.js").UrlConfigProvider;
-  /** Creates a new [[Param]] for a given location (DefType) */
-  paramFactory: ParamFactory;
+  _config: import("./url-config.js").UrlConfigProvider;
+  /** @type {ParamFactory} Creates a new [[Param]] for a given location (DefType) */
+  _paramFactory: ParamFactory;
   _urlListeners: any[];
   /**
    * Gets the path part of the current url

package/@types/services/cookie/cookie.d.ts

@@ -5,10 +5,7 @@
 export class CookieProvider {
   /** @type {ng.CookieOptions} */
   defaults: ng.CookieOptions;
-  $get: (
-    | string
-    | (($exceptionHandler: ng.ExceptionHandlerService) => CookieService)
-  )[];
+  $get: () => CookieService;
 }
 /**
  *
@@ -21,16 +18,10 @@ export class CookieService {
   /**
    * @param {ng.CookieOptions} defaults
    *   Default cookie attributes defined by `$cookiesProvider.defaults`.
-   * @param {ng.ExceptionHandlerService} $exceptionHandler
    */
-  constructor(
-    defaults: ng.CookieOptions,
-    $exceptionHandler: ng.ExceptionHandlerService,
-  );
+  constructor(defaults: ng.CookieOptions);
   /** @private @type {ng.CookieOptions} */
   private _defaults;
-  /** @private @type {ng.ExceptionHandlerService} */
-  private _$exceptionHandler;
   /**
    * Retrieves a raw cookie value.
    *
@@ -61,6 +52,7 @@ export class CookieService {
    * @param {string} key
    * @param {string} value
    * @param {ng.CookieOptions} [options]
+   * @throws {URIError} if key or value cannot be encoded
    */
   put(key: string, value: string, options?: ng.CookieOptions): void;
   /**

package/@types/services/http/http.d.ts

@@ -23,21 +23,7 @@ export function defaultHttpResponseTransform(data: any, headers: any): any;
  */
 export function HttpProvider(): void;
 export class HttpProvider {
-  defaults: {
-    transformResponse: (typeof defaultHttpResponseTransform)[];
-    transformRequest: ((data: any) => any)[];
-    headers: {
-      common: {
-        Accept: string;
-      };
-      post: any;
-      put: any;
-      patch: any;
-    };
-    xsrfCookieName: string;
-    xsrfHeaderName: string;
-    paramSerializer: string;
-  };
+  defaults: import("./interface.ts").HttpProviderDefaults;
   /**
    * Configure $http service to combine processing of multiple http responses received at around
    * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
@@ -62,8 +48,11 @@ export class HttpProvider {
    * array, on request, but reverse order, on response.
    *
    * {@link ng.$http#interceptors Interceptors detailed info}
+   * @type {Array<string | ng.Injectable<import("./interface.ts").HttpInterceptorFactory>>}
    */
-  interceptors: any[];
+  interceptors: Array<
+    string | ng.Injectable<import("./interface.ts").HttpInterceptorFactory>
+  >;
   /**
    * Array containing URLs whose origins are trusted to receive the XSRF token. See the
    * {@link ng.$http#security-considerations Security Considerations} sections for more details on
@@ -118,21 +107,7 @@ export class HttpProvider {
          *
          * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
          */
-        defaults: {
-          transformResponse: (typeof defaultHttpResponseTransform)[];
-          transformRequest: ((data: any) => any)[];
-          headers: {
-            common: {
-              Accept: string;
-            };
-            post: any;
-            put: any;
-            patch: any;
-          };
-          xsrfCookieName: string;
-          xsrfHeaderName: string;
-          paramSerializer: string;
-        };
+        defaults: import("./interface.ts").HttpProviderDefaults;
       })
   )[];
 }

package/@types/services/http/interface.d.ts

@@ -4,6 +4,14 @@ export interface HttpHeadersGetter {
   };
   (headerName: string): string;
 }
+export interface HttpPromiseCallback<T> {
+  (
+    data: T,
+    status: number,
+    headers: HttpHeadersGetter,
+    config: RequestConfig,
+  ): void;
+}
 export interface HttpRequestConfigHeaders {
   [requestType: string]: any;
   common?: any;
@@ -18,6 +26,9 @@ export interface HttpRequestTransformer {
 export interface HttpResponseTransformer {
   (data: any, headersGetter: HttpHeadersGetter, status: number): any;
 }
+export interface HttpHeaderType {
+  [requestType: string]: string | ((config: RequestConfig) => string);
+}
 /**
  * Object that controls the defaults for $http provider. Not all fields of RequestShortcutConfig can be configured
  * via defaults and the docs do not say which. The following is based on the inspection of the source code.
@@ -165,13 +176,6 @@ export interface HttpService {
    * @param config Optional configuration object
    */
   head<T>(url: string, config?: RequestShortcutConfig): HttpPromise<T>;
-  /**
-   * Shortcut method to perform JSONP request.
-   *
-   * @param url Relative or absolute URL specifying the destination of the request
-   * @param config Optional configuration object
-   */
-  jsonp<T>(url: string, config?: RequestShortcutConfig): HttpPromise<T>;
   /**
    * Shortcut method to perform POST request.
    *
@@ -228,3 +232,14 @@ export type HttpParams = Record<
  * A function that serializes an object into a URL-encoded query string.
  */
 export type HttpParamSerializer = (params?: HttpParams) => string;
+export interface HttpInterceptor {
+  request?(config: RequestConfig): RequestConfig | Promise<RequestConfig>;
+  requestError?(rejection: any): RequestConfig | Promise<RequestConfig>;
+  response?<T>(
+    response: HttpResponse<T>,
+  ): Promise<HttpResponse<T>> | HttpResponse<T>;
+  responseError?<T>(rejection: any): Promise<HttpResponse<T>> | HttpResponse<T>;
+}
+export interface HttpInterceptorFactory {
+  (...args: any[]): HttpInterceptor;
+}