@startinblox/components-ds4go 2.3.0 → 3.0.0

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

@@ -0,0 +1,285 @@
+import filterGenerator from "@helpers/datas/filterGenerator";
+
+describe("filterGenerator helper function", () => {
+  describe("Basic functionality", () => {
+    it("should generate filter options from array of objects", () => {
+      const objects = [
+        { name: "Alice", category: "Engineering" },
+        { name: "Bob", category: "Marketing" },
+      ];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(2);
+      expect(result[0]).to.deep.equal({
+        label: "Engineering",
+        value: "Engineering",
+      });
+      expect(result[1]).to.deep.equal({
+        label: "Marketing",
+        value: "Marketing",
+      });
+    });
+
+    it("should extract label and value from nested objects", () => {
+      const objects = [
+        { name: "Alice", category: { name: "Engineering", "@id": "/cat/1" } },
+        { name: "Bob", category: { name: "Marketing", "@id": "/cat/2" } },
+      ];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(2);
+      expect(result[0]).to.deep.equal({
+        label: "Engineering",
+        value: "/cat/1",
+      });
+      expect(result[1]).to.deep.equal({ label: "Marketing", value: "/cat/2" });
+    });
+  });
+
+  describe("Array field handling", () => {
+    it("should handle array fields by flattening", () => {
+      const objects = [
+        { name: "Alice", tags: ["engineering", "frontend"] },
+        { name: "Bob", tags: ["engineering", "backend"] },
+      ];
+      const result = filterGenerator(objects, "tags");
+      expect(result).to.have.length(3);
+      expect(result).to.deep.include.members([
+        { label: "engineering", value: "engineering" },
+        { label: "frontend", value: "frontend" },
+        { label: "backend", value: "backend" },
+      ]);
+    });
+
+    it("should extract nested objects from array fields", () => {
+      const objects = [
+        {
+          name: "Alice",
+          tags: [
+            { name: "Engineering", "@id": "/tag/1" },
+            { name: "Frontend", "@id": "/tag/2" },
+          ],
+        },
+        { name: "Bob", tags: [{ name: "Backend", "@id": "/tag/3" }] },
+      ];
+      const result = filterGenerator(objects, "tags");
+      expect(result).to.have.length(3);
+      expect(result).to.deep.include.members([
+        { label: "Engineering", value: "/tag/1" },
+        { label: "Frontend", value: "/tag/2" },
+        { label: "Backend", value: "/tag/3" },
+      ]);
+    });
+  });
+
+  describe("Duplicate handling", () => {
+    it("should remove duplicate values", () => {
+      const objects = [
+        { name: "Alice", category: "Engineering" },
+        { name: "Bob", category: "Engineering" },
+        { name: "Charlie", category: "Engineering" },
+      ];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({
+        label: "Engineering",
+        value: "Engineering",
+      });
+    });
+
+    it("should remove duplicate nested objects by @id", () => {
+      const objects = [
+        { name: "Alice", category: { name: "Engineering", "@id": "/cat/1" } },
+        { name: "Bob", category: { name: "Engineering", "@id": "/cat/1" } },
+      ];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({
+        label: "Engineering",
+        value: "/cat/1",
+      });
+    });
+
+    it("should handle mixed duplicates across simple and array values", () => {
+      const objects = [
+        { name: "Alice", tags: ["engineering", "frontend"] },
+        { name: "Bob", tags: ["engineering"] },
+      ];
+      const result = filterGenerator(objects, "tags");
+      expect(result).to.have.length(2);
+      expect(result).to.deep.include.members([
+        { label: "engineering", value: "engineering" },
+        { label: "frontend", value: "frontend" },
+      ]);
+    });
+  });
+
+  describe("Filtering", () => {
+    it("should filter out objects without the specified field", () => {
+      const objects = [
+        { name: "Alice", category: "Engineering" },
+        { name: "Bob" },
+        { name: "Charlie", category: "Marketing" },
+      ];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(2);
+      expect(result.every((item) => item?.label)).to.be.true;
+    });
+
+    it("should filter out items without label or value", () => {
+      const objects = [
+        { name: "Alice", category: null },
+        { name: "Bob", category: undefined },
+        { name: "Charlie", category: "" },
+      ];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(0);
+    });
+
+    it("should filter out array elements with null/undefined values", () => {
+      const objects = [
+        { name: "Alice", tags: ["engineering", null, undefined, "frontend"] },
+      ];
+      const result = filterGenerator(objects, "tags");
+      expect(result).to.have.length(2);
+      expect(result.every((item) => item?.label && item?.value)).to.be.true;
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = filterGenerator([], "category");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle field not present in any object", () => {
+      const objects = [{ name: "Alice" }, { name: "Bob" }];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects with empty array field", () => {
+      const objects = [
+        { name: "Alice", tags: [] },
+        { name: "Bob", tags: ["engineering"] },
+      ];
+      const result = filterGenerator(objects, "tags");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({
+        label: "engineering",
+        value: "engineering",
+      });
+    });
+
+    it("should handle nested object with only @id", () => {
+      const objects = [{ name: "Alice", category: { "@id": "/cat/1" } }];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({
+        label: { "@id": "/cat/1" },
+        value: "/cat/1",
+      });
+    });
+
+    it("should handle nested object with only name", () => {
+      const objects = [{ name: "Alice", category: { name: "Engineering" } }];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({
+        label: "Engineering",
+        value: { name: "Engineering" },
+      });
+    });
+
+    it("should handle array with null elements", () => {
+      const objects = [{ name: "Alice", tags: [null, "engineering"] }];
+      const result = filterGenerator(objects, "tags");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({
+        label: "engineering",
+        value: "engineering",
+      });
+    });
+
+    it("should handle zero as valid value", () => {
+      const objects = [
+        { name: "Alice", level: 0 },
+        { name: "Bob", level: 1 },
+      ];
+      const result = filterGenerator(objects, "level");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({ label: 1, value: 1 });
+    });
+
+    it("should handle false as valid value", () => {
+      const objects = [
+        { name: "Alice", active: false },
+        { name: "Bob", active: true },
+      ];
+      const result = filterGenerator(objects, "active");
+      expect(result).to.have.length(1);
+      expect(result[0]).to.deep.equal({ label: true, value: true });
+    });
+  });
+
+  describe("Label extraction", () => {
+    it("should prefer name property over direct value for label", () => {
+      const objects = [{ category: { name: "Engineering", "@id": "/cat/1" } }];
+      const result = filterGenerator(objects, "category");
+      expect(result[0]?.label).to.equal("Engineering");
+    });
+
+    it("should use direct value when name property is absent", () => {
+      const objects = [{ category: "Engineering" }];
+      const result = filterGenerator(objects, "category");
+      expect(result[0]?.label).to.equal("Engineering");
+    });
+
+    it("should prefer @id property over direct value for value", () => {
+      const objects = [{ category: { name: "Engineering", "@id": "/cat/1" } }];
+      const result = filterGenerator(objects, "category");
+      expect(result[0]?.value).to.equal("/cat/1");
+    });
+
+    it("should use direct value when @id property is absent", () => {
+      const objects = [{ category: "Engineering" }];
+      const result = filterGenerator(objects, "category");
+      expect(result[0]?.value).to.equal("Engineering");
+    });
+  });
+
+  describe("Complex scenarios", () => {
+    it("should handle mixed field types across objects", () => {
+      const objects = [
+        { name: "Alice", category: "Engineering" },
+        { name: "Bob", category: { name: "Marketing", "@id": "/cat/2" } },
+      ];
+      const result = filterGenerator(objects, "category");
+      expect(result).to.have.length(2);
+      expect(result).to.deep.include.members([
+        { label: "Engineering", value: "Engineering" },
+        { label: "Marketing", value: "/cat/2" },
+      ]);
+    });
+
+    it("should handle deeply nested structures in arrays", () => {
+      const objects = [
+        {
+          name: "Alice",
+          tags: [
+            { name: "Engineering", "@id": "/tag/1" },
+            { name: "Frontend", "@id": "/tag/2" },
+          ],
+        },
+        {
+          name: "Bob",
+          tags: [
+            { name: "Backend", "@id": "/tag/3" },
+            { name: "Engineering", "@id": "/tag/1" },
+          ],
+        },
+      ];
+      const result = filterGenerator(objects, "tags");
+      expect(result).to.have.length(3);
+      expect(result.every((item) => item?.label && item?.value)).to.be.true;
+    });
+  });
+});

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

@@ -0,0 +1,389 @@
+import filterObjectByDateAfter from "@helpers/datas/filterObjectByDateAfter";
+
+describe("filterObjectByDateAfter helper function", () => {
+  describe("Basic functionality", () => {
+    it("should filter objects by date property after threshold date", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+        { name: "Event 3", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Event 2", "Event 3"]);
+    });
+
+    it("should exclude objects with date equal to threshold", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-01" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should return all objects when propName is empty", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "", "2023-02-01");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when thresholdDateString is empty", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when thresholdDateString is only whitespace", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "   ");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when thresholdDateString is not a string", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", null as any);
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when threshold date is invalid", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "invalid-date");
+      expect(result).to.have.length(2);
+    });
+  });
+
+  describe("Date format handling", () => {
+    it("should handle ISO date strings", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15T10:30:00Z" },
+        { name: "Event 2", date: "2023-03-15T10:30:00Z" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(2);
+    });
+
+    it("should handle ISO date strings with timezone", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15T10:30:00+05:00" },
+        { name: "Event 2", date: "2023-01-15T10:30:00+05:00" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle timestamp numbers", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle Date objects", () => {
+      const objects = [
+        { name: "Event 1", date: new Date("2023-02-15") },
+        { name: "Event 2", date: new Date("2023-01-15") },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle various date formats", () => {
+      const objects = [
+        { name: "Event 1", date: "2023/02/15" },
+        { name: "Event 2", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(2);
+    });
+  });
+
+  describe("Nested property handling", () => {
+    it("should filter by nested date property", () => {
+      const objects = [
+        { name: "Project 1", metadata: { createdAt: "2023-02-15" } },
+        { name: "Project 2", metadata: { createdAt: "2023-01-15" } },
+      ];
+      const result = filterObjectByDateAfter(
+        objects,
+        "metadata.createdAt",
+        "2023-02-01",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Project 1");
+    });
+
+    it("should filter by deeply nested date property", () => {
+      const objects = [
+        { name: "User 1", data: { profile: { joined: "2023-02-15" } } },
+        { name: "User 2", data: { profile: { joined: "2023-01-15" } } },
+      ];
+      const result = filterObjectByDateAfter(
+        objects,
+        "data.profile.joined",
+        "2023-02-01",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("User 1");
+    });
+
+    it("should search within arrays", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          milestones: [{ date: "2023-02-15" }, { date: "2023-03-15" }],
+        },
+        { name: "Project 2", milestones: [{ date: "2023-01-15" }] },
+      ];
+      const result = filterObjectByDateAfter(
+        objects,
+        "milestones",
+        "2023-02-01",
+      );
+      expect(result).to.have.length(0);
+    });
+
+    it("should return empty array when nested property does not exist", () => {
+      const objects = [
+        { name: "Event 1", metadata: { createdAt: "2023-02-15" } },
+        { name: "Event 2", metadata: { createdAt: "2023-01-15" } },
+      ];
+      const result = filterObjectByDateAfter(
+        objects,
+        "nonexistent.property",
+        "2023-02-01",
+      );
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = filterObjectByDateAfter([], "date", "2023-02-01");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects without the property", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15" },
+        { name: "Event 2" },
+        { name: "Event 3", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Event 1", "Event 3"]);
+    });
+
+    it("should handle objects with null property", () => {
+      const objects = [
+        { name: "Event 1", date: null },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle objects with undefined property", () => {
+      const objects = [
+        { name: "Event 1", date: undefined },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle objects with invalid date string", () => {
+      const objects = [
+        { name: "Event 1", date: "not a date" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle invalid date values", () => {
+      const objects = [
+        { name: "Event 1", date: Number.NaN },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle empty string date values", () => {
+      const objects = [
+        { name: "Event 1", date: "" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should return empty array when no dates are after threshold", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-01-20" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(0);
+    });
+
+    it("should return all objects when all dates are after threshold", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-03-15" },
+        { name: "Event 2", date: "2023-04-15" },
+      ];
+      const result = filterObjectByDateAfter(objects, "date", "2023-02-01");
+      expect(result).to.have.length(2);
+    });
+  });
+
+  describe("Precision handling", () => {
+    it("should compare dates at millisecond precision", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-01T00:00:00.000Z" },
+        { name: "Event 2", date: "2023-02-01T00:00:00.001Z" },
+      ];
+      const result = filterObjectByDateAfter(
+        objects,
+        "date",
+        "2023-02-01T00:00:00.000Z",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle dates with time components", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-01T08:00:00Z" },
+        { name: "Event 2", date: "2023-02-01T12:00:00Z" },
+        { name: "Event 3", date: "2023-02-01T16:00:00Z" },
+      ];
+      const result = filterObjectByDateAfter(
+        objects,
+        "date",
+        "2023-02-01T10:00:00Z",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Event 2", "Event 3"]);
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should filter projects by creation date after a threshold", () => {
+      const projects = [
+        { name: "Project A", createdAt: "2023-01-15" },
+        { name: "Project B", createdAt: "2023-02-15" },
+        { name: "Project C", createdAt: "2023-03-15" },
+        { name: "Project D", createdAt: "2023-04-15" },
+      ];
+      const result = filterObjectByDateAfter(
+        projects,
+        "createdAt",
+        "2023-02-01",
+      );
+      expect(result).to.have.length(3);
+      expect(result.map((p) => p.name)).to.deep.equal([
+        "Project B",
+        "Project C",
+        "Project D",
+      ]);
+    });
+
+    it("should filter events by date after today", () => {
+      const today = new Date().toISOString().split("T")[0];
+      const tomorrow = new Date(Date.now() + 86400000)
+        .toISOString()
+        .split("T")[0];
+
+      const events = [
+        { name: "Past Event", date: "2023-01-01" },
+        { name: "Future Event", date: tomorrow },
+      ];
+      const result = filterObjectByDateAfter(events, "date", today);
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Future Event");
+    });
+
+    it("should filter tasks by due date", () => {
+      const tasks = [
+        { name: "Task 1", dueDate: "2023-05-01" },
+        { name: "Task 2", dueDate: "2023-06-01" },
+        { name: "Task 3", dueDate: "2023-04-01" },
+      ];
+      const result = filterObjectByDateAfter(tasks, "dueDate", "2023-05-01");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Task 2");
+    });
+
+    it("should filter users by last login", () => {
+      const users = [
+        { name: "Alice", lastLogin: "2023-05-15T10:00:00Z" },
+        { name: "Bob", lastLogin: "2023-06-15T10:00:00Z" },
+        { name: "Charlie", lastLogin: "2023-04-15T10:00:00Z" },
+      ];
+      const result = filterObjectByDateAfter(
+        users,
+        "lastLogin",
+        "2023-05-01T00:00:00Z",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((u) => u.name)).to.deep.equal(["Alice", "Bob"]);
+    });
+  });
+
+  describe("Complex nested structures", () => {
+    it("should find dates in deeply nested structures", () => {
+      const objects = [
+        {
+          name: "Project1",
+          data: { history: { entries: [{ date: "2023-02-15" }] } },
+        },
+        {
+          name: "Project2",
+          data: { history: { entries: [{ date: "2023-01-15" }] } },
+        },
+      ];
+      const result = filterObjectByDateAfter(objects, "data", "2023-02-01");
+      expect(result).to.have.length(0);
+    });
+
+    it("should handle mixed date types in nested arrays", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          events: ["2023-02-15", "2023-03-15", { date: "2023-04-15" }],
+        },
+        { name: "Project 2", events: ["2023-01-15"] },
+      ];
+      const result = filterObjectByDateAfter(objects, "events", "2023-02-01");
+      expect(result).to.have.length(0);
+    });
+  });
+});