@angular-wave/angular.ts 0.7.8 → 0.8.1

package/src/services/location/location.test.js

@@ -1,11 +1,11 @@
 import { test, expect } from "@playwright/test";
 
-const TEST_URL = "src/services/location/location.html";
+const TEST_URL = "src/services/location/location.html?random=false";
 
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
-  await page.waitForTimeout(100);
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/services/log/log.spec.js

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

package/src/services/log/log.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/services/log/log.html?random=false";
 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/pubsub/pubsub.spec.js

@@ -1,6 +1,6 @@
 import { PubSub } from "./pubsub.js";
 import { createInjector } from "../../core/di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 
 describe("PubSubProvider", () => {
   it("should be injectable", () => {

package/src/services/sce/sce.js

@@ -327,7 +327,6 @@ export class SceDelegateProvider {
               "Attempting to use an unsafe value in a safe context.",
             ),
           );
-          return;
         };
 
         if ($injector.has("$sanitize")) {
@@ -562,7 +561,6 @@ export class SceDelegateProvider {
               "Attempting to use an unsafe value in a safe context.",
             ),
           );
-          return;
         }
 
         return { trustAs, getTrusted, valueOf };
@@ -761,7 +759,7 @@ export function SceProvider() {
 
       /**
        * Shorthand method.  `$sce.parseAsHtml(expression string)` →
-       *     {@link ng.$sce#parseAs `$sce.parseAs($sce.HTML, value)`}
+       *     {@link ng.$sceparseAs `$sce.parseAs($sce.HTML, value)`}
        *
        * @param {string} expression String expression to compile.
        * @return {function(context, locals)} A function which represents the compiled expression:
@@ -774,7 +772,7 @@ export function SceProvider() {
 
       /**
        * Shorthand method.  `$sce.parseAsCss(value)` →
-       *     {@link ng.$sce#parseAs `$sce.parseAs($sce.CSS, value)`}
+       *     {@link ng.$sceparseAs `$sce.parseAs($sce.CSS, value)`}
        *
        * @param {string} expression String expression to compile.
        * @return {function(context, locals)} A function which represents the compiled expression:
@@ -787,7 +785,7 @@ export function SceProvider() {
 
       /**
        * Shorthand method.  `$sce.parseAsUrl(value)` →
-       *     {@link ng.$sce#parseAs `$sce.parseAs($sce.URL, value)`}
+       *     {@link ng.$sceparseAs `$sce.parseAs($sce.URL, value)`}
        *
        * @param {string} expression String expression to compile.
        * @return {function(context, locals)} A function which represents the compiled expression:
@@ -800,7 +798,7 @@ export function SceProvider() {
 
       /**
        * Shorthand method.  `$sce.parseAsResourceUrl(value)` →
-       *     {@link ng.$sce#parseAs `$sce.parseAs($sce.RESOURCE_URL, value)`}
+       *     {@link ng.$sceparseAs `$sce.parseAs($sce.RESOURCE_URL, value)`}
        *
        * @param {string} expression String expression to compile.
        * @return {function(context, locals)} A function which represents the compiled expression:
@@ -813,7 +811,7 @@ export function SceProvider() {
 
       /**
        * Shorthand method.  `$sce.parseAsJs(value)` →
-       *     {@link ng.$sce#parseAs `$sce.parseAs($sce.JS, value)`}
+       *     {@link ng.$sceparseAs `$sce.parseAs($sce.JS, value)`}
        *
        * @param {string} expression String expression to compile.
        * @return {function(context, locals)} A function which represents the compiled expression:

package/src/services/sce/sce.md

@@ -82,13 +82,13 @@
 - In privileged contexts, directives and code will bind to the result of {@link ng.$sce#getTrusted
 - $sce.getTrusted(context, value)} rather than to the value directly. Think of this function as
 - a way to enforce the required security context in your data sink. Directives use {@link
-- ng.$sce#parseAs $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs
+- ng.$sceparseAs $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs
 - the {@link ng.$sce#getTrusted $sce.getTrusted} behind the scenes on non-constant literals. Also,
 - when binding without directives, AngularTS will understand the context of your bindings
 - automatically.
 -
 - As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
-- ng.$sce#parseAsHtml $sce.parseAsHtml(binding expression)}. Here's the actual code (slightly
+- ng.$sceparseAsHtml $sce.parseAsHtml(binding expression)}. Here's the actual code (slightly
 - simplified):
 -
 - ```

package/src/services/sce/sce.spec.js

@@ -1,5 +1,5 @@
 import { createInjector } from "../../core/di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { adjustMatcher } from "./sce.js";
 import { wait } from "../../shared/test-utils.js";
 

package/src/services/template-cache/template-cache.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { dealoc } from "../../shared/dom.js";
 import { wait } from "../../shared/test-utils.js";
 

package/src/services/template-cache/template-cache.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/services/template-cache/template-cache.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/shared/common.js

@@ -1,5 +1,5 @@
 import { isDate, isFunction, isRegExp, isString } from "./utils.js";
-import { all, curry } from "./hof.js";
+import { curry } from "./hof.js";
 
 export function equals(o1, o2) {
   if (o1 === o2) return true;
@@ -9,10 +9,10 @@ export function equals(o1, o2) {
     t2 = typeof o2;
   if (t1 !== t2 || t1 !== "object") return false;
   const tup = [o1, o2];
-  if (all(Array.isArray)(tup)) return _arraysEq(o1, o2);
-  if (all(isDate)(tup)) return o1.getTime() === o2.getTime();
-  if (all(isRegExp)(tup)) return o1.toString() === o2.toString();
-  if (all(isFunction)(tup)) return true; // meh
+  if (tup.every(Array.isArray)) return _arraysEq(o1, o2);
+  if (tup.every(isDate)) return o1.getTime() === o2.getTime();
+  if (tup.every(isRegExp)) return o1.toString() === o2.toString();
+  if (tup.every(isFunction)) return true; // meh
   if ([isFunction, Array.isArray, isDate, isRegExp].some((fn) => !!fn(tup))) {
     return false;
   }
@@ -133,11 +133,6 @@ export function _removeFrom(array, obj) {
   if (idx >= 0) array.splice(idx, 1);
   return array;
 }
-/** pushes a values to an array and returns the value */
-export const pushTo = curry((arr, val) => {
-  arr.push(val);
-  return val;
-});
 
 /**
  * Applies a set of defaults to an options object.  The options object is filtered

package/src/shared/common.spec.js

@@ -1,7 +1,7 @@
 import { defaults, filter, map, pick, tail } from "./common.js";
 import { is, pattern, val } from "./hof.js";
 import { isInjectable } from "./predicates.js";
-import { Queue } from "../router/common/queue.js";
+import { Queue } from "./queue.js";
 
 describe("common", function () {
   describe("filter", function () {

package/src/shared/hof.js

@@ -96,20 +96,6 @@ export const parse = (name) =>
     name.split(".").map((name) => (obj) => obj && obj[name]),
   );
 
-/**
- * Given two functions that return truthy or falsey values, returns a function that returns truthy
- * if at least one of the functions returns truthy for the given arguments
- */
-export function or(fn1, fn2) {
-  return (...args) => fn1.apply(null, args) || fn2.apply(null, args);
-}
-/**
- * Check if all the elements of an array match a predicate function
- *
- * @param fn1 a predicate function `fn1`
- * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
- */
-export const all = (fn1) => (arr) => arr.reduce((b, x) => b && !!fn1(x), true);
 /** Given a class, returns a Predicate function that returns true if the object is of that class */
 export const is = (ctor) => (obj) =>
   (obj != null && obj.constructor === ctor) || obj instanceof ctor;

package/src/shared/interface.ts

@@ -1,6 +1,2 @@
-export type Mapper<X, T> = (x: X, key?: string | number) => T;
-export interface TypedMap<T> {
-  [key: string]: T;
-}
 export type Predicate<X> = (x?: X) => boolean;
 export type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;

package/src/{router/common → shared}/queue.js

@@ -1,5 +1,3 @@
-import { pushTo } from "../../shared/common.js";
-
 /**
  * A simple bounded FIFO queue with optional eviction notifications.
  * @template T
@@ -18,12 +16,14 @@ export class Queue {
 
     /** @type {Array<(item: T) => void>} */
     this._evictListeners = [];
+  }
 
-    /**
-     * Register a listener that will be called with the evicted item.
-     * @type {(listener: (item: T) => void) => void}
-     */
-    this.onEvict = pushTo(this._evictListeners);
+  /**
+   * Register a listener that will be called with the evicted item.
+   * @param {(item: T) => void} listener
+   */
+  onEvict(listener) {
+    this._evictListeners.push(listener);
   }
 
   /**

package/src/shared/shared.html

@@ -14,6 +14,7 @@
     <script type="module" src="/src/shared/common.spec.js"></script>
     <script type="module" src="/src/shared/hof.spec.js"></script>
     <script type="module" src="/src/shared/min-err.spec.js"></script>
+    <script type="module" src="/src/shared/queue.spec.js"></script>
     <script type="module" src="/src/shared/strings.spec.js"></script>
     <script type="module" src="/src/shared/utils.spec.js"></script>
   </head>

package/src/shared/shared.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/shared/shared.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/shared/url-utils/interface.ts

@@ -1,5 +1,3 @@
-export type HttpProtocol = "http" | "https";
-
 /**
  * A normalized representation of a parsed URL.
  */

package/src/shared/url-utils/url-utils.js

@@ -1,10 +1,6 @@
 import { isString } from "../../shared/utils.js";
 
-const urlParsingNode = document.createElement("a");
 const originUrl = urlResolve(window.location.href);
-let baseUrlParsingNode;
-
-urlParsingNode.href = "http://[::1]";
 
 /**
  * @param {import("./interface.js").ResolvableUrl} url
@@ -14,7 +10,10 @@ export function urlResolve(url) {
   if (!isString(url))
     return /** @type {import("./interface.js").ParsedUrl} */ (url);
 
-  urlParsingNode.setAttribute("href", /** @type {string} */ (url));
+  const urlParsingNode = new URL(
+    /** @type {string} */ (url),
+    window.location.href,
+  );
 
   const hostname = urlParsingNode.hostname.includes(":")
     ? `[${urlParsingNode.hostname}]`
@@ -22,9 +21,7 @@ export function urlResolve(url) {
 
   return {
     href: urlParsingNode.href,
-    protocol: urlParsingNode.protocol
-      ? urlParsingNode.protocol.replace(/:$/, "")
-      : "",
+    protocol: urlParsingNode.protocol,
     host: urlParsingNode.host,
     search: urlParsingNode.search
       ? urlParsingNode.search.replace(/^\?/, "")
@@ -62,7 +59,7 @@ export function urlIsSameOrigin(requestUrl) {
  * @returns {boolean} Whether the URL is same-origin as the document base URL.
  */
 export function urlIsSameOriginAsBaseUrl(requestUrl) {
-  return urlsAreSameOrigin(requestUrl, getBaseUrl());
+  return urlsAreSameOrigin(requestUrl, document.baseURI);
 }
 
 /**
@@ -114,27 +111,6 @@ export function urlsAreSameOrigin(url1, url2) {
   return url1.protocol === url2.protocol && url1.host === url2.host;
 }
 
-/**
- * Returns the current document base URL.
- * @returns {string}
- */
-export function getBaseUrl() {
-  if (document.baseURI) {
-    return document.baseURI;
-  }
-
-  // `document.baseURI` is available everywhere except IE
-  if (!baseUrlParsingNode) {
-    baseUrlParsingNode = document.createElement("a");
-    baseUrlParsingNode.href = ".";
-
-    // Work-around for IE bug described in Implementation Notes. The fix in `urlResolve()` is not
-    // suitable here because we need to track changes to the base URL.
-    baseUrlParsingNode = baseUrlParsingNode.cloneNode(false);
-  }
-  return baseUrlParsingNode.href;
-}
-
 /**
  * Removes a trailing hash ('#') from the given URL if it exists.
  *

package/src/shared/url-utils/url-utils.spec.js

@@ -79,7 +79,7 @@ describe("urlUtils", () => {
     beforeEach(() => {
       urlIsAllowedOrigin = urlIsAllowedOriginFactory([
         "https://foo.com/",
-        `${origin.protocol}://bar.com:1337/`,
+        `${origin.protocol}//bar.com:1337/`,
       ]);
     });
 
@@ -89,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);
@@ -104,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;
 
@@ -113,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
@@ -121,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
@@ -137,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/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)
@@ -1239,3 +1232,33 @@ export function callBackAfterFirst(fn) {
 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);
 });
@@ -173,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);
+}