@angular-wave/angular.ts 0.7.3 → 0.7.5

package/.prettierignore

@@ -4,5 +4,6 @@
 dist
 node_modules
 playwright-report
-docs
+docs/public
+docs/resources
 typedoc

package/@types/core/exception-handler.d.ts

@@ -41,7 +41,7 @@
  *
  * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
-/** @typedef {import('../services/log.js').LogService} LogService */
+/** @typedef {import('../services/log/interface.ts').LogService} LogService */
 /** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
 /**
  * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
@@ -54,5 +54,5 @@ export class ExceptionHandlerProvider {
   errorHandler: ErrorHandler;
   $get: (string | (($log: LogService) => ErrorHandler))[];
 }
-export type LogService = import("../services/log.js").LogService;
+export type LogService = import("../services/log/interface.ts").LogService;
 export type ErrorHandler = import("./error-handler.ts").ErrorHandler;

package/@types/core/task-tracker-factory.d.ts

@@ -15,9 +15,9 @@ export class TaskTrackerFactoryProvider implements ServiceProvider {
  */
 export class TaskTracker {
   /**
-   * @param {import('../services/log.js').LogService} log - The logging service.
+   * @param {import('../services/log/interface.ts').LogService} log - The logging service.
    */
-  constructor(log: import("../services/log.js").LogService);
+  constructor(log: import("../services/log/interface.ts").LogService);
   /** @private */
   private log;
   /** @private */

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

@@ -1,25 +1,9 @@
 /**
- * Dynamically updates an element's content based on events published on a specified channel.
- * If data is sent via `$eventBus` on the specified `ngChannel`, the directive attempts to update the element's content accordingly,
- * either by directly setting the inner HTML or merging the scope's data if the element contains a template.
- *
- * If the element has a template and incoming data is an object, the directive will merge all key/value pairs onto the scope,
- * allowing Angular expressions (`{{ yourModel }}`) to be evaluated and rendered.
- *
- * When the scope is destroyed, the directive automatically unsubscribes from the channel.
- * Example:
- *
- * HTML:
- * <div ng-channel="userChannel">Hello {{ user.firstName }} {{ user.lastName }}</div>
- *
- * JavaScript:
- * angular.$eventBus.publish('userChannel', { user: { firstName: 'John', lastName: 'Smith' } });
- *
- * @param {import("../../core/pubsub/pubsub.js").PubSub} $eventBus
+ * @param {import("../../services/pubsub/pubsub.js").PubSub} $eventBus
  * @returns {import("../../interface.ts").Directive}
  */
 export function ngChannelDirective(
-  $eventBus: import("../../core/pubsub/pubsub.js").PubSub,
+  $eventBus: import("../../services/pubsub/pubsub.js").PubSub,
 ): import("../../interface.ts").Directive;
 export namespace ngChannelDirective {
   let $inject: string[];

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {"click" | "change" | "submit"} EventType
+ */
 /**
  * Selects DOM event to listen for based on the element type.
  *

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

@@ -1,9 +1,9 @@
 /**
- * @param {import('../../core/cache/cache-factory').TemplateCache} $templateCache
+ * @param {import('../../services/template-cache/interface.ts').TemplateCache} $templateCache
  * @returns {import('../../interface.ts').Directive}
  */
 export function scriptDirective(
-  $templateCache: any,
+  $templateCache: import("../../services/template-cache/interface.ts").TemplateCache,
 ): import("../../interface.ts").Directive;
 export namespace scriptDirective {
   let $inject: string[];

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

@@ -1,11 +1,11 @@
 /**
  * @param {import('../../core/parse/interface.ts').ParseService} $parse
- * @param {import('../../services/log.js').LogService} $log
+ * @param {import('../../services/log/interface.ts').LogService} $log
  * @returns {import('../../interface.ts').Directive}
  */
 export function ngSetterDirective(
   $parse: import("../../core/parse/interface.ts").ParseService,
-  $log: import("../../services/log.js").LogService,
+  $log: import("../../services/log/interface.ts").LogService,
 ): import("../../interface.ts").Directive;
 export namespace ngSetterDirective {
   let $inject: string[];

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

@@ -14,6 +14,9 @@ export function provider(services: string[]): string[];
  *   angular.$injectTokens.$animate,
  *   angular.$injectTokens.$templateRequest,
  * ];
+ *
+ * function myDirective($animate, $templateRequest) { ... }
+ *
  * ```
  * @type Readonly<Record<string, string>>
  */

package/@types/interface.d.ts

@@ -1,5 +1,11 @@
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
+export * from "./services/http/interface.ts";
+export * from "./services/log/interface.ts";
+export * from "./services/log/log.js";
+export * from "./services/pubsub/pubsub.js";
+export * from "./services/template-cache/interface.ts";
+export * from "./services/template-cache/template-cache.js";
 /**
  * A JavaScript expression represented as a string, typically used in interpolation bindings.
  *
@@ -10,6 +16,11 @@ import { Scope } from "./core/scope/scope.js";
  *
  */
 export type Expression = string;
+export type ExpandoStore = {
+  data: {
+    [key: string]: any;
+  };
+};
 /**
  * A dependency-annotated factory array used by AngularTS DI system.
  *

package/@types/loader.d.ts

@@ -5,10 +5,9 @@
  * @property {boolean} [strictDi] - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
  */
 export class Angular {
-  /** @type {Map<number, import("./core/cache/cache.js").ExpandoStore>} */
-  $cache: Map<number, import("./core/cache/cache.js").ExpandoStore>;
-  /** @type {import('./core/pubsub/pubsub.js').PubSub} */
-  $eventBus: import("./core/pubsub/pubsub.js").PubSub;
+  $cache: Map<number, import("./interface.ts").ExpandoStore>;
+  /** @type {import('./services/pubsub/pubsub.js').PubSub} */
+  $eventBus: import("./services/pubsub/pubsub.js").PubSub;
   /**
    * @type {string} `version` from `package.json`
    */

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

@@ -1,6 +1,14 @@
 export class ParamFactory {
-  constructor(urlServiceConfig: any);
-  urlServiceConfig: any;
+  /**
+   * @param {import("../url/url-config.js").UrlConfigProvider} urlServiceConfig
+   */
+  constructor(
+    urlServiceConfig: import("../url/url-config.js").UrlConfigProvider,
+  );
+  /**
+   * @type {import("../url/url-config.js").UrlConfigProvider}
+   */
+  urlServiceConfig: import("../url/url-config.js").UrlConfigProvider;
   fromConfig(id: any, type: any, state: any): Param;
   fromPath(id: any, type: any, state: any): Param;
   fromSearch(id: any, type: any, state: any): Param;

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

@@ -1,3 +1,9 @@
+export type DefType = number;
+export namespace DefType {
+  let PATH: number;
+  let SEARCH: number;
+  let CONFIG: number;
+}
 export class Param {
   static values(params: any, values?: {}): {};
   /**
@@ -24,10 +30,24 @@ export class Param {
   static equals(params: any, values1?: {}, values2?: {}): boolean;
   /** Returns true if a the parameter values are valid, according to the Param definitions */
   static validates(params: any, values?: {}): any;
-  constructor(id: any, type: any, location: any, urlConfig: any, state: any);
+  /**
+   *
+   * @param {*} id
+   * @param {*} type
+   * @param {DefType} location
+   * @param {import("../url/url-config.js").UrlConfigProvider} urlConfig
+   * @param {*} state
+   */
+  constructor(
+    id: any,
+    type: any,
+    location: DefType,
+    urlConfig: import("../url/url-config.js").UrlConfigProvider,
+    state: any,
+  );
   isOptional: boolean;
   type: any;
-  location: any;
+  location: number;
   id: any;
   dynamic: boolean;
   raw: boolean;
@@ -49,4 +69,3 @@ export class Param {
   validates(value: any): boolean;
   toString(): string;
 }
-export let DefType: any;

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

@@ -13,14 +13,14 @@ export class TemplateFactoryProvider {
     | string
     | ((
         $http: any,
-        $templateCache: import("../core/cache/cache-factory.js").TemplateCache,
+        $templateCache: import("../services/template-cache/interface.ts").TemplateCache,
         $templateRequest: any,
         $injector: import("../core/di/internal-injector.js").InjectorService,
       ) => this)
   )[];
   $templateRequest: any;
   $http: any;
-  $templateCache: import("../core/cache/cache-factory.js").TemplateCache;
+  $templateCache: import("../interface.ts").TemplateCache;
   $injector: import("../core/di/internal-injector.js").InjectorService;
   /**
    * Forces the provider to use $http service directly

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

@@ -32,9 +32,9 @@ export class UrlService {
    * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
    *
    * See: [[UrlConfig]] for details
-   * @type {import("./url-config").UrlConfigProvider}
+   * @type {import("./url-config.js").UrlConfigProvider}
    */
-  config: any;
+  config: import("./url-config.js").UrlConfigProvider;
   /** Creates a new [[Param]] for a given location (DefType) */
   paramFactory: ParamFactory;
   /**

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

@@ -57,8 +57,8 @@ export class HttpProvider {
     | ((
         $browser: any,
         $httpBackend: any,
-        $rootScope: any,
-        $injector: any,
+        $rootScope: import("../../core/scope/scope.js").Scope,
+        $injector: import("../../core/di/internal-injector.js").InjectorService,
         $sce: any,
       ) => {
         (requestConfig: any): Promise<any>;

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

@@ -0,0 +1,219 @@
+export interface HttpHeadersGetter {
+  (): {
+    [name: string]: string;
+  };
+  (headerName: string): string;
+}
+export interface HttpRequestConfigHeaders {
+  [requestType: string]: any;
+  common?: any;
+  get?: any;
+  post?: any;
+  put?: any;
+  patch?: any;
+}
+export interface HttpRequestTransformer {
+  (data: any, headersGetter: HttpHeadersGetter): any;
+}
+export interface HttpResponseTransformer {
+  (data: any, headersGetter: HttpHeadersGetter, status: number): any;
+}
+/**
+ * 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.
+ * https://docs.angularjs.org/api/ng/service/$http#defaults
+ * https://docs.angularjs.org/api/ng/service/$http#usage
+ * https://docs.angularjs.org/api/ng/provider/$httpProvider The properties section
+ */
+export interface HttpProviderDefaults {
+  /**
+   * {boolean|Cache}
+   * If true, a default $http cache will be used to cache the GET request, otherwise if a cache instance built with $cacheFactory, this cache will be used for caching.
+   */
+  cache?: any;
+  /**
+   * Transform function or an array of such functions. The transform function takes the http request body and
+   * headers and returns its transformed (typically serialized) version.
+   * @see {@link https://docs.angularjs.org/api/ng/service/$http#transforming-requests-and-responses}
+   */
+  transformRequest?:
+    | HttpRequestTransformer
+    | HttpRequestTransformer[]
+    | undefined;
+  /**
+   * Transform function or an array of such functions. The transform function takes the http response body and
+   * headers and returns its transformed (typically deserialized) version.
+   */
+  transformResponse?:
+    | HttpResponseTransformer
+    | HttpResponseTransformer[]
+    | undefined;
+  /**
+   * Map of strings or functions which return strings representing HTTP headers to send to the server. If the
+   * return value of a function is null, the header will not be sent.
+   * The key of the map is the request verb in lower case. The "common" key applies to all requests.
+   * @see {@link https://docs.angularjs.org/api/ng/service/$http#setting-http-headers}
+   */
+  headers?: HttpRequestConfigHeaders | undefined;
+  /** Name of HTTP header to populate with the XSRF token. */
+  xsrfHeaderName?: string | undefined;
+  /** Name of cookie containing the XSRF token. */
+  xsrfCookieName?: string | undefined;
+  /**
+   * whether to to set the withCredentials flag on the XHR object. See [requests with credentials]https://developer.mozilla.org/en/http_access_control#section_5 for more information.
+   */
+  withCredentials?: boolean | undefined;
+  /**
+   * A function used to the prepare string representation of request parameters (specified as an object). If
+   * specified as string, it is interpreted as a function registered with the $injector. Defaults to
+   * $httpParamSerializer.
+   */
+  paramSerializer?: string | ((obj: any) => string) | undefined;
+}
+/**
+ * Object describing the request to be made and how it should be processed.
+ * see http://docs.angularjs.org/api/ng/service/$http#usage
+ */
+export interface RequestShortcutConfig extends HttpProviderDefaults {
+  /**
+   * {Object.<string|Object>}
+   * Map of strings or objects which will be turned to ?key1=value1&key2=value2 after the url. If the value is not a string, it will be JSONified.
+   */
+  params?: any;
+  /**
+   * {string|Object}
+   * Data to be sent as the request message data.
+   */
+  data?: any;
+  /**
+   * Timeout in milliseconds, or promise that should abort the request when resolved.
+   */
+  timeout?: number | Promise<any> | undefined;
+  /**
+   * See [XMLHttpRequest.responseType]https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#xmlhttprequest-responsetype
+   */
+  responseType?: string | undefined;
+}
+/**
+ * Object describing the request to be made and how it should be processed.
+ * see http://docs.angularjs.org/api/ng/service/$http#usage
+ */
+export interface RequestConfig extends RequestShortcutConfig {
+  /**
+   * HTTP method (e.g. 'GET', 'POST', etc)
+   */
+  method: string;
+  /**
+   * Absolute or relative URL of the resource that is being requested.
+   */
+  url: string;
+  /**
+   * Event listeners to be bound to the XMLHttpRequest object.
+   * To bind events to the XMLHttpRequest upload object, use uploadEventHandlers. The handler will be called in the context of a $apply block.
+   */
+  eventHandlers?:
+    | {
+        [type: string]: EventListenerOrEventListenerObject;
+      }
+    | undefined;
+  /**
+   * Event listeners to be bound to the XMLHttpRequest upload object.
+   * To bind events to the XMLHttpRequest object, use eventHandlers. The handler will be called in the context of a $apply block.
+   */
+  uploadEventHandlers?:
+    | {
+        [type: string]: EventListenerOrEventListenerObject;
+      }
+    | undefined;
+}
+export interface HttpResponse<T> {
+  data: T;
+  status: number;
+  headers: HttpHeadersGetter;
+  config: RequestConfig;
+  statusText: string;
+  /** Added in AngularJS 1.6.6 */
+  xhrStatus: "complete" | "error" | "timeout" | "abort";
+}
+export type HttpPromise<T> = Promise<HttpResponse<T>>;
+/**
+ * HttpService
+ */
+export interface HttpService {
+  /**
+   * Object describing the request to be made and how it should be processed.
+   */
+  <T>(config: RequestConfig): HttpPromise<T>;
+  /**
+   * Shortcut method to perform GET request.
+   *
+   * @param url Relative or absolute URL specifying the destination of the request
+   * @param config Optional configuration object
+   */
+  get<T>(url: string, config?: RequestShortcutConfig): HttpPromise<T>;
+  /**
+   * Shortcut method to perform DELETE request.
+   *
+   * @param url Relative or absolute URL specifying the destination of the request
+   * @param config Optional configuration object
+   */
+  delete<T>(url: string, config?: RequestShortcutConfig): HttpPromise<T>;
+  /**
+   * Shortcut method to perform HEAD request.
+   *
+   * @param url Relative or absolute URL specifying the destination of the request
+   * @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.
+   *
+   * @param url Relative or absolute URL specifying the destination of the request
+   * @param data Request content
+   * @param config Optional configuration object
+   */
+  post<T>(
+    url: string,
+    data: any,
+    config?: RequestShortcutConfig,
+  ): HttpPromise<T>;
+  /**
+   * Shortcut method to perform PUT request.
+   *
+   * @param url Relative or absolute URL specifying the destination of the request
+   * @param data Request content
+   * @param config Optional configuration object
+   */
+  put<T>(
+    url: string,
+    data: any,
+    config?: RequestShortcutConfig,
+  ): HttpPromise<T>;
+  /**
+   * Shortcut method to perform PATCH request.
+   *
+   * @param url Relative or absolute URL specifying the destination of the request
+   * @param data Request content
+   * @param config Optional configuration object
+   */
+  patch<T>(
+    url: string,
+    data: any,
+    config?: RequestShortcutConfig,
+  ): HttpPromise<T>;
+  /**
+   * Runtime equivalent of the $httpProvider.defaults property. Allows configuration of default headers, withCredentials as well as request and response transformations.
+   */
+  defaults: HttpProviderDefaults;
+  /**
+   * Array of config objects for currently pending requests. This is primarily meant to be used for debugging purposes.
+   */
+  pendingRequests: RequestConfig[];
+}

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

@@ -1,3 +1,29 @@
+/**
+ * @param {import('../browser.js').Browser} $browser
+ * @returns
+ */
+export function createHttpBackend(
+  $browser: import("../browser.js").Browser,
+): (
+  method: any,
+  url: any,
+  post: any,
+  callback: any,
+  headers: any,
+  timeout: any,
+  withCredentials: any,
+  responseType: any,
+  eventHandlers: any,
+  uploadEventHandlers: any,
+) => void;
+/**
+ * HTTP backend used by the {@link ng.$http service} that delegates to
+ * XMLHttpRequest object and deals with browser incompatibilities.
+ *
+ * You should never need to use this service directly, instead use the higher-level abstractions:
+ * {@link ng.$http $http}.
+ *
+ */
 /**
  * HTTP backend used by the {@link ng.$http service} that delegates to
  * XMLHttpRequest object and deals with browser incompatibilities.
@@ -6,7 +32,6 @@
  * {@link ng.$http $http}.
  *
  */
-export function HttpBackendProvider(): void;
 export class HttpBackendProvider {
   $get: (
     | string
@@ -26,21 +51,3 @@ export class HttpBackendProvider {
       ) => void)
   )[];
 }
-/**
- * @param {import('../browser.js').Browser} $browser
- * @returns
- */
-export function createHttpBackend(
-  $browser: import("../browser.js").Browser,
-): (
-  method: any,
-  url: any,
-  post: any,
-  callback: any,
-  headers: any,
-  timeout: any,
-  withCredentials: any,
-  responseType: any,
-  eventHandlers: any,
-  uploadEventHandlers: any,
-) => void;

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

@@ -0,0 +1,33 @@
+/**
+ * A function that logs messages. Accepts any number of arguments.
+ */
+export type LogCall = (...args: any[]) => void;
+/**
+ * A function that returns a LogService implementation.
+ */
+export type LogServiceFactory = (...args: any[]) => LogService;
+/**
+ * Service for logging messages at various levels.
+ */
+export interface LogService {
+  /**
+   * Log a debug message.
+   */
+  debug: LogCall;
+  /**
+   * Log an error message.
+   */
+  error: LogCall;
+  /**
+   * Log an info message.
+   */
+  info: LogCall;
+  /**
+   * Log a general message.
+   */
+  log: LogCall;
+  /**
+   * Log a warning message.
+   */
+  warn: LogCall;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Configuration provider for `$log` service
+ */
+export class LogProvider {
+  /** @type {boolean} */
+  debug: boolean;
+  /** @private @type {import("./interface.ts").LogServiceFactory | null} */
+  private _override;
+  /**
+   * Override the default {@link LogService} implemenation
+   * @param {import("./interface.ts").LogServiceFactory} fn
+   */
+  setLogger(fn: import("./interface.ts").LogServiceFactory): void;
+  /** @private */
+  private formatError;
+  /**
+   * @private
+   * @param {string} type
+   */
+  private consoleLog;
+  /**
+   * @returns {import("./interface.ts").LogService}
+   */
+  $get(): import("./interface.ts").LogService;
+}

package/@types/{core → services}/pubsub/pubsub.d.ts

@@ -2,9 +2,9 @@
 
 /**
  * Configurable provider for an injectable event bus
- * @implements {ServiceProvider}
+ * @extends {ServiceProvider}
  */
-export class PubSubProvider implements ServiceProvider {
+export class PubSubProvider {
   /**
    * @type {PubSub}
    */
@@ -69,7 +69,7 @@ export class PubSub {
    * representation minimizes the number of object allocations and has been
    * shown to be faster than an array of objects with three key-value pairs or
    * three parallel arrays, especially on IE.) Once a subscription is removed
-   * via {@link #unsubscribe} or {@link #unsubscribeByKey}, the three
+   * via {@link unsubscribe} or {@link unsubscribeByKey}, the three
    * corresponding array elements are deleted, and never reused. This means the
    * total number of subscriptions during the lifetime of the pubsub channel is
    * limited by the maximum length of a JavaScript array to (2^32 - 1) / 3 =
@@ -95,7 +95,7 @@ export class PubSub {
    * is specified.  Subscribing the same function to the same topic multiple
    * times will result in multiple function invocations while publishing.
    * Returns a subscription key that can be used to unsubscribe the function from
-   * the topic via {@link #unsubscribeByKey}.
+   * the topic via {@link unsubscribeByKey}.
    *
    * @param {string} topic Topic to subscribe to.
    * @param {Function} fn Function to be invoked when a message is published to
@@ -110,7 +110,7 @@ export class PubSub {
    * method on the given `opt_context` object, or in the global scope if
    * no context is specified, and is then unsubscribed.  Returns a subscription
    * key that can be used to unsubscribe the function from the topic via
-   * {@link #unsubscribeByKey}.
+   * {@link unsubscribeByKey}.
    *
    * @param {string} topic Topic to subscribe to.
    * @param {Function} fn Function to be invoked once and then unsubscribed when
@@ -140,7 +140,7 @@ export class PubSub {
     opt_context?: any | undefined,
   ): boolean;
   /**
-   * Removes a subscription based on the key returned by {@link #subscribe}.
+   * Removes a subscription based on the key returned by {@link subscribe}.
    * No-op if no matching subscription is found.  Returns a Boolean indicating
    * whether a subscription was removed.
    *

package/@types/services/template-cache/interface.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A cache for mapping template names to their respective content.
+ */
+export type TemplateCache = Map<string, string>;

package/@types/services/template-cache/template-cache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Provides an instance of a cache that can be used to store and retrieve template content.
+ */
+export class TemplateCacheProvider {
+  /** @type {import('./interface.ts').TemplateCache} */
+  cache: import("./interface.ts").TemplateCache;
+  /**
+   * @returns {import('./interface.ts').TemplateCache}
+   */
+  $get: () => import("./interface.ts").TemplateCache;
+}

package/@types/services/template-request.d.ts

@@ -44,7 +44,7 @@ export class TemplateRequestProvider {
     | string
     | ((
         $exceptionHandler: import("../core/exception-handler.js").ErrorHandler,
-        $templateCache: import("../core/cache/cache-factory.js").TemplateCache,
+        $templateCache: import("../services/template-cache/interface.ts").TemplateCache,
         $http: any,
         $sce: any,
       ) => {