@angular-wave/angular.ts 0.9.3 → 0.9.5

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

@@ -11,7 +11,11 @@
  */
 export function HttpParamSerializerProvider(): void;
 export class HttpParamSerializerProvider {
-  $get: () => (params: any) => string;
+  /**
+   * @returns {import('./interface.ts').HttpParamSerializer}
+   * A function that serializes parameters into a query string.
+   */
+  $get: () => import("./interface.ts").HttpParamSerializer;
 }
 export function defaultHttpResponseTransform(data: any, headers: any): any;
 /**
@@ -102,7 +106,6 @@ export class HttpProvider {
   $get: (
     | string
     | ((
-        $httpBackend: any,
         $injector: import("../../core/di/internal-injector.js").InjectorService,
         $sce: any,
       ) => {
@@ -132,3 +135,38 @@ export class HttpProvider {
       })
   )[];
 }
+/**
+ * Makes an HTTP request using XMLHttpRequest with flexible options.
+ *
+ * @param {string} method - The HTTP method (e.g., "GET", "POST").
+ * @param {string} [url] - The URL to send the request to. Defaults to the current page URL.
+ * @param {*} [post] - The body to send with the request, if any.
+ * @param {function(number, any, string|null, string, string): void} [callback] - Callback invoked when the request completes.
+ * @param {Object<string, string|undefined>} [headers] - Headers to set on the request.
+ * @param {number|Promise<any>} [timeout] - Timeout in ms or a cancellable promise.
+ * @param {boolean} [withCredentials] - Whether to send credentials with the request.
+ * @param {XMLHttpRequestResponseType} [responseType] - The type of data expected in the response.
+ * @param {Record<string, EventListener>} [eventHandlers] - Event listeners for the XMLHttpRequest object.
+ * @param {Record<string, EventListener>} [uploadEventHandlers] - Event listeners for the XMLHttpRequest.upload object.
+ * @returns {void}
+ */
+export function http(
+  method: string,
+  url?: string,
+  post?: any,
+  callback?: (
+    arg0: number,
+    arg1: any,
+    arg2: string | null,
+    arg3: string,
+    arg4: string,
+  ) => void,
+  headers?: {
+    [x: string]: string;
+  },
+  timeout?: number | Promise<any>,
+  withCredentials?: boolean,
+  responseType?: XMLHttpRequestResponseType,
+  eventHandlers?: Record<string, EventListener>,
+  uploadEventHandlers?: Record<string, EventListener>,
+): void;

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

@@ -217,3 +217,14 @@ export interface HttpService {
    */
   pendingRequests: RequestConfig[];
 }
+/**
+ * Represents an object of key-value pairs to be serialized into an HTTP query string.
+ */
+export type HttpParams = Record<
+  string,
+  string | number | boolean | null | undefined | unknown[]
+>;
+/**
+ * A function that serializes an object into a URL-encoded query string.
+ */
+export type HttpParamSerializer = (params?: HttpParams) => string;

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

@@ -321,10 +321,7 @@ export class LocationProvider {
   lastCachedState: any;
   $get: (
     | string
-    | ((
-        $rootScope: import("../../core/scope/scope.js").Scope,
-        $rootElement: Element,
-      ) => Location)
+    | (($rootScope: ng.Scope, $rootElement: Element) => Location)
   )[];
   #private;
 }

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

@@ -10,7 +10,7 @@ export class SceProvider {
    * Enables/disables SCE and returns the current value.
    */
   enabled: (value?: boolean | undefined, ...args: any[]) => boolean;
-  $get: (string | (($parse: any, $sceDelegate: any) => any))[];
+  $get: (string | (($parse: ng.ParseService, $sceDelegate: any) => any))[];
 }
 export namespace SCE_CONTEXTS {
   let HTML: string;
@@ -225,9 +225,9 @@ export class SceDelegateProvider {
   $get: (
     | string
     | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
+        $injector: ng.InjectorService,
         $$sanitizeUri: any,
-        $exceptionHandler: ErrorHandler,
+        $exceptionHandler: ng.ExceptionHandlerService,
       ) => {
         trustAs: (type: string, trustedValue: any) => any;
         getTrusted: (type: string, maybeTrusted: any) => any;
@@ -235,4 +235,3 @@ export class SceDelegateProvider {
       })
   )[];
 }
-export type ErrorHandler = import("../exception/interface.ts").Interface;

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

@@ -2,10 +2,10 @@
  * 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;
+  /** @type {ng.TemplateCacheService} */
+  cache: ng.TemplateCacheService;
   /**
-   * @returns {import('./interface.ts').TemplateCache}
+   * @returns {ng.TemplateCacheService}
    */
-  $get(): import("./interface.ts").TemplateCache;
+  $get(): ng.TemplateCacheService;
 }

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

@@ -0,0 +1,22 @@
+export interface TemplateRequestService {
+  /**
+   * Downloads a 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 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.
+   *
+   * @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;
+}

package/@types/services/{template-request.d.ts → template-request/template-request.d.ts}

@@ -43,13 +43,10 @@ export class TemplateRequestProvider {
   $get: (
     | string
     | ((
-        $exceptionHandler: import("./exception/exception-handler.js").ErrorHandler,
-        $templateCache: import("../services/template-cache/interface.ts").TemplateCache,
-        $http: any,
+        $exceptionHandler: ng.ExceptionHandlerService,
+        $templateCache: ng.TemplateCacheService,
+        $http: ng.HttpService,
         $sce: any,
-      ) => {
-        (tpl: any, ignoreRequestError: any): any;
-        totalPendingRequests: number;
-      })
+      ) => ng.TemplateRequestService)
   )[];
 }

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

@@ -1,67 +1,4 @@
 export function equals(o1: any, o2: any): any;
-/**
- * Builds proxy functions on the `to` object which pass through to the `from` object.
- *
- * For each key in `fnNames`, creates a proxy function on the `to` object.
- * The proxy function calls the real function on the `from` object.
- *
- *
- * #### Example:
- * This example creates an new class instance whose functions are prebound to the new'd object.
- * ```js
- * class Foo {
- *   constructor(data) {
- *     // Binds all functions from Foo.prototype to 'this',
- *     // then copies them to 'this'
- *     bindFunctions(Foo.prototype, this, this);
- *     this.data = data;
- *   }
- *
- *   log() {
- *     console.log(this.data);
- *   }
- * }
- *
- * let myFoo = new Foo([1,2,3]);
- * var logit = myFoo.log;
- * logit(); // logs [1, 2, 3] from the myFoo 'this' instance
- * ```
- *
- * #### Example:
- * This example creates a bound version of a service function, and copies it to another object
- * ```
- *
- * var SomeService = {
- *   this.data = [3, 4, 5];
- *   this.log = function() {
- *     console.log(this.data);
- *   }
- * }
- *
- * // Constructor fn
- * function OtherThing() {
- *   // Binds all functions from SomeService to SomeService,
- *   // then copies them to 'this'
- *   bindFunctions(SomeService, this, SomeService);
- * }
- *
- * let myOtherThing = new OtherThing();
- * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'
- * ```
- *
- * @param source A function that returns the source object which contains the original functions to be bound
- * @param target A function that returns the target object which will receive the bound functions
- * @param bind A function that returns the object which the functions will be bound to
- * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)
- * @param latebind If true, the binding of the function is delayed until the first time it's invoked
- */
-export function createProxyFunctions(
-  source: any,
-  target: any,
-  bind: any,
-  fnNames: any,
-  latebind?: boolean,
-): any;
 /**
  * prototypal inheritance helper.
  * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
@@ -75,7 +12,14 @@ export function createProxyFunctions(
  * @returns {Object} - A new object with `parent` as its prototype and properties from `extra`.
  */
 export function inherit(parent: any, extra?: any): any;
-export function _removeFrom(array: any, obj: any): any;
+/**
+ * Given an array, and an item, if the item is found in the array, it removes it (in-place).
+ * The same array is returned
+ * @param {Array} array
+ * @param {any} obj
+ * @returns {Array}
+ */
+export function removeFrom(array: any[], obj: any): any[];
 /**
  * Applies a set of defaults to an options object.  The options object is filtered
  * to only those properties of the objects in the defaultsList.
@@ -177,11 +121,6 @@ export function tail<T>(arr: T[]): T | undefined;
  * shallow copy from src to dest
  */
 export function copy(src: any, dest: any): any;
-/**
- * Given an array, and an item, if the item is found in the array, it removes it (in-place).
- * The same array is returned
- */
-export const removeFrom: any;
 export function allTrueR(memo: any, elem: any): any;
 export function anyTrueR(memo: any, elem: any): any;
 export function unnestR(memo: any, elem: any): any;

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

@@ -48,12 +48,13 @@ export function curry(fn: any): any | (() => any | any);
  */
 export function compose(...args: any[]): () => any;
 /**
- * Given a varargs list of functions, returns a function that is composes the argument functions, left-to-right
- * given: f(x), g(x), h(x)
- * let piped = pipe(f,g,h);
- * then, piped is: h(g(f(x)))
+ * Given a class constructor, returns a predicate function that checks
+ * whether a given object is an instance of that class.
+ *
+ * @param {new (...args: any[]) => any} ctor - The class constructor to check against.
+ * @returns {(obj: any) => boolean} A predicate function that returns true if the object is of the given class.
  */
-export function pipe(...args: any[]): any;
+export function is(ctor: new (...args: any[]) => any): (obj: any) => boolean;
 /**
  * Sorta like Pattern Matching (a functional programming conditional construct)
  *
@@ -103,6 +104,5 @@ export function pattern(struct: any): (arg0: any) => any;
  * getName(obj) === true
  */
 export const propEq: any;
-export function parse(name: any): any;
-export function is(ctor: any): (obj: any) => boolean;
+export function parse(path: any): (obj: any) => any;
 export function val(v: any): () => any;