@startinblox/components-ds4go 2.2.4 → 3.0.0

package/cypress/e2e/helpers/datas/filterObjectByValue.cy.ts

@@ -0,0 +1,375 @@
+import filterObjectByValue from "@helpers/datas/filterObjectByValue";
+
+describe("filterObjectByValue helper function", () => {
+  describe("Basic functionality", () => {
+    it("should filter objects by any property value matching search string", () => {
+      const objects = [
+        { name: "Alice Johnson", age: 30 },
+        { name: "Bob Smith", age: 25 },
+        { name: "Charlie Brown", age: 35 },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice Johnson");
+    });
+
+    it("should return all objects when searchString is empty", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterObjectByValue(objects, "");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when searchString is only whitespace", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterObjectByValue(objects, "   ");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return empty array when no match found", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterObjectByValue(objects, "xyz");
+      expect(result).to.have.length(0);
+    });
+
+    it("should search across all properties", () => {
+      const objects = [
+        { name: "Alice", email: "alice@example.com" },
+        { name: "Bob", email: "bob@test.com" },
+        { name: "Charlie", email: "charlie@example.com" },
+      ];
+      const result = filterObjectByValue(objects, "example");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Charlie"]);
+    });
+  });
+
+  describe("Search scoring", () => {
+    it("should score matches in name/title higher (score 4)", () => {
+      const objects = [
+        { name: "Alice", description: "Developer" },
+        { description: "Alice specialist" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1]).to.not.have.property("name");
+    });
+
+    it("should score whole word matches in name/title higher than partial", () => {
+      const objects = [
+        { name: "Alice" },
+        { name: "Alice Wonderland" },
+        { description: "Alice specialist" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Alice Wonderland");
+    });
+
+    it("should score whole word matches in other properties (score 3)", () => {
+      const objects = [
+        { description: "Alice specialist" },
+        { description: "Alice Wonderland" },
+      ];
+      const result = filterObjectByValue(objects, "specialist");
+      expect(result[0].description).to.equal("Alice specialist");
+    });
+
+    it("should score partial matches in name/title (score 2)", () => {
+      const objects = [{ name: "Alice Wonderland" }, { description: "Alice" }];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result[0].name).to.equal("Alice Wonderland");
+      expect(result[1].description).to.equal("Alice");
+    });
+
+    it("should score partial matches in other properties (score 1)", () => {
+      const objects = [
+        { description: "Alice Wonderland" },
+        { description: "Alice specialist" },
+      ];
+      const result = filterObjectByValue(objects, "ali");
+      expect(result).to.have.length(2);
+    });
+
+    it("should sort results by relevance score descending", () => {
+      const objects = [
+        { name: "Alice", bio: "Developer" },
+        { name: "Bob", bio: "Alice specialist" },
+        { title: "Alice" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(3);
+      expect(result[0]).to.have.property("name", "Alice");
+      expect(result[1]).to.have.property("title", "Alice");
+      expect(result[2]).to.have.property("name", "Bob");
+    });
+  });
+
+  describe("Case sensitivity", () => {
+    it("should be case insensitive", () => {
+      const objects = [{ name: "Alice" }, { name: "BOB" }, { name: "Charlie" }];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should match uppercase search with lowercase data", () => {
+      const objects = [{ name: "alice" }, { name: "bob" }];
+      const result = filterObjectByValue(objects, "ALICE");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("alice");
+    });
+  });
+
+  describe("Recursive search", () => {
+    it("should search recursively within nested objects", () => {
+      const objects = [
+        { name: "Alice", profile: { bio: "Software engineer" } },
+        { name: "Bob", profile: { bio: "Designer" } },
+      ];
+      const result = filterObjectByValue(objects, "software");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should search recursively within arrays", () => {
+      const objects = [
+        { name: "Alice", skills: ["Python", "JavaScript"] },
+        { name: "Bob", skills: ["Java", "C++"] },
+      ];
+      const result = filterObjectByValue(objects, "python");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should search recursively within array of objects", () => {
+      const objects = [
+        { name: "Alice", skills: [{ name: "Python" }, { name: "JavaScript" }] },
+        { name: "Bob", skills: [{ name: "Java" }, { name: "C++" }] },
+      ];
+      const result = filterObjectByValue(objects, "python");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should find match at any depth in nested structure", () => {
+      const objects = [
+        { name: "Alice", data: { level1: { level2: { level3: "Python" } } } },
+        { name: "Bob", data: { level1: { level2: { level3: "Java" } } } },
+      ];
+      const result = filterObjectByValue(objects, "python");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should search across entire object structure", () => {
+      const objects = [
+        { name: "Project 1", owner: { name: "Alice" }, tags: ["web", "app"] },
+        { name: "Project 2", owner: { name: "Bob" }, tags: ["api"] },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Project 1");
+    });
+  });
+
+  describe("Special characters in search", () => {
+    it("should handle regex special characters in search string", () => {
+      const objects = [{ name: "C++ Developer" }, { name: "Java Developer" }];
+      const result = filterObjectByValue(objects, "c++");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("C++ Developer");
+    });
+
+    it("should handle dots in search string", () => {
+      const objects = [{ name: "version.1.0" }, { name: "version.2.0" }];
+      const result = filterObjectByValue(objects, "version.1");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("version.1.0");
+    });
+
+    it("should handle asterisks in search string", () => {
+      const objects = [{ name: "item*1" }, { name: "item*2" }];
+      const result = filterObjectByValue(objects, "item*1");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("item*1");
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = filterObjectByValue([], "test");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects with null properties", () => {
+      const objects = [
+        { name: null, email: "alice@test.com" },
+        { name: "Bob", email: "bob@test.com" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].email).to.equal("alice@test.com");
+    });
+
+    it("should handle objects with undefined properties", () => {
+      const objects = [
+        { name: undefined, email: "alice@test.com" },
+        { name: "Bob", email: "bob@test.com" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].email).to.equal("alice@test.com");
+    });
+
+    it("should handle property values that are numbers", () => {
+      const objects = [
+        { name: "Alice", score: 100 },
+        { name: "Bob", score: 200 },
+      ];
+      const result = filterObjectByValue(objects, "100");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle property values that are booleans", () => {
+      const objects = [
+        { name: "Alice", active: true },
+        { name: "Bob", active: false },
+      ];
+      const result = filterObjectByValue(objects, "true");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle empty objects", () => {
+      const objects = [{}, { name: "Alice" }];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle objects with empty arrays", () => {
+      const objects = [
+        { name: "Alice", tags: [] },
+        { name: "Bob", tags: ["developer"] },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+
+  describe("Mixed data types", () => {
+    it("should search through mixed types in nested structure", () => {
+      const objects = [
+        {
+          name: "Alice",
+          data: { mixed: ["text", 123, true, { nested: "match" }] },
+        },
+        { name: "Bob", data: { mixed: ["other", 456] } },
+      ];
+      const result = filterObjectByValue(objects, "match");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should search through nested arrays of different types", () => {
+      const objects = [
+        { name: "Alice", items: ["string", 100, { key: "value" }, [1, 2, 3]] },
+        { name: "Bob", items: ["other"] },
+      ];
+      const result = filterObjectByValue(objects, "value");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+
+  describe("Multiple matches", () => {
+    it("should return all objects that match", () => {
+      const objects = [
+        { name: "Alice", email: "alice@example.com" },
+        { name: "Bob", email: "bob@alice.com" },
+        { name: "Charlie", email: "charlie@test.com" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+
+    it("should score objects with matches in multiple properties", () => {
+      const objects = [
+        { name: "Alice", bio: "Alice is a developer" },
+        { name: "Bob", bio: "Bob works with Alice" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+
+  describe("Whole word matching", () => {
+    it("should prioritize whole word matches over partial", () => {
+      const objects = [
+        { name: "Alice" },
+        { name: "Alicia" },
+        { name: "Alice Wonderland" },
+      ];
+      const result = filterObjectByValue(objects, "alice");
+      expect(result).to.have.length(2);
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Alice Wonderland");
+    });
+
+    it("should identify whole words using word boundaries", () => {
+      const objects = [{ name: "web developer" }, { name: "website" }];
+      const result = filterObjectByValue(objects, "web");
+      expect(result[0].name).to.equal("web developer");
+      expect(result[1].name).to.equal("website");
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should search across user profiles", () => {
+      const users = [
+        {
+          name: "Alice Johnson",
+          email: "alice@example.com",
+          bio: "Software engineer",
+        },
+        { name: "Bob Smith", email: "bob@test.com", bio: "Designer" },
+        {
+          name: "Charlie Brown",
+          email: "charlie@example.com",
+          bio: "Software developer",
+        },
+      ];
+      const result = filterObjectByValue(users, "software");
+      expect(result).to.have.length(2);
+      expect(result.map((u) => u.name)).to.deep.equal([
+        "Alice Johnson",
+        "Charlie Brown",
+      ]);
+    });
+
+    it("should search across project data", () => {
+      const projects = [
+        {
+          name: "Website",
+          description: "E-commerce platform",
+          tags: ["web", "ecommerce"],
+        },
+        {
+          name: "Mobile App",
+          description: "iOS and Android",
+          tags: ["mobile", "ios"],
+        },
+        {
+          name: "API",
+          description: "REST API for web platform",
+          tags: ["api", "web"],
+        },
+      ];
+      const result = filterObjectByValue(projects, "web");
+      expect(result.length).to.be.greaterThan(1);
+    });
+  });
+});

package/cypress/e2e/helpers/datas/sort.cy.ts

@@ -0,0 +1,293 @@
+import sort from "@helpers/datas/sort";
+
+describe("sort helper function", () => {
+  describe("getValueFromAnyKey (internal function behavior)", () => {
+    it("should get value from single-level key", () => {
+      const obj = { name: "Alice", age: 30 };
+      const result = sort([obj], "name", "asc");
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should get value from nested key using array", () => {
+      const obj = { user: { profile: { name: "Alice" } } };
+      const result = sort([obj], ["user", "profile", "name"], "asc");
+      expect(result[0].user.profile.name).to.equal("Alice");
+    });
+
+    it("should return undefined for missing key in non-first elements", () => {
+      const arr = [
+        { name: "Alice", age: 30 },
+        { name: "Bob" },
+        { name: "Charlie", age: 25 },
+      ];
+      const result = sort(arr, "age", "asc");
+      expect(result[0].name).to.equal("Charlie");
+      expect(result[0].age).to.equal(25);
+      expect(result[1].age).to.equal(30);
+      expect(result[2].name).to.equal("Bob");
+      expect(result[2].age).to.be.undefined;
+    });
+  });
+
+  describe("String sorting", () => {
+    it("should sort strings in ascending order", () => {
+      const arr = [{ name: "Charlie" }, { name: "Alice" }, { name: "Bob" }];
+      const result = sort(arr, "name", "asc");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Bob");
+      expect(result[2].name).to.equal("Charlie");
+    });
+
+    it("should sort strings in descending order", () => {
+      const arr = [{ name: "Charlie" }, { name: "Alice" }, { name: "Bob" }];
+      const result = sort(arr, "name", "desc");
+      expect(result[0].name).to.equal("Charlie");
+      expect(result[1].name).to.equal("Bob");
+      expect(result[2].name).to.equal("Alice");
+    });
+
+    it("should sort strings with default ascending order", () => {
+      const arr = [{ name: "Charlie" }, { name: "Alice" }, { name: "Bob" }];
+      const result = sort(arr, "name");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Bob");
+      expect(result[2].name).to.equal("Charlie");
+    });
+
+    it("should use localeCompare for string sorting", () => {
+      const arr = [{ name: "Émile" }, { name: "Alice" }, { name: "Zoe" }];
+      const result = sort(arr, "name", "asc");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Émile");
+      expect(result[2].name).to.equal("Zoe");
+    });
+  });
+
+  describe("Number sorting", () => {
+    it("should sort numbers in ascending order", () => {
+      const arr = [{ age: 30 }, { age: 20 }, { age: 25 }];
+      const result = sort(arr, "age", "asc");
+      expect(result[0].age).to.equal(20);
+      expect(result[1].age).to.equal(25);
+      expect(result[2].age).to.equal(30);
+    });
+
+    it("should sort numbers in descending order", () => {
+      const arr = [{ age: 30 }, { age: 20 }, { age: 25 }];
+      const result = sort(arr, "age", "desc");
+      expect(result[0].age).to.equal(30);
+      expect(result[1].age).to.equal(25);
+      expect(result[2].age).to.equal(20);
+    });
+
+    it("should sort negative numbers", () => {
+      const arr = [{ value: -10 }, { value: 5 }, { value: -5 }, { value: 0 }];
+      const result = sort(arr, "value", "asc");
+      expect(result[0].value).to.equal(-10);
+      expect(result[1].value).to.equal(-5);
+      expect(result[2].value).to.equal(0);
+      expect(result[3].value).to.equal(5);
+    });
+
+    it("should sort decimal numbers", () => {
+      const arr = [{ price: 10.5 }, { price: 5.25 }, { price: 7.75 }];
+      const result = sort(arr, "price", "asc");
+      expect(result[0].price).to.equal(5.25);
+      expect(result[1].price).to.equal(7.75);
+      expect(result[2].price).to.equal(10.5);
+    });
+  });
+
+  describe("Date sorting", () => {
+    it("should sort dates in ascending order", () => {
+      const arr = [
+        { date: new Date("2023-03-01") },
+        { date: new Date("2023-01-01") },
+        { date: new Date("2023-02-01") },
+      ];
+      const result = sort(arr, "date", "asc");
+      expect(result[0].date.toISOString()).to.contain("2023-01");
+      expect(result[1].date.toISOString()).to.contain("2023-02");
+      expect(result[2].date.toISOString()).to.contain("2023-03");
+    });
+
+    it("should sort dates in descending order", () => {
+      const arr = [
+        { date: new Date("2023-03-01") },
+        { date: new Date("2023-01-01") },
+        { date: new Date("2023-02-01") },
+      ];
+      const result = sort(arr, "date", "desc");
+      expect(result[0].date.toISOString()).to.contain("2023-03");
+      expect(result[1].date.toISOString()).to.contain("2023-02");
+      expect(result[2].date.toISOString()).to.contain("2023-01");
+    });
+  });
+
+  describe("Nested key sorting", () => {
+    it("should sort by nested key using array notation", () => {
+      const arr = [
+        { user: { profile: { name: "Charlie" } } },
+        { user: { profile: { name: "Alice" } } },
+        { user: { profile: { name: "Bob" } } },
+      ];
+      const result = sort(arr, ["user", "profile", "name"], "asc");
+      expect(result[0].user.profile.name).to.equal("Alice");
+      expect(result[1].user.profile.name).to.equal("Bob");
+      expect(result[2].user.profile.name).to.equal("Charlie");
+    });
+
+    it("should not support dot notation for nested keys - use array notation", () => {
+      const arr = [
+        { user: { name: "Charlie" } },
+        { user: { name: "Alice" } },
+        { user: { name: "Bob" } },
+      ];
+      expect(() => sort(arr, "user.name", "asc")).to.throw();
+    });
+
+    it("should sort by deeply nested numeric key", () => {
+      const arr = [
+        { data: { stats: { score: 90 } } },
+        { data: { stats: { score: 70 } } },
+        { data: { stats: { score: 80 } } },
+      ];
+      const result = sort(arr, ["data", "stats", "score"], "asc");
+      expect(result[0].data.stats.score).to.equal(70);
+      expect(result[1].data.stats.score).to.equal(80);
+      expect(result[2].data.stats.score).to.equal(90);
+    });
+  });
+
+  describe("Null/undefined handling", () => {
+    it("should put null/undefined values at the end for ascending sort", () => {
+      const arr = [
+        { name: "Bob" },
+        { name: null },
+        { name: "Alice" },
+        { name: undefined },
+        { name: "Charlie" },
+      ];
+      const result = sort(arr, "name", "asc");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Bob");
+      expect(result[2].name).to.equal("Charlie");
+      expect(result[3].name).to.be.null;
+      expect(result[4].name).to.be.undefined;
+    });
+
+    it("should put null/undefined values at the beginning for descending sort", () => {
+      const arr = [
+        { name: "Bob" },
+        { name: null },
+        { name: "Alice" },
+        { name: undefined },
+        { name: "Charlie" },
+      ];
+      const result = sort(arr, "name", "desc");
+      expect(result[0].name).to.satisfy((v: any) => v == null);
+      expect(result[1].name).to.satisfy((v: any) => v == null);
+      expect(result[2].name).to.equal("Charlie");
+      expect(result[3].name).to.equal("Bob");
+      expect(result[4].name).to.equal("Alice");
+    });
+
+    it("should throw TypeError for arrays with all null values", () => {
+      const arr = [{ name: null }, { name: null }, { name: null }];
+      expect(() => sort(arr, "name", "asc")).to.throw();
+    });
+  });
+
+  describe("Immutability", () => {
+    it("should not mutate the original array", () => {
+      const arr = [{ name: "Charlie" }, { name: "Alice" }, { name: "Bob" }];
+      const originalOrder = arr.map((item) => item.name);
+      const result = sort(arr, "name", "asc");
+
+      expect(arr.map((item) => item.name)).to.deep.equal(originalOrder);
+      expect(result.map((item) => item.name)).to.deep.equal([
+        "Alice",
+        "Bob",
+        "Charlie",
+      ]);
+    });
+
+    it("should create a new array reference", () => {
+      const arr = [{ name: "Alice" }, { name: "Bob" }];
+      const result = sort(arr, "name", "asc");
+      expect(result).to.not.equal(arr);
+    });
+  });
+
+  describe("Error handling", () => {
+    it("should throw TypeError for object type values", () => {
+      const arr = [
+        { data: { foo: { bar: "baz" } } },
+        { data: { foo: { bar: "qux" } } },
+      ];
+      expect(() => sort(arr, ["data", "foo"], "asc")).to.throw();
+    });
+
+    it("should throw TypeError for array type values", () => {
+      const arr = [{ items: [1, 2, 3] }, { items: [4, 5, 6] }];
+      expect(() => sort(arr, "items", "asc")).to.throw();
+    });
+
+    it("should throw TypeError when first element has undefined value", () => {
+      const arr = [{ name: undefined }, { name: "Alice" }];
+      expect(() => sort(arr, "name", "asc")).to.throw();
+    });
+
+    it("should throw TypeError when first element has null value", () => {
+      const arr = [{ name: null }, { name: "Alice" }];
+      expect(() => sort(arr, "name", "asc")).to.throw();
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should throw TypeError for empty array", () => {
+      const arr: any[] = [];
+      expect(() => sort(arr, "name", "asc")).to.throw();
+    });
+
+    it("should handle single element array", () => {
+      const arr = [{ name: "Alice" }];
+      const result = sort(arr, "name", "asc");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle equal values", () => {
+      const arr = [{ name: "Alice" }, { name: "Alice" }, { name: "Alice" }];
+      const result = sort(arr, "name", "asc");
+      expect(result).to.have.length(3);
+      expect(result.every((item) => item.name === "Alice")).to.be.true;
+    });
+
+    it("should handle objects with missing nested keys", () => {
+      const arr = [
+        { user: { name: "Alice" } },
+        { user: { name: "Bob" } },
+        { user: {} },
+      ];
+      const result = sort(arr, ["user", "name"], "asc");
+      expect(result[0].user.name).to.equal("Alice");
+      expect(result[1].user.name).to.equal("Bob");
+      expect(result[2].user.name).to.be.undefined;
+    });
+  });
+
+  describe("Mixed data types (same array)", () => {
+    it("should sort objects with mixed string properties", () => {
+      const arr = [
+        { name: "Charlie", age: 30 },
+        { name: "Alice", age: 20 },
+        { name: "Bob", age: 25 },
+      ];
+      const result = sort(arr, "name", "asc");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Bob");
+      expect(result[2].name).to.equal("Charlie");
+    });
+  });
+});