@angular-wave/angular.ts 0.7.8 → 0.8.0

package/src/services/anchor-scroll.js

@@ -5,6 +5,7 @@ import {
   isString,
   getNodeName,
 } from "../shared/utils.js";
+import { $injectTokens as $t } from "../injection-tokens.js";
 
 /**
  * @typedef {Object} AnchorScrollObject
@@ -25,8 +26,8 @@ export class AnchorScrollProvider {
   }
 
   $get = [
-    "$location",
-    "$rootScope",
+    $t.$location,
+    $t.$rootScope,
     /**
      *
      * @param {import('../services/location/location.js').Location} $location
@@ -104,7 +105,7 @@ export class AnchorScrollProvider {
           ? hash
           : isNumber(hash)
             ? hash.toString()
-            : $location.hash();
+            : $location.getHash();
         let elm;
 
         // empty hash, scroll to the top of the page
@@ -121,7 +122,7 @@ export class AnchorScrollProvider {
       };
 
       // does not scroll when user clicks on anchor link that is currently on
-      // (no url change, no $location.hash() change), browser native does scroll
+      // (no url change, no $location.getHash() change), browser native does scroll
       if (this.autoScrollingEnabled) {
         $rootScope["$location"] = $location;
         $rootScope.$watch("$location.$$hash", (newVal, oldVal) => {

package/src/services/http/http.js

@@ -291,6 +291,7 @@ export function HttpProvider() {
   });
 
   let useApplyAsync = false;
+
   /**
    * 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
@@ -323,7 +324,7 @@ export function HttpProvider() {
    *
    * {@link ng.$http#interceptors Interceptors detailed info}
    */
-  const interceptorFactories = (this.interceptors = []);
+  this.interceptors = [];
 
   /**
    * Array containing URLs whose origins are trusted to receive the XSRF token. See the
@@ -360,8 +361,10 @@ export function HttpProvider() {
    *     $http.get('https://stats.example.com/activity').then(...);
    *   }]);
    * ```
+   *
+   * @type {string[]}
    */
-  const xsrfTrustedOrigins = (this.xsrfTrustedOrigins = []);
+  this.xsrfTrustedOrigins = [];
 
   /**
    * This property is deprecated. Use {@link $httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}
@@ -407,7 +410,7 @@ export function HttpProvider() {
        */
       const reversedInterceptors = [];
 
-      interceptorFactories.forEach((interceptorFactory) => {
+      this.interceptors.forEach((interceptorFactory) => {
         reversedInterceptors.unshift(
           isString(interceptorFactory)
             ? $injector.get(interceptorFactory)
@@ -418,7 +421,9 @@ export function HttpProvider() {
       /**
        * A function to check request URLs against a list of allowed origins.
        */
-      const urlIsAllowedOrigin = urlIsAllowedOriginFactory(xsrfTrustedOrigins);
+      const urlIsAllowedOrigin = urlIsAllowedOriginFactory(
+        this.xsrfTrustedOrigins,
+      );
 
       /**
        * @property {Array.<Object>} requestConfig Array of config objects for currently pending

package/src/services/http/http.spec.js

@@ -1,6 +1,6 @@
 import { createInjector } from "../../core/di/injector.js";
 import { isObject } from "../../shared/utils.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
 export function getLastAjaxRequest() {
@@ -238,12 +238,7 @@ describe("$http", function () {
     });
     expect(response.headers).toBeDefined();
     expect(response.headers instanceof Function).toBe(true);
-    expect(response.headers("Content-Type")).toBe(
-      "application/json; charset=utf-8",
-    );
-    expect(response.headers("content-type")).toBe(
-      "application/json; charset=utf-8",
-    );
+    expect(response.headers("Content-Type")).toBe("text/html; charset=utf-8");
   });
 
   it("may returns all response headers", async function () {

package/src/services/http/template-request.spec.js

@@ -1,5 +1,5 @@
 import { createInjector } from "../../core/di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
 describe("$templateRequest", () => {

package/src/services/http-backend/http-backend.js

@@ -1,25 +1,14 @@
-import { trimEmptyHash, urlResolve } from "../../shared/url-utils/url-utils.js";
+import { trimEmptyHash } from "../../shared/url-utils/url-utils.js";
 import { isDefined, isPromiseLike, isUndefined } from "../../shared/utils.js";
 
 /**
- * HTTP backend used by the {@link ng.$http service} that delegates to
+ * HTTP backend used by the `$http` 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.
- *
- * You should never need to use this service directly, instead use the higher-level abstractions:
- * {@link ng.$http $http}.
- *
+ * You should never need to use this service directly.
  */
 export class HttpBackendProvider {
   constructor() {
-    this.$get = [() => createHttpBackend()];
+    this.$get = () => createHttpBackend();
   }
 }
 
@@ -27,7 +16,21 @@ export class HttpBackendProvider {
  * @returns
  */
 export function createHttpBackend() {
-  // TODO(vojta): fix the signature
+  /**
+   * 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 {Object<string, EventListener>} [eventHandlers] - Event listeners for the XMLHttpRequest object.
+   * @param {Object<string, EventListener>} [uploadEventHandlers] - Event listeners for the XMLHttpRequest.upload object.
+   * @returns {void}
+   */
   return function (
     method,
     url,
@@ -44,34 +47,31 @@ export function createHttpBackend() {
 
     const xhr = new XMLHttpRequest();
     let abortedByTimeout = false;
+    let timeoutId;
 
     xhr.open(method, url, true);
+
     if (headers) {
-      Object.entries(headers).forEach(([key, value]) => {
+      for (const [key, value] of Object.entries(headers)) {
         if (isDefined(value)) {
           xhr.setRequestHeader(key, value);
         }
-      });
+      }
     }
 
-    xhr.onload = function () {
+    xhr.onload = () => {
+      let status = xhr.status || 0;
       const statusText = xhr.statusText || "";
 
-      let status = xhr.status;
-
-      // fix status code when it is 0 (0 status is undocumented).
-      // Occurs when accessing file resources or on Android 4.1 stock browser
-      // while retrieving files from application cache.
       if (status === 0) {
         status = xhr.response
           ? 200
-          : urlResolve(url).protocol === "file"
+          : new URL(url).protocol === "file:"
             ? 404
             : 0;
       }
 
       completeRequest(
-        callback,
         status,
         xhr.response,
         xhr.getAllResponseHeaders(),
@@ -80,20 +80,11 @@ export function createHttpBackend() {
       );
     };
 
-    xhr.onerror = function () {
-      // The response is always empty
-      // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
-      completeRequest(callback, -1, null, null, "", "error");
-    };
-    xhr.ontimeout = function () {
-      // The response is always empty
-      // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
-      completeRequest(callback, -1, null, null, "", "timeout");
-    };
+    xhr.onerror = () => completeRequest(-1, null, null, "", "error");
+    xhr.ontimeout = () => completeRequest(-1, null, null, "", "timeout");
 
-    xhr.onabort = function () {
+    xhr.onabort = () => {
       completeRequest(
-        callback,
         -1,
         null,
         null,
@@ -103,16 +94,15 @@ export function createHttpBackend() {
     };
 
     if (eventHandlers) {
-      eventHandlers &&
-        Object.entries(eventHandlers).forEach(([key, value]) => {
-          xhr.addEventListener(key, value);
-        });
+      for (const [key, handler] of Object.entries(eventHandlers)) {
+        xhr.addEventListener(key, handler);
+      }
     }
 
     if (uploadEventHandlers) {
-      Object.entries(uploadEventHandlers).forEach(([key, value]) => {
-        xhr.upload.addEventListener(key, value);
-      });
+      for (const [key, handler] of Object.entries(uploadEventHandlers)) {
+        xhr.upload.addEventListener(key, handler);
+      }
     }
 
     if (withCredentials) {
@@ -123,61 +113,45 @@ export function createHttpBackend() {
       try {
         xhr.responseType = responseType;
       } catch (e) {
-        // WebKit added support for the json responseType value on 09/03/2013
-        // https://bugs.webkit.org/show_bug.cgi?id=73648. Versions of Safari prior to 7 are
-        // known to throw when setting the value "json" as the response type. Other older
-        // browsers implementing the responseType
-        //
-        // The json response type can be ignored if not supported, because JSON payloads are
-        // parsed on the client-side regardless.
-        if (responseType !== "json") {
-          throw e;
-        }
+        if (responseType !== "json") throw e;
       }
     }
 
     xhr.send(isUndefined(post) ? null : post);
 
-    // Since we are using xhr.abort() when a request times out, we have to set a flag that
-    // indicates to requestAborted if the request timed out or was aborted.
-    //
-    // http.timeout = numerical timeout   timeout
-    // http.timeout = $timeout            timeout
-    // http.timeout = promise             abort
-    // xhr.abort()                        abort (The xhr object is normally inaccessible, but
-    //                                    can be exposed with the xhrFactory)
-    /** @type {number} */
-    let timeoutId;
-    if (timeout > 0) {
-      timeoutId = setTimeout(() => {
-        timeoutRequest("timeout");
-      }, timeout);
+    if (typeof timeout === "number" && timeout > 0) {
+      timeoutId = setTimeout(() => timeoutRequest("timeout"), timeout);
     } else if (isPromiseLike(timeout)) {
-      timeout.then(() => {
-        timeoutRequest(isDefined(timeout.$$timeoutId) ? "timeout" : "abort");
+      /** @type {Promise} */ (timeout).then(() => {
+        timeoutRequest(isDefined(timeout["$$timeoutId"]) ? "timeout" : "abort");
       });
     }
 
+    /**
+     * @param {"timeout"|"abort"} reason
+     */
     function timeoutRequest(reason) {
       abortedByTimeout = reason === "timeout";
-      if (xhr) {
-        xhr.abort();
-      }
+      if (xhr) xhr.abort();
     }
 
+    /**
+     * @param {number} status - HTTP status code or -1 for network errors.
+     * @param {*} response - The parsed or raw response from the server.
+     * @param {string|null} headersString - The raw response headers as a string.
+     * @param {string} statusText - The status text returned by the server.
+     * @param {"complete"|"error"|"timeout"|"abort"} xhrStatus - Final status of the request.
+     */
     function completeRequest(
-      callback,
       status,
       response,
       headersString,
       statusText,
       xhrStatus,
     ) {
-      // cancel timeout and subsequent timeout promise resolution
       if (isDefined(timeoutId)) {
         clearTimeout(timeoutId);
       }
-
       callback(status, response, headersString, statusText, xhrStatus);
     }
   };

package/src/services/http-backend/http-backend.spec.js

@@ -1,5 +1,4 @@
-import { createInjector } from "../../core/di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createHttpBackend } from "./http-backend.js";
 import sinon from "sinon";
 

package/src/services/http-backend/http-backend.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/services/http-backend/http-backend.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/services/location/interface.ts

@@ -6,3 +6,65 @@
  * @returns void
  */
 export type UrlChangeListener = (url: string, state: History["state"]) => void;
+
+/**
+ * Represents the configuration options for HTML5 mode.
+ */
+export interface Html5Mode {
+  /**
+   * If true, will rely on `history.pushState` to change URLs where supported.
+   * Falls back to hash-prefixed paths in browsers that do not support `pushState`.
+   * @default false
+   */
+  enabled: boolean;
+
+  /**
+   * When html5Mode is enabled, specifies whether or not a `<base>` tag is required to be present.
+   * If both `enabled` and `requireBase` are true, and a `<base>` tag is not present,
+   * an error will be thrown when `$location` is injected.
+   * @default true
+   */
+  requireBase: boolean;
+
+  /**
+   * When html5Mode is enabled, enables or disables URL rewriting for relative links.
+   * If set to a string, URL rewriting will only apply to links with an attribute that matches the given string.
+   * For example, if set to `'internal-link'`, URL rewriting will only occur for `<a internal-link>` links.
+   * Attribute name normalization does not apply here.
+   * @default true
+   */
+  rewriteLinks: boolean | string;
+}
+
+/**
+ * Represents default port numbers for various protocols.
+ */
+export interface DefaultPorts {
+  http: number;
+  https: number;
+  ftp: number;
+}
+
+/**
+ * Represents the individual components of a URL.
+ */
+export interface UrlParts {
+  /**
+   * The URL path (e.g. `/dashboard`, `/users/123`).
+   */
+  path: string;
+
+  /**
+   * The parsed query string as an object.
+   * Mirrors AngularJS’s `$location.setSearch()` format.
+   */
+  search: Record<
+    string,
+    string | number | boolean | (string | number | boolean)[]
+  >;
+
+  /**
+   * The fragment identifier (everything after `#`, not including the `#` itself).
+   */
+  hash: string;
+}