@angular-wave/angular.ts 0.7.7 → 0.8.0

package/src/{core → shared}/url-utils/url-utils.spec.js

@@ -36,14 +36,6 @@ describe("urlUtils", () => {
       expect(parsed.pathname).toBe("/");
     });
 
-    it("should return an IPv6 hostname wrapped in brackets", () => {
-      // Support: IE 9-11 only, Edge 16-17 only (fixed in 18 Preview)
-      // IE/Edge don't wrap IPv6 addresses' hostnames in square brackets
-      // when parsed out of an anchor element.
-      const parsed = urlResolve("http://[::1]/");
-      expect(parsed.hostname).toBe("[::1]");
-    });
-
     it("should not put the domain in brackets for the hostname field", () => {
       const parsed = urlResolve("https://google.com/");
       expect(parsed.hostname).toBe("google.com");
@@ -87,7 +79,7 @@ describe("urlUtils", () => {
     beforeEach(() => {
       urlIsAllowedOrigin = urlIsAllowedOriginFactory([
         "https://foo.com/",
-        `${origin.protocol}://bar.com:1337/`,
+        `${origin.protocol}//bar.com:1337/`,
       ]);
     });
 
@@ -97,7 +89,7 @@ describe("urlUtils", () => {
 
     it("should check against the list of trusted origins", () => {
       expect(urlIsAllowedOrigin("https://foo.com/path")).toBe(true);
-      expect(urlIsAllowedOrigin(`${origin.protocol}://bar.com:1337/path`)).toBe(
+      expect(urlIsAllowedOrigin(`${origin.protocol}//bar.com:1337/path`)).toBe(
         true,
       );
       expect(urlIsAllowedOrigin("https://baz.com:1337/path")).toBe(false);
@@ -112,7 +104,8 @@ describe("urlUtils", () => {
     });
 
     it("should return true only if the origins (protocol, hostname, post) match", () => {
-      const differentProtocol = origin.protocol !== "http" ? "http" : "https";
+      const differentProtocol =
+        origin.protocol !== "http:" ? "http:" : "https:";
       const differentPort = (parseInt(origin.port, 10) || 0) + 1;
       let url;
 
@@ -121,7 +114,7 @@ describe("urlUtils", () => {
       expect(urlIsAllowedOrigin(url)).toBe(true);
 
       // Same origin
-      url = `${origin.protocol}://${origin.host}/path`;
+      url = `${origin.protocol}//${origin.host}/path`;
       expect(urlIsAllowedOrigin(url)).toBe(true);
 
       // Same origin - implicit protocol
@@ -129,15 +122,15 @@ describe("urlUtils", () => {
       expect(urlIsAllowedOrigin(url)).toBe(true);
 
       // Same origin - different protocol
-      url = `${differentProtocol}://${origin.host}/path`;
+      url = `${differentProtocol}//${origin.host}/path`;
       expect(urlIsAllowedOrigin(url)).toBe(false);
 
       // Same origin - different port
-      url = `${origin.protocol}://${origin.hostname}:${differentPort}/path`;
+      url = `${origin.protocol}//${origin.hostname}:${differentPort}/path`;
       expect(urlIsAllowedOrigin(url)).toBe(false);
 
       // Allowed origin
-      url = `${origin.protocol}://bar.com:1337/path`;
+      url = `${origin.protocol}//bar.com:1337/path`;
       expect(urlIsAllowedOrigin(url)).toBe(true);
 
       // Allowed origin - implicit protocol
@@ -145,11 +138,11 @@ describe("urlUtils", () => {
       expect(urlIsAllowedOrigin(url)).toBe(true);
 
       // Allowed origin - different protocol
-      url = `${differentProtocol}://bar.com:1337/path`;
+      url = `${differentProtocol}//bar.com:1337/path`;
       expect(urlIsAllowedOrigin(url)).toBe(false);
 
       // Allowed origin - different port
-      url = `${origin.protocol}://bar.com:1338/path`;
+      url = `${origin.protocol}//bar.com:1338/path`;
       expect(urlIsAllowedOrigin(url)).toBe(false);
     });
   });

package/src/{core → shared}/url-utils/url-utils.test.js

@@ -1,6 +1,6 @@
 import { test, expect } from "@playwright/test";
 
-const TEST_URL = "src/core/url-utils/url-utils.html";
+const TEST_URL = "src/shared/url-utils/url-utils.html";
 
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);

package/src/shared/utils.js

@@ -375,14 +375,6 @@ export function extend(dst, ...src) {
   return baseExtend(dst, src, false);
 }
 
-/**
- * @param {string} str
- * @returns {number}
- */
-export function toInt(str) {
-  return parseInt(str, 10);
-}
-
 /**
  * @param {any} num
  * @returns {boolean}
@@ -853,7 +845,7 @@ export function tryDecodeURIComponent(value) {
   try {
     return decodeURIComponent(value);
   } catch {
-    return;
+    /* empty */
   }
 }
 
@@ -867,6 +859,7 @@ export function tryDecodeURIComponent(value) {
  *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
  *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
  *                     / "*" / "+" / "," / ";" / "="
+ * @param {string} val
  */
 export function encodeUriSegment(val) {
   return encodeUriQuery(val, true)
@@ -1211,3 +1204,61 @@ export function callBackOnce(fn) {
     }
   };
 }
+
+/**
+ * Wraps a function so it will only be called starting from the second invocation.
+ * The first call does nothing and returns undefined.
+ *
+ * @param {Function} fn - The function to wrap.
+ * @returns {Function} A new function that will skip the first call.
+ */
+export function callBackAfterFirst(fn) {
+  let calledOnce = false;
+
+  return function (...args) {
+    if (calledOnce) {
+      return fn.apply(this, args);
+    }
+    calledOnce = true;
+  };
+}
+
+/**
+ * Delays execution for a specified number of milliseconds.
+ *
+ * @param {number} [t=0] - The number of milliseconds to wait. Defaults to 0.
+ * @returns {Promise<void>} A promise that resolves after the delay.
+ */
+export function wait(t = 0) {
+  return new Promise((resolve) => setTimeout(resolve, t));
+}
+
+/**
+ * Checks if a given string starts with a specified substring.
+ *
+ * This is a simple polyfill-like function that mimics the behavior of
+ * `String.prototype.startsWith` without using the built-in method.
+ *
+ * @param {string} str - The full string to evaluate.
+ * @param {string} search - The substring to test against the beginning of `str`.
+ * @returns {boolean} `true` if `str` starts with `search`, otherwise `false`.
+ *
+ * @example
+ * startsWith("hello world", "hello");
+ * // returns true
+ *
+ * @example
+ * startsWith("hello world", "world");
+ * // returns false
+ *
+ * @example
+ * startsWith("test", "");
+ * // returns true (empty search string always matches)
+ *
+ * @example
+ * startsWith("abc", "abcd");
+ * // returns false
+ */
+export function startsWith(str, search) {
+  return str.slice(0, search.length) === search;
+}

package/src/shared/utils.spec.js

@@ -1,4 +1,4 @@
-import { hashKey } from "./utils.js";
+import { hashKey, startsWith } from "./utils.js";
 
 describe("api", () => {
   describe("hashKey()", () => {
@@ -141,4 +141,38 @@ describe("api", () => {
       ).toEqual(42);
     });
   });
+
+  describe("startsWith", () => {
+    it("should return true when string starts with search string", () => {
+      expect(startsWith("hello world", "hello")).toBe(true);
+    });
+
+    it("should return false when string does not start with search string", () => {
+      expect(startsWith("hello world", "world")).toBe(false);
+    });
+
+    it("should return true when both strings are equal", () => {
+      expect(startsWith("test", "test")).toBe(true);
+    });
+
+    it("should return true when search string is empty", () => {
+      expect(startsWith("abc", "")).toBe(true); // matches JavaScript's native behavior
+    });
+
+    it("should return false when original string is empty and search is not", () => {
+      expect(startsWith("", "a")).toBe(false);
+    });
+
+    it("should return true with special characters at the beginning", () => {
+      expect(startsWith("💡 idea", "💡")).toBe(true);
+    });
+
+    it("should be case-sensitive", () => {
+      expect(startsWith("Hello", "hello")).toBe(false);
+    });
+
+    it("should return false if search is longer than the string", () => {
+      expect(startsWith("short", "shorter")).toBe(false);
+    });
+  });
 });

package/src/src.html

@@ -13,8 +13,7 @@
     <script src="/jasmine/boot1.js"></script>
     <script type="module" src="/src/angular.spec.js"></script>
     <script type="module" src="/src/index.spec.js"></script>
-    <script type="module" src="/src/loader.spec.js"></script>
-    <script type="module" src="/src/public.spec.js"></script>
+    <script type="module" src="/src/ng.spec.js"></script>
   </head>
   <body>
     <div ng-app id="app"></div>

package/typedoc.json

@@ -1,4 +1,3 @@
-// typedoc.json
 {
   "entryPoints": ["src/interface.ts"],
   "entryPointStrategy": "expand",

package/utils/express.js

@@ -37,9 +37,22 @@ app.post("/nocontent", (req, res) => {
 });
 
 app.post("/form", (req, res) => {
+  console.log(req.body);
   res.send(req.body);
 });
 
+app.use("/json", express.json());
+app.use("/json", express.urlencoded({ extended: true }));
+app.post("/json", (req, res) => {
+  console.log(req.body);
+  res.json(req.body);
+});
+
+app.post("/hello", (req, res) => {
+  console.log(req.body);
+  res.send("<div>Hello</div>");
+});
+
 app.post("/blob", (req, res) => {
   res.send(req.body);
 });
@@ -72,6 +85,10 @@ app.get("/jsoninterpolation", (req, res) => {
   res.json("{{expr}}");
 });
 
+app.get("/now", (req, res) => {
+  res.send(Date.now().toString(10));
+});
+
 app.get("/scopeinit", (req, res) => {
   res.send('<div ng-init="name=1"></div>');
 });
@@ -112,6 +129,10 @@ app.get("/hello2", (req, res) => {
   res.send("Hello2");
 });
 
+app.get("/include", (req, res) => {
+  res.send("<div ng-include=\"'/mock/hello'\"></div>");
+});
+
 app.get("/third", (req, res) => {
   res.send("<div third>{{1+2}}</div>");
 });
@@ -132,7 +153,7 @@ app.get("/422", (req, res) => {
   res.status(422).send("Invalid data");
 });
 
-app.get("/never", (req, res) => {
+app.get("/never", () => {
   setTimeout(() => {}, 500);
 });
 
@@ -165,5 +186,18 @@ app.use("/posthtml", express.json());
 app.use("/posthtml", express.urlencoded({ extended: true }));
 app.post("/posthtml", (req, res) => {
   console.log(req.body);
-  res.send(`<div>Post response ${req.body.name} </div>`);
+  res.send(`<div>${req.body.name}</div>`);
+});
+
+app.use("/posterror", express.json());
+app.use("/posterror", express.urlencoded({ extended: true }));
+app.post("/posterror", (req, res) => {
+  console.log(req.body);
+  res.status(422).send(`<div>Error</div>`);
+});
+
+app.use("/urlencoded", express.urlencoded({ extended: true }));
+app.post("/urlencoded", (req, res) => {
+  console.log(req.body); // Access parsed form data
+  res.send("Form data: " + req.body.name);
 });

package/utils/version.cjs

@@ -0,0 +1,23 @@
+const fs = require("fs");
+const path = require("path");
+
+const packageJsonPath = path.resolve(__dirname, "../package.json");
+
+const outputPath = path.resolve(
+  __dirname,
+  "../docs/layouts/shortcodes/version.html",
+);
+
+try {
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  const version = packageJson.version || "unknown";
+
+  const htmlContent = `<p>Version: ${version}</p>\n`;
+
+  fs.writeFileSync(outputPath, htmlContent);
+
+  console.log(`✅ Version HTML file generated at ${outputPath}`);
+} catch (error) {
+  console.error("❌ Error generating version HTML:", error);
+  process.exit(1);
+}

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

@@ -1,317 +0,0 @@
-/**
- *
- * @param {string} base
- * @param {string} url
- * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
- *                   the expected string.
- */
-export function stripBaseUrl(base: string, url: string): string;
-export function stripHash(url: any): any;
-export function stripFile(url: any): any;
-export function serverBase(url: any): any;
-/**
- * @abstract
- */
-export class Location {
-  /**
-   * @param {string} appBase application base URL
-   * @param {string} appBaseNoFile application base URL stripped of any filename
-   */
-  constructor(appBase: string, appBaseNoFile: string);
-  /** @type {string} */
-  appBase: string;
-  /** @type {string} */
-  appBaseNoFile: string;
-  /**
-   * An absolute URL is the full URL, including protocol (http/https ), the optional subdomain (e.g. www ), domain (example.com), and path (which includes the directory and slug).
-   * @type {string}
-   */
-  $$absUrl: string;
-  /**
-   * If html5 mode is enabled
-   * @type {boolean}
-   */
-  $$html5: boolean;
-  /**
-   * Has any change been replacing?
-   * @type {boolean}
-   */
-  $$replace: boolean;
-  /** @type {import('../url-utils/url-utils').HttpProtocol} */
-  $$protocol: any;
-  /** @type {string} */
-  $$host: string;
-  /**
-   * The port, without ":"
-   * @type {number}
-   */
-  $$port: number;
-  /**
-   * The pathname, beginning with "/"
-   * @type {string}
-   */
-  $$path: string;
-  /**
-   * The hash string, minus the hash symbol
-   * @type {string}
-   */
-  $$hash: string;
-  /**
-   * Helper property for scope watch changes
-   * @type {boolean}
-   */
-  $$urlUpdatedByLocation: boolean;
-  /**
-   * Return full URL representation with all segments encoded according to rules specified in
-   * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
-   *
-   * @return {string} full URL
-   */
-  absUrl(): string;
-  /**
-   * This method is getter / setter.
-   *
-   * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
-   * Change path, search and hash, when called with parameter and return `$location`.
-   *
-   * @param {string=} url New URL without base prefix (e.g. `/path?a=b#hash`)
-   * @return {Location|string} url
-   */
-  url(url?: string | undefined): Location | string;
-  /**
-   *
-   * Return protocol of current URL.
-   * @return {import("../url-utils/url-utils").HttpProtocol} protocol of current URL
-   */
-  protocol(): any;
-  /**
-   * This method is getter only.
-   *
-   * Return host of current URL.
-   *
-   * Note: compared to the non-AngularTS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
-   *
-   *
-   * @return {string} host of current URL.
-   */
-  host(): string;
-  /**
-   * This method is getter only.
-   *
-   * Return port of current URL.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let port = $location.port();
-   * // => 80
-   * ```
-   *
-   * @return {number} port
-   */
-  port(): number;
-  /**
-   * This method is getter / setter.
-   *
-   * Return path of current URL when called without any parameter.
-   *
-   * Change path when called with parameter and return `$location`.
-   *
-   * Note: Path should always begin with forward slash (/), this method will add the forward slash
-   * if it is missing.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let path = $location.path();
-   * // => "/some/path"
-   * ```
-   *
-   * @param {(string|number)=} path New path
-   * @return {(string|object)} path if called with no parameters, or `$location` if called with a parameter
-   */
-  path(path?: (string | number) | undefined): string | object;
-  /**
-   * This method is getter / setter.
-   *
-   * Returns the hash fragment when called without any parameters.
-   *
-   * Changes the hash fragment when called with a parameter and returns `$location`.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
-   * let hash = $location.hash();
-   * // => "hashValue"
-   * ```
-   *
-   * @param {(string|number)=} hash New hash fragment
-   * @return {string|Location} hash
-   */
-  hash(hash?: (string | number) | undefined): string | Location;
-  /**
-   * If called, all changes to $location during the current `$digest` will replace the current history
-   * record, instead of adding a new one.
-   */
-  replace(): this;
-  /**
-   * Returns or sets the search part (as object) of current URL when called without any parameter
-   *
-   * @param {string|Object=} search New search params - string or hash object.
-   * @param {(string|number|Array<string>|boolean)=} paramValue If search is a string or number, then paramValue will override only a single search property.
-   * @returns {Object|Location} Search object or Location object
-   */
-  search(
-    search?: (string | any) | undefined,
-    paramValue?: (string | number | Array<string> | boolean) | undefined,
-    ...args: any[]
-  ): any | Location;
-  $$search: any;
-  /**
-   * Compose url and update `url` and `absUrl` property
-   * @returns {void}
-   */
-  $$compose(): void;
-  $$url: string;
-  /**
-   * @param {string} _url
-   * @returns {string}
-   */
-  $$normalizeUrl(_url: string): string;
-  /**
-   * This method is getter / setter.
-   *
-   * Return the history state object when called without any parameter.
-   *
-   * Change the history state object when called with one parameter and return `$location`.
-   * The state object is later passed to `pushState` or `replaceState`.
-   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/History/pushState#state|History.state}
-   *
-   * NOTE: This method is supported only in HTML5 mode and only in browsers supporting
-   * the HTML5 History API (i.e. methods `pushState` and `replaceState`). If you need to support
-   * older browsers (like IE9 or Android < 4.0), don't use this method.
-   *
-   * @param {any} state State object for pushState or replaceState
-   * @return {any} state
-   */
-  state(state: any, ...args: any[]): any;
-  $$state: any;
-  /**
-   * @param {string} _url
-   * @param {string} _url2
-   * @returns {boolean}
-   */
-  $$parseLinkUrl(_url: string, _url2: string): boolean;
-  $$parse(_url: any): void;
-}
-/**
- * This object is exposed as $location service when HTML5 mode is enabled and supported
- */
-export class LocationHtml5Url extends Location {
-  /**
-   * @param {string} appBase application base URL
-   * @param {string} appBaseNoFile application base URL stripped of any filename
-   * @param {string} basePrefix URL path prefix
-   */
-  constructor(appBase: string, appBaseNoFile: string, basePrefix: string);
-  basePrefix: string;
-  /**
-   * Parse given HTML5 (regular) URL string into properties
-   * @param {string} url HTML5 URL
-   */
-  $$parse(url: string): void;
-  $$normalizeUrl(url: any): string;
-}
-/**
- * LocationHashbangUrl represents URL
- * This object is exposed as $location service when developer doesn't opt into html5 mode.
- * It also serves as the base class for html5 mode fallback on legacy browsers.
- *
- * @constructor
- * @param {string} appBase application base URL
- * @param {string} appBaseNoFile application base URL stripped of any filename
- * @param {string} hashPrefix hashbang prefix
- */
-export class LocationHashbangUrl extends Location {
-  constructor(appBase: any, appBaseNoFile: any, hashPrefix: any);
-  hashPrefix: any;
-  /**
-   * Parse given hashbang URL into properties
-   * @param {string} url Hashbang URL
-   */
-  $$parse(url: string): void;
-  $$normalizeUrl(url: any): string;
-  /**
-   * @param {string} url
-   * @returns {boolean}
-   */
-  $$parseLinkUrl(url: string): boolean;
-}
-export class LocationProvider {
-  /** @type {string} */
-  hashPrefixConf: string;
-  /** @type {Html5Mode} */
-  html5ModeConf: Html5Mode;
-  /**
-   * The default value for the prefix is `'!'`.
-   * @param {string=} prefix Prefix for hash part (containing path and search)
-   * @returns {void}
-   */
-  setHashPrefix(prefix?: string | undefined): void;
-  /**
-   * Current hash prefix
-   * @returns {string}
-   */
-  getHashPrefix(): string;
-  /**
-   * Configures html5 mode
-   * @param {(boolean|Html5Mode)=} mode If boolean, sets `html5Mode.enabled` to value. Otherwise, accepts html5Mode object
-   *
-   * @returns {void}
-   */
-  setHtml5Mode(mode?: (boolean | Html5Mode) | undefined): void;
-  /**
-   * Returns html5 mode cofiguration
-   * @returns {Html5Mode}
-   */
-  getHtml5Mode(): Html5Mode;
-  $get: (
-    | string
-    | ((
-        $rootScope: import("../scope/scope.js").Scope,
-        $browser: any,
-        $rootElement: Element,
-      ) => Location)
-  )[];
-}
-export type DefaultPorts = {
-  http: number;
-  https: number;
-  ftp: number;
-};
-/**
- * Represents the configuration options for HTML5 mode.
- */
-export type Html5Mode = {
-  /**
-   * - (default: false) 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`.
-   */
-  enabled: boolean;
-  /**
-   * - (default: `true`) 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.
-   * See the {@link guide /$location $location guide} for more information.
-   */
-  requireBase: boolean;
-  /**
-   * - (default: `true`) 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. Note that [attribute name normalization](guide/directive#normalization)
-   * does not apply here, so `'internalLink'` will **not** match `'internal-link'`.
-   */
-  rewriteLinks: boolean | string;
-};