@angular-wave/angular.ts 0.15.1 → 0.15.2

package/@types/angular.d.ts

@@ -1,4 +1,7 @@
 export class Angular extends EventTarget {
+  constructor(submodule?: boolean);
+  /** @private @type {boolean} */
+  private _submodule;
   /** @private @type {!Array<string|any>} */
   private _bootsrappedModules;
   /** @public @type {ng.PubSubService} */

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

@@ -5,10 +5,10 @@
  *
  * @param {Object} target - The object to be wrapped in a proxy.
  * @param {Scope} [context] - The context for the handler, used to track listeners.
- * @returns {Scope} - A proxy that intercepts operations on the target object,
+ * @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;
+export function createScope(target?: any, context?: Scope): Scope | any;
 /**
  * @ignore
  * Checks if a target should be excluded from scope observability
@@ -19,13 +19,13 @@ export function isNonScope(target: any): boolean;
 /** @ignore @type {Function[]}*/
 export const $postUpdateQueue: Function[];
 export class RootScopeProvider {
-  rootScope: Scope;
+  rootScope: any;
   $get: (
     | string
     | ((
         exceptionHandler: ng.ExceptionHandlerService,
         parse: ng.ParseService,
-      ) => Scope)
+      ) => any)
   )[];
 }
 /**
@@ -45,22 +45,14 @@ export class Scope {
   context: Scope;
   /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
   watchers: Map<string, Array<import("./interface.ts").Listener>>;
-  /** @type {Map<String, Function[]>} Event listeners */
-  $$listeners: Map<string, Function[]>;
-  /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
-  foreignListeners: Map<string, Array<import("./interface.ts").Listener>>;
-  /** @type {Set<Proxy<ng.Scope>>} */
-  foreignProxies: Set<ProxyConstructor>;
-  /** @type {WeakMap<Object, Array<string>>} */
-  objectListeners: WeakMap<any, Array<string>>;
-  /** @type {Map<Function, {oldValue: any, fn: Function}>} */
-  functionListeners: Map<
-    Function,
-    {
-      oldValue: any;
-      fn: Function;
-    }
-  >;
+  /** @private @type {Map<String, Function[]>} Event listeners */
+  private _listeners;
+  /** @private @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
+  private _foreignListeners;
+  /** @private @type {Set<Proxy<ng.Scope>>} */
+  private _foreignProxies;
+  /** @private @type {WeakMap<Object, Array<string>>} */
+  private _objectListeners;
   /** @type {Proxy<Scope>} Current proxy being operated on */
   $proxy: ProxyConstructor;
   /** @type {Scope} The actual proxy */
@@ -82,10 +74,10 @@ export class Scope {
    */
   $root: Scope;
   $parent: Scope;
-  filters: any[];
-  /** @type {boolean} */
-  $$destroyed: boolean;
-  scheduled: any[];
+  /** @ignore @type {boolean} */
+  _destroyed: boolean;
+  /** @private @type {import("./interface.ts").Listener[]} A list of scheduled Event listeners */
+  private _scheduled;
   $scopename: any;
   /** @private */
   private propertyMap;

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

@@ -1,20 +1,9 @@
-export function weekParser(isoWeek: any, existingDate: any): any;
-export function createDateParser(
-  regexp: any,
-  mapping: any,
-): (iso: any, previousDate: any) => any;
-export function createDateInputType(
-  type: any,
-  regexp: any,
-  parseDate: any,
-): (
-  scope: any,
-  element: any,
-  attr: any,
-  ctrl: any,
-  $filter: any,
-  $parse: any,
-) => void;
+/**
+ * @param {string} type
+ * @param {RegExp} regexp
+ * @returns {*}
+ */
+export function createStringDateInputType(type: string, regexp: RegExp): any;
 export function badInputChecker(
   scope: any,
   element: any,
@@ -35,7 +24,6 @@ export function numberInputType(
   element: any,
   attr: any,
   ctrl: any,
-  $filter: any,
   $parse: any,
 ): void;
 export function rangeInputType(
@@ -45,41 +33,21 @@ export function rangeInputType(
   ctrl: any,
 ): void;
 /**
- * @param {ng.FilterFactory} $filter
  * @param {ng.ParseService} $parse
  * @returns {ng.Directive}
  */
-export function inputDirective(
-  $filter: ng.FilterFactory,
-  $parse: ng.ParseService,
-): ng.Directive;
+export function inputDirective($parse: ng.ParseService): ng.Directive;
 export namespace inputDirective {
   let $inject: string[];
 }
 /**
  * @returns {ng.Directive}
  */
-export function hiddenInputBrowserCacheDirective(): ng.Directive;
+export function hiddenInputDirective(): ng.Directive;
 /**
  * @returns {ng.Directive}
  */
 export function ngValueDirective(): ng.Directive;
-/**
- * @param {Date} date
- * @param {any} timezone
- * @param {undefined} [reverse]
- */
-export function convertTimezoneToLocal(
-  date: Date,
-  timezone: any,
-  reverse?: undefined,
-): Date;
-/**
- * @param {any} timezone
- * @param {number} [fallback]
- * @returns {number}
- */
-export function timezoneToOffset(timezone: any, fallback?: number): number;
 export const ISO_DATE_REGEXP: RegExp;
 export const URL_REGEXP: RegExp;
 export const EMAIL_REGEXP: RegExp;

package/@types/directive/show-hide/show-hide.d.ts

@@ -7,9 +7,10 @@ export namespace ngShowDirective {
   let $inject: string[];
 }
 /**
+ * @param {ng.AnimateService} $animate
  * @returns {ng.Directive}
  */
-export function ngHideDirective($animate: any): ng.Directive;
+export function ngHideDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngHideDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };

package/@types/namespace.d.ts

@@ -20,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,
@@ -214,5 +218,7 @@ declare global {
     type AnchorScrollObject = TAnchorScrollObject;
     type InjectionTokens = typeof PublicInjectionTokens;
     type ScopeEvent = TScopeEvent;
+    type RequestShortcutConfig = TRequestShortcutConfig;
+    type HttpProviderDefaults = THttpProviderDefaults;
   }
 }

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

@@ -176,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.
    *

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

@@ -7,16 +7,9 @@ export interface TemplateRequestService {
    * empty then a $compile error will be thrown (unless
    * {ignoreRequestError} is set to true).
    *
-   * @param tpl                  The template URL.
-   * @param ignoreRequestError   Whether or not to ignore the exception
-   *                             when the request fails or the template is
-   *                             empty.
+   * @param templateUrl The template URL.
    *
    * @return   A promise whose value is the template content.
    */
-  (tpl: string, ignoreRequestError?: boolean): Promise<string>;
-  /**
-   * total amount of pending template requests being downloaded.
-   */
-  totalPendingRequests: number;
+  (templateUrl: string): Promise<string>;
 }

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

@@ -1,52 +1,19 @@
 /**
- * Used to configure the options passed to the {@link $http} service when making a template request.
+ * Provider for the `$templateRequest` service.
  *
- * For example, it can be used for specifying the "Accept" header that is sent to the server, when
- * requesting a template.
+ * Fetches templates via HTTP and caches them in `$templateCache`.
+ * Templates are assumed trusted. This provider allows configuring
+ * per-request `$http` options such as headers, timeout, or transform functions.
  */
-export function TemplateRequestProvider(): void;
 export class TemplateRequestProvider {
-  /**
-   * The options to be passed to the {@link $http} service when making the request.
-   * You can use this to override options such as the "Accept" header for template requests.
-   * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
-   * options if not overridden here.
-   *
-   * @param {string=} val new value for the {@link $http} options.
-   * @returns {string|TemplateRequestProvider} Returns the {@link $http} options when used as getter and self if used as setter.
-   */
-  httpOptions: (val?: string | undefined) => string | TemplateRequestProvider;
-  /**
-   * The `$templateRequest` service runs security checks then downloads the provided template using
-   * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
-   * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
-   * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
-   * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
-   * when `tpl` is of type string and `$templateCache` has the matching entry.
-   *
-   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
-   * can configure this via {@link $templateRequestProvider#httpOptions}.
-   *
-   * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
-   * as {@link ngInclude} to download and cache templates.
-   *
-   * 3rd party modules should use `$templateRequest` if their services or directives are loading
-   * templates.
-   *
-   * @param {string} tpl The HTTP request template URL
-   * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
-   *
-   * @return {Promise} a promise for the HTTP response data of the given URL.
-   *
-   * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
-   */
+  /** @type {ng.RequestShortcutConfig|undefined} */
+  httpOptions: ng.RequestShortcutConfig | undefined;
+  /** @returns {Array} DI tokens for Angular.ts injection */
   $get: (
     | string
     | ((
-        $exceptionHandler: ng.ExceptionHandlerService,
         $templateCache: ng.TemplateCacheService,
         $http: ng.HttpService,
-        $sce: any,
       ) => ng.TemplateRequestService)
   )[];
 }

package/@types/shared/utils.d.ts

@@ -195,16 +195,6 @@ export function isBoolean(value: any): boolean;
  * @returns {boolean}
  */
 export function isPromiseLike(obj: any): boolean;
-/**
- * @param {*} value
- * @returns {boolean}
- */
-export function isTypedArray(value: any): boolean;
-/**
- * @param {*} obj
- * @returns {boolean}
- */
-export function isArrayBuffer(obj: any): boolean;
 /**
  * @param {*} value
  * @returns {string | *}