@featurevisor/core 2.5.0 → 2.6.0

package/lib/builder/buildScopedSegments.spec.js

@@ -0,0 +1,1062 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildScopedSegments_1 = require("./buildScopedSegments");
+const sdk_1 = require("@featurevisor/sdk");
+describe("core: buildScopedSegments", function () {
+    describe("buildScopedSegments", function () {
+        const datafileWithSegments = {
+            schemaVersion: "2",
+            revision: "unknown",
+            segments: {
+                web: {
+                    conditions: [{ attribute: "platform", operator: "equals", value: "web" }],
+                },
+                mobile: {
+                    conditions: [{ attribute: "platform", operator: "equals", value: "mobile" }],
+                },
+                chrome: {
+                    conditions: [{ attribute: "browser", operator: "equals", value: "chrome" }],
+                },
+                safari: {
+                    conditions: [{ attribute: "browser", operator: "equals", value: "safari" }],
+                },
+                premium: {
+                    conditions: [
+                        {
+                            and: [
+                                { attribute: "tier", operator: "equals", value: "premium" },
+                                { attribute: "status", operator: "equals", value: "active" },
+                            ],
+                        },
+                    ],
+                },
+                us: {
+                    conditions: [{ attribute: "country", operator: "equals", value: "us" }],
+                },
+                eu: {
+                    conditions: [{ attribute: "country", operator: "equals", value: "eu" }],
+                },
+            },
+            features: {},
+        };
+        const datafileReaderWithSegments = new sdk_1.DatafileReader({
+            datafile: datafileWithSegments,
+            logger: (0, sdk_1.createLogger)({ level: "fatal" }),
+        });
+        test("buildScopedSegments is a function", function () {
+            expect(buildScopedSegments_1.buildScopedSegments).toBeInstanceOf(Function);
+        });
+        test("simple cases", function () {
+            // "*" remains "*"
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, "*", {})).toEqual("*");
+            // Plain segment that matches
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, "web", {
+                platform: "web",
+            })).toEqual("*");
+            // Plain segment that doesn't match
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, "web", {
+                platform: "mobile",
+            })).toEqual("web");
+            // Array of segments - partial match (redundant "*" removed)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "web",
+            })).toEqual(["chrome"]);
+            // Array of segments - full match (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual("*");
+            // Array of segments - no match
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "mobile",
+                browser: "safari",
+            })).toEqual(["web", "chrome"]);
+        });
+        test("AND group segments", function () {
+            // AND with all matching segments (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual("*");
+            // AND with partial match (redundant "*" removed)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {
+                platform: "web",
+            })).toEqual({
+                and: ["chrome"],
+            });
+            // AND with no matches
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {
+                platform: "mobile",
+                browser: "safari",
+            })).toEqual({
+                and: ["web", "chrome"],
+            });
+            // AND with "*" in it (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: ["*", "chrome"],
+            }, {
+                browser: "chrome",
+            })).toEqual("*");
+        });
+        test("OR group segments", function () {
+            // OR with all matching segments (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                or: ["web", "chrome"],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual("*");
+            // OR with partial match (redundant "*" removed, but OR structure remains)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                or: ["web", "chrome"],
+            }, {
+                platform: "web",
+            })).toEqual({
+                or: ["chrome"],
+            });
+            // OR with no matches
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                or: ["web", "mobile"],
+            }, {
+                platform: "desktop",
+            })).toEqual({
+                or: ["web", "mobile"],
+            });
+        });
+        test("NOT group segments", function () {
+            // NOT with matching segment (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                not: ["web"],
+            }, {
+                platform: "web",
+            })).toEqual("*");
+            // NOT with non-matching segment
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                not: ["web"],
+            }, {
+                platform: "mobile",
+            })).toEqual({
+                not: ["web"],
+            });
+            // NOT with multiple segments (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                not: ["web", "chrome"],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual("*");
+        });
+        test("nested AND group segments", function () {
+            // Nested AND with all matching (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        and: ["chrome", "us"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+                country: "us",
+            })).toEqual("*");
+            // Nested AND with partial match (redundant "*" removed)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        and: ["chrome", "us"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                and: [
+                    {
+                        and: ["us"],
+                    },
+                ],
+            });
+        });
+        test("nested OR group segments", function () {
+            // Nested OR with outer match (redundant "*" removed, but inner OR remains)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                or: [
+                    "web",
+                    {
+                        or: ["mobile", "chrome"],
+                    },
+                ],
+            }, {
+                platform: "web",
+            })).toEqual({
+                or: [
+                    {
+                        or: ["mobile", "chrome"],
+                    },
+                ],
+            });
+            // Nested OR with inner match (redundant "*" removed, but outer OR remains)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                or: [
+                    "web",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                ],
+            }, {
+                browser: "chrome",
+            })).toEqual({
+                or: [
+                    "web",
+                    {
+                        or: ["safari"],
+                    },
+                ],
+            });
+        });
+        test("nested NOT group segments", function () {
+            // Nested NOT (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                not: [
+                    "web",
+                    {
+                        not: ["chrome"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual("*");
+        });
+        test("mixed nested group segments", function () {
+            // AND with nested OR (redundant "*" removed, but OR structure remains if not all match)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                and: [
+                    {
+                        or: ["safari"],
+                    },
+                ],
+            });
+            // OR with nested AND (redundant "*" removed, but OR structure remains if not all match)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                or: [
+                    "web",
+                    {
+                        and: ["mobile", "chrome"],
+                    },
+                ],
+            }, {
+                platform: "mobile",
+                browser: "chrome",
+            })).toEqual({
+                or: ["web"],
+            });
+            // AND with nested NOT (redundant "*" removed)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        not: ["mobile"],
+                    },
+                ],
+            }, {
+                platform: "web",
+            })).toEqual({
+                and: [
+                    {
+                        not: ["mobile"],
+                    },
+                ],
+            });
+            // Complex nested structure (redundant "*" removed)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        or: [
+                            {
+                                and: ["chrome", "us"],
+                            },
+                            "safari",
+                        ],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+                country: "us",
+            })).toEqual({
+                and: [
+                    {
+                        or: ["safari"],
+                    },
+                ],
+            });
+        });
+        test("arrays with nested group segments", function () {
+            // Array with AND group segment (redundant "*" removed)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, [
+                "web",
+                {
+                    and: ["chrome", "us"],
+                },
+            ], {
+                platform: "web",
+                browser: "chrome",
+                country: "us",
+            })).toEqual("*");
+            // Array with OR group segment (redundant "*" removed, but OR structure remains if not all match)
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, [
+                "web",
+                {
+                    or: ["chrome", "safari"],
+                },
+            ], {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual([
+                {
+                    or: ["safari"],
+                },
+            ]);
+        });
+        test("segments with complex conditions", function () {
+            // Segment with AND conditions in its definition
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, "premium", {
+                tier: "premium",
+                status: "active",
+            })).toEqual("*");
+            // Segment with AND conditions that doesn't match
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, "premium", {
+                tier: "premium",
+                status: "inactive",
+            })).toEqual("premium");
+        });
+        test("edge cases", function () {
+            // Empty context
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, "web", {})).toEqual("web");
+            // Empty array (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, [], {})).toEqual("*");
+            // "*" in array with matching segment (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, ["*", "web"], {
+                platform: "web",
+            })).toEqual("*");
+            // AND with empty array (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                and: [],
+            }, {})).toEqual("*");
+            // OR with empty array (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedSegments)(datafileReaderWithSegments, {
+                or: [],
+            }, {})).toEqual("*");
+        });
+    });
+    describe("removeRedundantGroupSegments", function () {
+        test("removeRedundantGroupSegments is a function", function () {
+            expect(buildScopedSegments_1.removeRedundantGroupSegments).toBeInstanceOf(Function);
+        });
+        test("simple cases", function () {
+            // * is *
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)("*")).toEqual("*");
+            // [*, *, *] is "*"
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)(["*", "*", "*"])).toEqual("*");
+            // Array with mixed group segments
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)(["*", "web", "*", "chrome"])).toEqual(["web", "chrome"]);
+        });
+        test("AND group segments", function () {
+            // All "*" in AND
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({ and: ["*", "*", "*"] })).toEqual("*");
+            // Mixed with "*" in AND
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: ["*", "web", "*"],
+            })).toEqual({
+                and: ["web"],
+            });
+            // Multiple non-* group segments in AND
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: ["*", "web", "*", "chrome", "*"],
+            })).toEqual({
+                and: ["web", "chrome"],
+            });
+        });
+        test("OR group segments", function () {
+            // All "*" in OR
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({ or: ["*", "*", "*"] })).toEqual("*");
+            // Mixed with "*" in OR
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                or: ["*", "web", "*"],
+            })).toEqual({
+                or: ["web"],
+            });
+            // Multiple non-* group segments in OR
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                or: ["*", "web", "*", "mobile", "*"],
+            })).toEqual({
+                or: ["web", "mobile"],
+            });
+        });
+        test("NOT group segments", function () {
+            // All "*" in NOT
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({ not: ["*", "*", "*"] })).toEqual("*");
+            // Mixed with "*" in NOT
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                not: ["*", "web", "*"],
+            })).toEqual({
+                not: ["web"],
+            });
+        });
+        test("nested AND group segments", function () {
+            // Nested AND with all "*"
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: ["*", { and: ["*", "*", "*"] }, "*"],
+            })).toEqual("*");
+            // Nested AND with mixed group segments
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: [
+                    "*",
+                    "web",
+                    {
+                        and: ["*", "chrome", "*"],
+                    },
+                    "*",
+                ],
+            })).toEqual({
+                and: [
+                    "web",
+                    {
+                        and: ["chrome"],
+                    },
+                ],
+            });
+            // Deeply nested AND
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: [
+                    "*",
+                    {
+                        and: [
+                            "*",
+                            {
+                                and: ["*", "*", "*"],
+                            },
+                            "*",
+                        ],
+                    },
+                    "*",
+                ],
+            })).toEqual("*");
+        });
+        test("nested OR group segments", function () {
+            // Nested OR with all "*"
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                or: ["*", { or: ["*", "*", "*"] }, "*"],
+            })).toEqual("*");
+            // Nested OR with mixed group segments
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                or: [
+                    "*",
+                    "web",
+                    {
+                        or: ["*", "mobile", "*"],
+                    },
+                    "*",
+                ],
+            })).toEqual({
+                or: [
+                    "web",
+                    {
+                        or: ["mobile"],
+                    },
+                ],
+            });
+        });
+        test("nested NOT group segments", function () {
+            // Nested NOT with all "*"
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                not: ["*", { not: ["*", "*", "*"] }, "*"],
+            })).toEqual("*");
+            // Nested NOT with mixed group segments
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                not: [
+                    "*",
+                    "web",
+                    {
+                        not: ["*", "chrome", "*"],
+                    },
+                    "*",
+                ],
+            })).toEqual({
+                not: [
+                    "web",
+                    {
+                        not: ["chrome"],
+                    },
+                ],
+            });
+        });
+        test("mixed nested group segments", function () {
+            // AND with nested OR
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: [
+                    "*",
+                    "web",
+                    {
+                        or: ["*", "chrome", "*"],
+                    },
+                    "*",
+                ],
+            })).toEqual({
+                and: [
+                    "web",
+                    {
+                        or: ["chrome"],
+                    },
+                ],
+            });
+            // OR with nested AND
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                or: [
+                    "*",
+                    "web",
+                    {
+                        and: ["*", "chrome", "*"],
+                    },
+                    "*",
+                ],
+            })).toEqual({
+                or: [
+                    "web",
+                    {
+                        and: ["chrome"],
+                    },
+                ],
+            });
+            // AND with nested NOT
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: [
+                    "*",
+                    "web",
+                    {
+                        not: ["*", "mobile", "*"],
+                    },
+                    "*",
+                ],
+            })).toEqual({
+                and: [
+                    "web",
+                    {
+                        not: ["mobile"],
+                    },
+                ],
+            });
+            // Complex nested structure
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: [
+                    "*",
+                    "web",
+                    {
+                        or: [
+                            "*",
+                            {
+                                and: ["*", "chrome", "*"],
+                            },
+                            "*",
+                        ],
+                    },
+                    "*",
+                ],
+            })).toEqual({
+                and: [
+                    "web",
+                    {
+                        or: [
+                            {
+                                and: ["chrome"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+        test("arrays with nested group segments", function () {
+            // Array with nested AND
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)([
+                "*",
+                {
+                    and: ["*", "web", "*"],
+                },
+                "*",
+            ])).toEqual([
+                {
+                    and: ["web"],
+                },
+            ]);
+            // Array with multiple nested group segments
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)([
+                "*",
+                "web",
+                {
+                    or: ["*", "chrome", "*"],
+                },
+                "*",
+            ])).toEqual([
+                "web",
+                {
+                    or: ["chrome"],
+                },
+            ]);
+        });
+        test("edge cases", function () {
+            // Single group segment after filtering
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)({
+                and: ["*", "web", "*"],
+            })).toEqual({
+                and: ["web"],
+            });
+            // Plain string group segment (no change)
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)("web")).toEqual("web");
+            // Array with single non-* group segment
+            expect((0, buildScopedSegments_1.removeRedundantGroupSegments)(["*", "web", "*"])).toEqual(["web"]);
+        });
+    });
+    describe("buildScopedGroupSegments", function () {
+        const datafileWithSegments = {
+            schemaVersion: "2",
+            revision: "unknown",
+            segments: {
+                web: {
+                    conditions: [{ attribute: "platform", operator: "equals", value: "web" }],
+                },
+                mobile: {
+                    conditions: [{ attribute: "platform", operator: "equals", value: "mobile" }],
+                },
+                chrome: {
+                    conditions: [{ attribute: "browser", operator: "equals", value: "chrome" }],
+                },
+                safari: {
+                    conditions: [{ attribute: "browser", operator: "equals", value: "safari" }],
+                },
+                premium: {
+                    conditions: [
+                        {
+                            and: [
+                                { attribute: "tier", operator: "equals", value: "premium" },
+                                { attribute: "status", operator: "equals", value: "active" },
+                            ],
+                        },
+                    ],
+                },
+                us: {
+                    conditions: [{ attribute: "country", operator: "equals", value: "us" }],
+                },
+                eu: {
+                    conditions: [{ attribute: "country", operator: "equals", value: "eu" }],
+                },
+            },
+            features: {},
+        };
+        const datafileReaderWithSegments = new sdk_1.DatafileReader({
+            datafile: datafileWithSegments,
+            logger: (0, sdk_1.createLogger)({ level: "fatal" }),
+        });
+        test("buildScopedGroupSegments is a function", function () {
+            expect(buildScopedSegments_1.buildScopedGroupSegments).toBeInstanceOf(Function);
+        });
+        test("simple cases", function () {
+            // "*" remains "*"
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "*", {})).toEqual("*");
+            // Plain segment that matches
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "web", {
+                platform: "web",
+            })).toEqual("*");
+            // Plain segment that doesn't match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "web", {
+                platform: "mobile",
+            })).toEqual("web");
+            // Array of segments - partial match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "web",
+            })).toEqual(["*", "chrome"]);
+            // Array of segments - full match (all "*" - will be cleaned by removeRedundantGroupSegments later)
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual(["*", "*"]);
+            // Array of segments - no match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "mobile",
+                browser: "safari",
+            })).toEqual(["web", "chrome"]);
+        });
+        test("AND group segments", function () {
+            // AND with all matching segments (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                and: ["*", "*"],
+            });
+            // AND with partial match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {
+                platform: "web",
+            })).toEqual({
+                and: ["*", "chrome"],
+            });
+            // AND with no matches
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {
+                platform: "mobile",
+                browser: "safari",
+            })).toEqual({
+                and: ["web", "chrome"],
+            });
+            // AND with "*" in it
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: ["*", "chrome"],
+            }, {
+                browser: "chrome",
+            })).toEqual({
+                and: ["*", "*"],
+            });
+        });
+        test("OR group segments", function () {
+            // OR with all matching segments (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: ["web", "chrome"],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                or: ["*", "*"],
+            });
+            // OR with partial match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: ["web", "chrome"],
+            }, {
+                platform: "web",
+            })).toEqual({
+                or: ["*", "chrome"],
+            });
+            // OR with no matches
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: ["web", "mobile"],
+            }, {
+                platform: "desktop",
+            })).toEqual({
+                or: ["web", "mobile"],
+            });
+        });
+        test("NOT group segments", function () {
+            // NOT with matching segment
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                not: ["web"],
+            }, {
+                platform: "web",
+            })).toEqual({
+                not: ["*"],
+            });
+            // NOT with non-matching segment
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                not: ["web"],
+            }, {
+                platform: "mobile",
+            })).toEqual({
+                not: ["web"],
+            });
+            // NOT with multiple segments (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                not: ["web", "chrome"],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                not: ["*", "*"],
+            });
+        });
+        test("nested AND group segments", function () {
+            // Nested AND with all matching (all "*" becomes "*")
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        and: ["chrome", "us"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+                country: "us",
+            })).toEqual({
+                and: [
+                    "*",
+                    {
+                        and: ["*", "*"],
+                    },
+                ],
+            });
+            // Nested AND with partial match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        and: ["chrome", "us"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                and: [
+                    "*",
+                    {
+                        and: ["*", "us"],
+                    },
+                ],
+            });
+        });
+        test("nested OR group segments", function () {
+            // Nested OR with all matching
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: [
+                    "web",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                or: [
+                    "*",
+                    {
+                        or: ["*", "safari"],
+                    },
+                ],
+            });
+            // Nested OR with partial match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: [
+                    "web",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                ],
+            }, {
+                platform: "web",
+            })).toEqual({
+                or: [
+                    "*",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                ],
+            });
+        });
+        test("complex nested structures", function () {
+            // Complex nested with AND, OR, NOT
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                    {
+                        not: ["mobile"],
+                    },
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            })).toEqual({
+                and: [
+                    "*",
+                    {
+                        or: ["*", "safari"],
+                    },
+                    {
+                        not: ["mobile"],
+                    },
+                ],
+            });
+        });
+        test("segments with complex conditions", function () {
+            // Segment with AND conditions in its definition
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "premium", {
+                tier: "premium",
+                status: "active",
+            })).toEqual("*");
+            // Segment with AND conditions that doesn't match
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "premium", {
+                tier: "premium",
+                status: "inactive",
+            })).toEqual("premium");
+        });
+        test("removeSegments parameter", function () {
+            // Simple segment in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "web", {}, ["web"])).toEqual("*");
+            // Segment not in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "web", {}, ["mobile"])).toEqual("web");
+            // Array with one segment in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome"], {}, ["web"])).toEqual(["*", "chrome"]);
+            // Array with all segments in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome"], {}, [
+                "web",
+                "chrome",
+            ])).toEqual(["*", "*"]);
+            // Array with multiple segments, some in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome", "mobile", "safari"], {}, ["web", "mobile"])).toEqual(["*", "chrome", "*", "safari"]);
+            // AND group segment with removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {}, ["web"])).toEqual({
+                and: ["*", "chrome"],
+            });
+            // AND group segment with all segments in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: ["web", "chrome"],
+            }, {}, ["web", "chrome"])).toEqual({
+                and: ["*", "*"],
+            });
+            // OR group segment with removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: ["web", "chrome"],
+            }, {}, ["web"])).toEqual({
+                or: ["*", "chrome"],
+            });
+            // OR group segment with all segments in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: ["web", "chrome"],
+            }, {}, ["web", "chrome"])).toEqual({
+                or: ["*", "*"],
+            });
+            // NOT group segment with removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                not: ["web", "chrome"],
+            }, {}, ["web"])).toEqual({
+                not: ["*", "chrome"],
+            });
+            // NOT group segment with all segments in removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                not: ["web", "chrome"],
+            }, {}, ["web", "chrome"])).toEqual({
+                not: ["*", "*"],
+            });
+            // Nested AND with removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        and: ["chrome", "us"],
+                    },
+                ],
+            }, {}, ["web"])).toEqual({
+                and: [
+                    "*",
+                    {
+                        and: ["chrome", "us"],
+                    },
+                ],
+            });
+            // Nested OR with removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                or: [
+                    "web",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                ],
+            }, {}, ["chrome"])).toEqual({
+                or: [
+                    "web",
+                    {
+                        or: ["*", "safari"],
+                    },
+                ],
+            });
+            // Mixed nested structure with removeSegments
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        or: ["chrome", "safari"],
+                    },
+                    {
+                        not: ["mobile"],
+                    },
+                ],
+            }, {}, ["web", "safari"])).toEqual({
+                and: [
+                    "*",
+                    {
+                        or: ["chrome", "*"],
+                    },
+                    {
+                        not: ["mobile"],
+                    },
+                ],
+            });
+            // removeSegments combined with matching context
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "web",
+            }, ["chrome"])).toEqual(["*", "*"]);
+            // removeSegments with segment that would match context
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "chrome"], {
+                platform: "web",
+                browser: "chrome",
+            }, ["web"])).toEqual(["*", "*"]);
+            // Complex: removeSegments, context matching, and nested structures
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, {
+                and: [
+                    "web",
+                    {
+                        or: ["chrome", "safari", "mobile"],
+                    },
+                    "us",
+                ],
+            }, {
+                platform: "web",
+                browser: "chrome",
+            }, ["us"])).toEqual({
+                and: [
+                    "*",
+                    {
+                        or: ["*", "safari", "mobile"],
+                    },
+                    "*",
+                ],
+            });
+            // Empty removeSegments array (should behave like no removeSegments)
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, "web", {}, [])).toEqual("web");
+            // removeSegments with segment that doesn't exist in datafile
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["web", "nonexistent"], {}, [
+                "nonexistent",
+            ])).toEqual(["web", "*"]);
+            // removeSegments with "*" in array (should still work)
+            expect((0, buildScopedSegments_1.buildScopedGroupSegments)(datafileReaderWithSegments, ["*", "web", "chrome"], {}, ["web"])).toEqual(["*", "*", "chrome"]);
+        });
+    });
+});
+//# sourceMappingURL=buildScopedSegments.spec.js.map