@featurevisor/core 2.26.1 → 3.0.1

package/lib/builder/buildScopedSegments.spec.js

@@ -1,1062 +0,0 @@
-"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