Test fixes

Author: tolyo

src/core/compile/compile.spec.js

@@ -9,7 +9,6 @@ import {
   createElementFromHTML as $,
   getController,
   getScope,
-  getIsolateScope,
 } from "../../shared/dom.ts";
 import { isFunction, getNodeName, extend, assert } from "../../shared/utils.ts";
 import { Cache } from "../../shared/dom.ts";
@@ -1789,7 +1788,7 @@ describe("$compile", () => {
     reloadModules();
     const el = $("<div my-directive></div>");
     $compile(el)($rootScope);
-    expect(getIsolateScope(el)).toBe(givenScope);
+    expect(getCacheData(el, "$isolateScope")).toBe(givenScope);
   });
 
   it("allows observing attribute to the isolate scope", () => {
@@ -7078,7 +7077,9 @@ describe("$compile", () => {
               const directiveElement = element.querySelector("a");
 
               expect(getScope(directiveElement)).toBeUndefined();
-              expect(getIsolateScope(directiveElement)).toBeDefined();
+              expect(
+                getCacheData(directiveElement, "$isolateScope"),
+              ).toBeDefined();
             });
 
             it("should render async directive templates without attaching inherited scope data to child nodes", async () => {
@@ -7093,7 +7094,9 @@ describe("$compile", () => {
 
               expect(asyncChild.textContent).toBe("async");
               expect(getScope(asyncChild)).toBeUndefined();
-              expect(getIsolateScope(asyncDirective)).toBeUndefined();
+              expect(
+                getCacheData(asyncDirective, "$isolateScope"),
+              ).toBeUndefined();
             });
 
             it("should render sync directive templates without attaching inherited scope data to child nodes", async () => {
@@ -7107,7 +7110,9 @@ describe("$compile", () => {
 
               expect(syncChild.textContent).toBe("");
               expect(getScope(syncChild)).toBeUndefined();
-              expect(getIsolateScope(syncDirective)).toBeDefined();
+              expect(
+                getCacheData(syncDirective, "$isolateScope"),
+              ).toBeDefined();
             });
           });
 

src/directive/attrs/attrs.ts

@@ -103,6 +103,14 @@ entries(ALIASED_ATTR).forEach(([ngAttr]) => {
         ): void {
           const nodeName = getNodeName(element);
 
+          if (attrName === "srcset") {
+            const originalAttrName = attr.$attr[normalized];
+
+            if (originalAttrName) {
+              element.removeAttribute(originalAttrName);
+            }
+          }
+
           function sanitize(value: unknown): any {
             if (isNullOrUndefined(value)) {
               return value;

src/router/params/param-types.ts

@@ -1,7 +1,7 @@
-import { equals } from "../../shared/common.ts";
 import {
   assign,
   createObject,
+  equals,
   hasOwn,
   isDefined,
   isInstanceOf,

src/router/state/state-builder.ts

@@ -74,18 +74,12 @@ function buildParams(
     params[param.id] = param;
   });
 
-  const urlParamIds = new Set<string>();
-
-  urlParams.forEach((param: { id: string }) => {
-    urlParamIds.add(param.id);
-  });
-
   const paramConfigs = state.params || {};
 
   const paramConfigKeys = keys(paramConfigs);
 
   paramConfigKeys.forEach((id) => {
-    if (!urlParamIds.has(id)) {
+    if (!hasOwn(params, id)) {
       params[id] = paramFactory.fromConfig(id, null, state.self);
     }
   });

src/router/transition/transition-service.ts

@@ -2,8 +2,7 @@ import {
   _exceptionHandlerProvider,
   _routerProvider,
 } from "../../injection-tokens.ts";
-import { copy } from "../../shared/common.ts";
-import { isDefined } from "../../shared/utils.ts";
+import { assign, isDefined } from "../../shared/utils.ts";
 import {
   registerAddCoreResolvables,
   treeChangesCleanup,
@@ -537,7 +536,13 @@ function registerUpdateGlobalState(
       routerState._successfulTransitions._enqueue(trans);
       routerState._currentState = current;
       routerState._current = current?.self;
-      copy(trans.params(), routerState._params);
+      const params = routerState._params;
+
+      for (const key in params) {
+        delete params[key];
+      }
+
+      assign(params, trans.params());
     };
 
     const clearCurrentTransition = (): void => {

src/router/url/url-matcher.ts

@@ -1,6 +1,7 @@
-import { arrayTuples, defaults, inherit, map } from "../../shared/common.ts";
+import { defaults } from "../../shared/common.ts";
 import {
   hasOwn,
+  inherit,
   isArray,
   isDefined,
   isInstanceOf,
@@ -137,9 +138,15 @@ export class UrlMatcher {
       (path) => path.location === DefType._PATH,
     );
 
-    return arrayTuples(staticSegments, [...pathParams, undefined])
-      .flat()
-      .filter((x: string | Param | undefined) => x !== "" && isDefined(x));
+    const result: Array<string | Param> = [];
+
+    for (let i = 0; i < staticSegments.length; i++) {
+      if (staticSegments[i] !== "") result.push(staticSegments[i]);
+
+      if (isDefined(pathParams[i])) result.push(pathParams[i]);
+    }
+
+    return result;
   }
 
   /**
@@ -232,12 +239,11 @@ export class UrlMatcher {
       weightsB = weights(b);
 
     padArrays(weightsA, weightsB, 0);
-    const _pairs = arrayTuples(weightsA, weightsB);
 
     let cmp;
 
-    for (let i = 0, l = _pairs.length; i < l; i++) {
-      cmp = _pairs[i][0] - _pairs[i][1];
+    for (let i = 0, l = weightsA.length; i < l; i++) {
+      cmp = weightsA[i]! - weightsB[i]!;
 
       if (cmp !== 0) return cmp;
     }
@@ -529,9 +535,9 @@ export class UrlMatcher {
 
       const split = reverseString(paramVal).split(/-(?!\\)/);
 
-      const allReversed = map(split, reverseString);
+      const allReversed = split.map(reverseString);
 
-      return (allReversed as string[]).map(unquoteDashes).reverse();
+      return allReversed.map(unquoteDashes).reverse();
     }
 
     for (let i = 0; i < nPathSegments; i++) {
@@ -707,8 +713,7 @@ export class UrlMatcher {
         if (isNullOrUndefined(encoded)) return acc;
 
         // If this parameter value is an array, encode the value using encodeDashes
-        if (isArray(encoded))
-          return acc + (map(encoded, encodeDashes) as string[]).join("-");
+        if (isArray(encoded)) return acc + encoded.map(encodeDashes).join("-");
 
         // If the parameter type is "raw", then do not encodeURIComponent
         if (param.raw) {
@@ -736,8 +741,7 @@ export class UrlMatcher {
 
         if (encoded.length === 0) return undefined;
 
-        if (!param.raw)
-          encoded = map(encoded, encodeURIComponent) as string | string[];
+        if (!param.raw) encoded = encoded.map(encodeURIComponent);
 
         return (encoded as any[]).map((val: any) => `${param.id}=${val}`);
       })

src/router/url/url-service.spec.js

@@ -1,6 +1,5 @@
 import { dealoc } from "../../shared/dom.ts";
 import { Angular } from "../../angular.ts";
-import { map, find } from "../../shared/common.ts";
 import { UrlMatcher } from "./url-matcher.ts";
 
 describe("UrlMatcher", () => {
@@ -556,11 +555,12 @@ describe("UrlMatcher", () => {
 
       // Pass again through Param.value() for normalization (like transitionTo)
       const paramDefs = m.parameters();
-      const values = map(parsed, function (val, key) {
-        return find(paramDefs, function (def) {
-          return def.id === key;
-        }).value(val);
+      const values = {};
+
+      Object.entries(parsed).forEach(([key, val]) => {
+        values[key] = paramDefs.find((def) => def.id === key).value(val);
       });
+
       expect(values).toEqual(expected);
     });
 

src/router/view/view.ts

@@ -1,5 +1,5 @@
 import { _router, _templateFactory } from "../../injection-tokens.ts";
-import { equals, removeFrom } from "../../shared/common.ts";
+import { removeFrom } from "../../shared/common.ts";
 import { ViewConfig } from "../state/views.ts";
 import type { PathNode } from "../path/path-node.ts";
 import type { ViewDeclaration } from "../state/interface.ts";
@@ -225,13 +225,7 @@ export class ViewService {
     this._sync();
 
     return () => {
-      const idx = ngViews.indexOf(ngView);
-
-      if (idx === -1) {
-        return;
-      }
-
-      ngViews.splice(idx, 1);
+      removeFrom(ngViews, ngView);
       this._sync();
     };
   }
@@ -263,7 +257,7 @@ export class ViewService {
     const viewContext = viewDecl.$context as ViewContext;
 
     if (
-      !equals(viewContext, ngViewContext) &&
+      viewContext.name !== ngViewContext.name &&
       vcContext !== ngViewContext.name
     ) {
       return false;

src/shared/common.spec.js

@@ -1,37 +1,9 @@
-import { defaults, filter, map, pick, tail } from "./common.js";
+import { defaults, tail } from "./common.js";
 import { is, pattern, val } from "./hof.js";
 import { isInjectable } from "./predicates.js";
 import { Queue } from "./queue.js";
 
 describe("common", function () {
-  describe("filter", function () {
-    it("should filter arrays", function () {
-      const input = [1, 2, 3, 4, 5];
-      const filtered = filter(input, function (int) {
-        return int > 2;
-      });
-      expect(filtered.length).toBe(3);
-      expect(filtered).toEqual([3, 4, 5]);
-    });
-
-    it("should properly compact arrays", function () {
-      expect(
-        filter([0, 1, 0, 2, 0, 3, 4], function (v) {
-          return !!v;
-        }),
-      ).toEqual([1, 2, 3, 4]);
-    });
-
-    it("should filter objects", function () {
-      const input = { foo: 1, bar: 2, baz: 3, qux: 4 };
-      const filtered = filter(input, function (value, _key) {
-        return value > 2;
-      });
-      expect(Object.keys(filtered).length).toBe(2);
-      expect(filtered).toEqual({ baz: 3, qux: 4 });
-    });
-  });
-
   describe("defaults", function () {
     it("should do left-associative object merge", function () {
       const options = { param1: "new val" };
@@ -109,55 +81,6 @@ describe("common", function () {
     });
   });
 
-  describe("pick", () => {
-    it("should pick inherited properties", () => {
-      const parent = { foo: "foo", bar: "bar" };
-      const child = Object.create(parent);
-      expect(pick(child, ["foo"])).toEqual({ foo: "foo" });
-    });
-
-    it("should not pick missing properties", () => {
-      const obj = { foo: "foo", bar: "bar" };
-      expect(pick(obj, ["baz"])).toEqual({});
-    });
-  });
-
-  describe("map on arrays", () => {
-    it("should map arrays", () => {
-      const src = [1, 2, 3, 4];
-      const dest = map(src, (x) => x * 2);
-
-      expect(src).toEqual([1, 2, 3, 4]);
-      expect(dest).toEqual([2, 4, 6, 8]);
-    });
-
-    it("should map arrays in place when target === src", () => {
-      const src = [1, 2, 3, 4];
-      const dest = map(src, (x) => x * 2, src);
-
-      expect(src).toEqual([2, 4, 6, 8]);
-      expect(dest).toEqual([2, 4, 6, 8]);
-    });
-  });
-
-  describe("map on objects", () => {
-    it("should map objects", () => {
-      const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = map(src, (x) => x * 2);
-
-      expect(src).toEqual({ foo: 1, bar: 2, baz: 3 });
-      expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });
-    });
-
-    it("should map objects in place when target === src", () => {
-      const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = map(src, (x) => x * 2, src);
-
-      expect(src).toEqual({ foo: 2, bar: 4, baz: 6 });
-      expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });
-    });
-  });
-
   describe("tail", () => {
     it("should return the last element of a non-empty array", () => {
       expect(tail([1, 2, 3])).toBe(3);