@startinblox/components-ds4go 2.2.4 → 3.0.0

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

@@ -0,0 +1,299 @@
+import filterObjectByNamedValue from "@helpers/datas/filterObjectByNamedValue";
+
+describe("filterObjectByNamedValue helper function", () => {
+  describe("Basic functionality", () => {
+    it("should filter objects by property value matching search string", () => {
+      const objects = [
+        { name: "Alice Johnson", age: 30 },
+        { name: "Bob Smith", age: 25 },
+        { name: "Charlie Brown", age: 35 },
+      ];
+      const result = filterObjectByNamedValue(objects, "name", "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice Johnson");
+    });
+
+    it("should return all objects when propName is empty", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterObjectByNamedValue(objects, "", "alice");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when searchString is empty", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterObjectByNamedValue(objects, "name", "");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when searchString is only whitespace", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterObjectByNamedValue(objects, "name", "   ");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return empty array when no match found", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterObjectByNamedValue(objects, "name", "xyz");
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Search scoring", () => {
+    it("should prioritize whole word matches", () => {
+      const objects = [
+        { name: "Alice" },
+        { name: "Alice Johnson" },
+        { name: "Alice Wonderland" },
+        { name: "Alicia" },
+      ];
+      const result = filterObjectByNamedValue(objects, "name", "alice");
+      expect(result).to.have.length(3);
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Alice Johnson");
+      expect(result[2].name).to.equal("Alice Wonderland");
+    });
+
+    it("should score partial matches lower than whole word matches", () => {
+      const objects = [{ name: "Alice Wonderland" }, { name: "Bob" }];
+      const result = filterObjectByNamedValue(objects, "name", "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice Wonderland");
+    });
+
+    it("should sort results by relevance score descending", () => {
+      const objects = [
+        { name: "Alice" },
+        { name: "Alice Wonderland" },
+        { name: "Bob Alice" },
+      ];
+      const result = filterObjectByNamedValue(objects, "name", "alice");
+      expect(result[0].name).to.equal("Alice");
+      expect(result[1].name).to.equal("Alice Wonderland");
+      expect(result[2].name).to.equal("Bob Alice");
+    });
+  });
+
+  describe("Case sensitivity", () => {
+    it("should be case insensitive", () => {
+      const objects = [{ name: "Alice" }, { name: "BOB" }, { name: "Charlie" }];
+      const result = filterObjectByNamedValue(objects, "name", "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 = filterObjectByNamedValue(objects, "name", "ALICE");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("alice");
+    });
+  });
+
+  describe("Nested property handling", () => {
+    it("should filter by nested property using dot notation", () => {
+      const objects = [
+        { name: "Alice", profile: { bio: "Software engineer" } },
+        { name: "Bob", profile: { bio: "Designer" } },
+        { name: "Charlie", profile: { bio: "Software developer" } },
+      ];
+      const result = filterObjectByNamedValue(
+        objects,
+        "profile.bio",
+        "software",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Charlie"]);
+    });
+
+    it("should filter by deeply nested property", () => {
+      const objects = [
+        { name: "Alice", user: { profile: { bio: "Software engineer" } } },
+        { name: "Bob", user: { profile: { bio: "Designer" } } },
+      ];
+      const result = filterObjectByNamedValue(
+        objects,
+        "user.profile.bio",
+        "software",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should return empty array when nested property does not exist", () => {
+      const objects = [
+        { name: "Alice", profile: { bio: "Software" } },
+        { name: "Bob", profile: { bio: "Designer" } },
+      ];
+      const result = filterObjectByNamedValue(
+        objects,
+        "nonexistent.property",
+        "software",
+      );
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Recursive search within property", () => {
+    it("should search recursively within nested objects", () => {
+      const objects = [
+        {
+          name: "Alice",
+          profile: { bio: "Software engineer with Python experience" },
+        },
+        { name: "Bob", profile: { bio: "Designer" } },
+      ];
+      const result = filterObjectByNamedValue(objects, "profile", "python");
+      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 = filterObjectByNamedValue(objects, "skills", "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 = filterObjectByNamedValue(objects, "skills", "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 = filterObjectByNamedValue(objects, "data", "python");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+
+  describe("Special characters in search", () => {
+    it("should handle regex special characters in search string", () => {
+      const objects = [{ name: "C++ Developer" }, { name: "Java Developer" }];
+      const result = filterObjectByNamedValue(objects, "name", "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 = filterObjectByNamedValue(objects, "name", "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 = filterObjectByNamedValue(objects, "name", "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 = filterObjectByNamedValue([], "name", "test");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects with null property", () => {
+      const objects = [{ name: null }, { name: "Alice" }];
+      const result = filterObjectByNamedValue(objects, "name", "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle objects with undefined property", () => {
+      const objects = [{ name: undefined }, { name: "Alice" }];
+      const result = filterObjectByNamedValue(objects, "name", "alice");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle property value that is number", () => {
+      const objects = [
+        { name: "Alice", score: 100 },
+        { name: "Bob", score: 200 },
+      ];
+      const result = filterObjectByNamedValue(objects, "score", "100");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle property value that is boolean", () => {
+      const objects = [
+        { name: "Alice", active: true },
+        { name: "Bob", active: false },
+      ];
+      const result = filterObjectByNamedValue(objects, "active", "true");
+      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 = filterObjectByNamedValue(objects, "data.mixed", "match");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should filter users by name", () => {
+      const users = [
+        { "@id": "/user/1", name: "Alice Johnson" },
+        { "@id": "/user/2", name: "Bob Smith" },
+        { "@id": "/user/3", name: "Alice Williams" },
+      ];
+      const result = filterObjectByNamedValue(users, "name", "alice");
+      expect(result).to.have.length(2);
+      expect(result[0].name).to.equal("Alice Johnson");
+      expect(result[1].name).to.equal("Alice Williams");
+    });
+
+    it("should filter projects by description", () => {
+      const projects = [
+        {
+          "@id": "/project/1",
+          name: "Website",
+          description: "E-commerce platform",
+        },
+        {
+          "@id": "/project/2",
+          name: "Mobile App",
+          description: "iOS and Android",
+        },
+        {
+          "@id": "/project/3",
+          name: "API",
+          description: "REST API for platform",
+        },
+      ];
+      const result = filterObjectByNamedValue(
+        projects,
+        "description",
+        "platform",
+      );
+      expect(result).to.have.length(2);
+    });
+  });
+});

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

@@ -0,0 +1,307 @@
+import filterObjectByType from "@helpers/datas/filterObjectByType";
+
+describe("filterObjectByType helper function", () => {
+  describe("Basic functionality", () => {
+    it("should filter objects by @type property", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": "User", name: "Alice" },
+        { "@id": "/resource/2", "@type": "Project", name: "Website" },
+        { "@id": "/resource/3", "@type": "User", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+
+    it("should return all objects when targetType is empty", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": "User", name: "Alice" },
+        { "@id": "/resource/2", "@type": "Project", name: "Website" },
+      ];
+      const result = filterObjectByType(objects, "");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return empty array when no match found", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": "User", name: "Alice" },
+        { "@id": "/resource/2", "@type": "Project", name: "Website" },
+      ];
+      const result = filterObjectByType(objects, "Task");
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Array @type handling", () => {
+    it("should filter objects with @type as an array", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": ["User", "Admin"], name: "Alice" },
+        { "@id": "/resource/2", "@type": ["Project"], name: "Website" },
+        { "@id": "/resource/3", "@type": ["User", "Member"], name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+
+    it("should match any type in the array", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": ["User", "Admin"], name: "Alice" },
+        { "@id": "/resource/2", "@type": ["Project"], name: "Website" },
+      ];
+      const result = filterObjectByType(objects, "Admin");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should return empty array when target type not in any array", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": ["User", "Admin"], name: "Alice" },
+        { "@id": "/resource/2", "@type": ["Project"], name: "Website" },
+      ];
+      const result = filterObjectByType(objects, "Task");
+      expect(result).to.have.length(0);
+    });
+
+    it("should handle arrays with multiple types", () => {
+      const objects = [
+        {
+          "@id": "/resource/1",
+          "@type": ["User", "Admin", "Moderator"],
+          name: "Alice",
+        },
+        {
+          "@id": "/resource/2",
+          "@type": ["Project", "Active"],
+          name: "Website",
+        },
+      ];
+      const result = filterObjectByType(objects, "Moderator");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle arrays with duplicate types", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": ["User", "User"], name: "Alice" },
+        { "@id": "/resource/2", "@type": ["Project"], name: "Website" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+
+  describe("String @type handling", () => {
+    it("should filter objects with @type as a string", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": "User", name: "Alice" },
+        { "@id": "/resource/2", "@type": "Project", name: "Website" },
+        { "@id": "/resource/3", "@type": "User", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+
+    it("should match exact string type", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": "User", name: "Alice" },
+        { "@id": "/resource/2", "@type": "UserAdmin", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should be case sensitive", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": "User", name: "Alice" },
+        { "@id": "/resource/2", "@type": "user", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = filterObjectByType([], "User");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects without @type property", () => {
+      const objects = [
+        { "@id": "/resource/1", name: "Alice" },
+        { "@id": "/resource/2", "@type": "User", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Bob");
+    });
+
+    it("should handle objects with null @type", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": null, name: "Alice" },
+        { "@id": "/resource/2", "@type": "User", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Bob");
+    });
+
+    it("should handle objects with undefined @type", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": undefined, name: "Alice" },
+        { "@id": "/resource/2", "@type": "User", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Bob");
+    });
+
+    it("should handle empty array @type", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": [], name: "Alice" },
+        { "@id": "/resource/2", "@type": ["User"], name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Bob");
+    });
+
+    it("should handle objects with non-string/non-array @type", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": 123 as any, name: "Alice" },
+        { "@id": "/resource/2", "@type": "User", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Bob");
+    });
+
+    it("should handle mixed @type types (string and array)", () => {
+      const objects = [
+        { "@id": "/resource/1", "@type": "User", name: "Alice" },
+        { "@id": "/resource/2", "@type": ["User", "Admin"], name: "Bob" },
+        { "@id": "/resource/3", "@type": "Project", name: "Website" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should filter resources by JSON-LD type", () => {
+      const resources = [
+        { "@id": "/user/1", "@type": "foaf:Person", name: "Alice" },
+        { "@id": "/project/1", "@type": "doap:Project", name: "Website" },
+        { "@id": "/user/2", "@type": "foaf:Person", name: "Bob" },
+        { "@id": "/task/1", "@type": "schema:Task", name: "Design" },
+      ];
+      const result = filterObjectByType(resources, "foaf:Person");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+
+    it("should filter by common RDF types", () => {
+      const objects = [
+        { "@id": "/1", "@type": "http://schema.org/Person", name: "Alice" },
+        {
+          "@id": "/2",
+          "@type": "http://schema.org/Organization",
+          name: "Company",
+        },
+        { "@id": "/3", "@type": "http://schema.org/Person", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "http://schema.org/Person");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+
+    it("should filter multi-typed resources", () => {
+      const resources = [
+        { "@id": "/1", "@type": ["User", "Admin"], name: "Super Admin" },
+        { "@id": "/2", "@type": ["User"], name: "Regular User" },
+        { "@id": "/3", "@type": ["User", "Moderator"], name: "Moderator" },
+      ];
+      const result = filterObjectByType(resources, "User");
+      expect(result).to.have.length(3);
+    });
+  });
+
+  describe("Multiple matching", () => {
+    it("should return all matching objects", () => {
+      const objects = [
+        { "@id": "/1", "@type": "User", name: "Alice" },
+        { "@id": "/2", "@type": "User", name: "Bob" },
+        { "@id": "/3", "@type": "User", name: "Charlie" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(3);
+    });
+
+    it("should handle objects with multiple types in array matching same target", () => {
+      const objects = [
+        { "@id": "/1", "@type": ["User", "User"], name: "Alice" },
+        { "@id": "/2", "@type": ["User"], name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, "User");
+      expect(result).to.have.length(2);
+    });
+  });
+
+  describe("Type edge cases", () => {
+    it("should handle type with special characters", () => {
+      const objects = [
+        {
+          "@id": "/1",
+          "@type": "http://example.com/types/User-Profile",
+          name: "Alice",
+        },
+        {
+          "@id": "/2",
+          "@type": "http://example.com/types/Project",
+          name: "Website",
+        },
+      ];
+      const result = filterObjectByType(
+        objects,
+        "http://example.com/types/User-Profile",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle type with URI fragments", () => {
+      const objects = [
+        {
+          "@id": "/1",
+          "@type": "http://schema.org/Person#User",
+          name: "Alice",
+        },
+        { "@id": "/2", "@type": "http://schema.org/Person", name: "Bob" },
+      ];
+      const result = filterObjectByType(
+        objects,
+        "http://schema.org/Person#User",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should handle very long type URIs", () => {
+      const longUri =
+        "http://example.com/very/long/path/to/resource/type/definition/User";
+      const objects = [
+        { "@id": "/1", "@type": longUri, name: "Alice" },
+        { "@id": "/2", "@type": "http://example.com/other/type", name: "Bob" },
+      ];
+      const result = filterObjectByType(objects, longUri);
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+  });
+});