@windstream/react-shared-components 0.1.93 → 0.1.95

package/src/utils/cookie.test.ts

@@ -0,0 +1,180 @@
+import {
+  getCookie,
+  getParsedCookie,
+  getUTMs,
+  removeUTMs,
+  setCookie,
+  setUTMs,
+} from "./cookie";
+import { Base64 } from "js-base64";
+import Cookies from "js-cookie";
+
+jest.mock("js-cookie");
+
+const mockCookiesGet = Cookies.get as jest.Mock;
+const mockCookiesSet = Cookies.set as jest.Mock;
+const mockCookiesRemove = Cookies.remove as jest.Mock;
+
+describe("cookie utilities", () => {
+  afterEach(() => {
+    mockCookiesGet.mockReset();
+    mockCookiesSet.mockReset();
+    mockCookiesRemove.mockReset();
+  });
+
+  // ── getUTMs ──────────────────────────────────────────
+  describe("getUTMs", () => {
+    it("returns null when window is undefined", () => {
+      const origWindow = globalThis.window;
+      // @ts-expect-error - intentionally deleting window
+      delete globalThis.window;
+      expect(getUTMs()).toBeNull();
+      globalThis.window = origWindow;
+    });
+
+    it("returns null when cookie does not exist", () => {
+      mockCookiesGet.mockReturnValue(undefined as any);
+      expect(getUTMs()).toBeNull();
+      expect(mockCookiesGet).toHaveBeenCalledWith("utm_parameters");
+    });
+
+    it("decodes and parses a valid Base64 cookie", () => {
+      const utms = { utm_source: "google", utm_medium: "cpc" };
+      const encoded = Base64.encode(JSON.stringify(utms));
+      mockCookiesGet.mockReturnValue(encoded as any);
+
+      expect(getUTMs()).toEqual(utms);
+    });
+
+    it("returns null for an invalid Base64/JSON cookie", () => {
+      mockCookiesGet.mockReturnValue("not-valid-base64!!!" as any);
+      expect(getUTMs()).toBeNull();
+    });
+  });
+
+  // ── setUTMs ──────────────────────────────────────────
+  describe("setUTMs", () => {
+    it("returns early when window is undefined", () => {
+      const origWindow = globalThis.window;
+      // @ts-expect-error - intentionally deleting window
+      delete globalThis.window;
+      setUTMs({ utm_source: "test" });
+      expect(mockCookiesSet).not.toHaveBeenCalled();
+      globalThis.window = origWindow;
+    });
+
+    it("encodes UTMs to Base64 and sets cookie with default domain", () => {
+      const utms = { utm_source: "google" };
+      setUTMs(utms);
+
+      const expectedEncoded = Base64.encode(JSON.stringify(utms));
+      expect(mockCookiesSet).toHaveBeenCalledWith(
+        "utm_parameters",
+        expectedEncoded,
+        { domain: ".gokinetic.com", path: "/", sameSite: "Lax" }
+      );
+    });
+
+    it("accepts a custom domain", () => {
+      setUTMs({ utm_source: "bing" }, ".custom.com");
+      expect(mockCookiesSet).toHaveBeenCalledWith(
+        "utm_parameters",
+        expect.any(String),
+        { domain: ".custom.com", path: "/", sameSite: "Lax" }
+      );
+    });
+  });
+
+  // ── removeUTMs ───────────────────────────────────────
+  describe("removeUTMs", () => {
+    it("removes cookie with default domain", () => {
+      removeUTMs();
+      expect(mockCookiesRemove).toHaveBeenCalledWith("utm_parameters", {
+        domain: ".gokinetic.com",
+        path: "/",
+      });
+    });
+
+    it("removes cookie with custom domain", () => {
+      removeUTMs(".other.com");
+      expect(mockCookiesRemove).toHaveBeenCalledWith("utm_parameters", {
+        domain: ".other.com",
+        path: "/",
+      });
+    });
+  });
+
+  // ── getCookie ────────────────────────────────────────
+  describe("getCookie", () => {
+    it("returns empty string when window is undefined", () => {
+      const origWindow = globalThis.window;
+      // @ts-expect-error - intentionally deleting window
+      delete globalThis.window;
+      expect(getCookie("key")).toBe("");
+      globalThis.window = origWindow;
+    });
+
+    it("returns decoded value when cookie exists", () => {
+      const value = "hello world";
+      mockCookiesGet.mockReturnValue(Base64.encode(value) as any);
+      expect(getCookie("my_key")).toBe(value);
+    });
+
+    it("returns null when cookie does not exist", () => {
+      mockCookiesGet.mockReturnValue(undefined as any);
+      expect(getCookie("missing")).toBeNull();
+    });
+  });
+
+  // ── getParsedCookie ──────────────────────────────────
+  describe("getParsedCookie", () => {
+    it("returns parsed JSON from cookie", () => {
+      const obj = { foo: "bar", num: 42 };
+      mockCookiesGet.mockReturnValue(Base64.encode(JSON.stringify(obj)) as any);
+      expect(getParsedCookie("key")).toEqual(obj);
+    });
+
+    it("returns null when cookie is missing", () => {
+      mockCookiesGet.mockReturnValue(undefined as any);
+      expect(getParsedCookie("missing")).toBeNull();
+    });
+
+    it("returns null when cookie has invalid JSON", () => {
+      mockCookiesGet.mockReturnValue(Base64.encode("not json") as any);
+      expect(getParsedCookie("bad")).toBeNull();
+    });
+  });
+
+  // ── setCookie ────────────────────────────────────────
+  describe("setCookie", () => {
+    it("returns early when window is undefined", () => {
+      const origWindow = globalThis.window;
+      // @ts-expect-error - intentionally deleting window
+      delete globalThis.window;
+      setCookie("key", "value", {});
+      expect(mockCookiesSet).not.toHaveBeenCalled();
+      globalThis.window = origWindow;
+    });
+
+    it("encodes value to Base64 and sets cookie with options", () => {
+      const value = { plan: "fiber", speed: 500 };
+      const options = { domain: ".test.com", path: "/" };
+      setCookie("plan_data", value, options);
+
+      const expectedEncoded = Base64.encode(JSON.stringify(value));
+      expect(mockCookiesSet).toHaveBeenCalledWith(
+        "plan_data",
+        expectedEncoded,
+        options
+      );
+    });
+
+    it("handles string values", () => {
+      setCookie("simple", "hello", { path: "/" });
+      const expectedEncoded = Base64.encode(JSON.stringify("hello"));
+      expect(mockCookiesSet).toHaveBeenCalledWith("simple", expectedEncoded, {
+        path: "/",
+      });
+    });
+  });
+});

package/src/utils/cx.test.ts

@@ -0,0 +1,90 @@
+import { clsx, cx } from "./cx";
+
+describe("cx utility", () => {
+  describe("basic class merging", () => {
+    it("returns empty string for no arguments", () => {
+      expect(cx()).toBe("");
+    });
+
+    it("returns single class unchanged", () => {
+      expect(cx("text-red-500")).toBe("text-red-500");
+    });
+
+    it("combines multiple classes", () => {
+      const result = cx("p-4", "m-2", "bg-white");
+      expect(result).toContain("p-4");
+      expect(result).toContain("m-2");
+      expect(result).toContain("bg-white");
+    });
+  });
+
+  describe("Tailwind conflict resolution", () => {
+    it("resolves conflicting padding classes (last wins)", () => {
+      expect(cx("p-4", "p-8")).toBe("p-8");
+    });
+
+    it("resolves conflicting text color classes", () => {
+      expect(cx("text-red-500", "text-blue-500")).toBe("text-blue-500");
+    });
+
+    it("resolves conflicting margin classes", () => {
+      expect(cx("m-2", "m-6")).toBe("m-6");
+    });
+  });
+
+  describe("custom font-variants class group", () => {
+    it("resolves conflicting font variant classes", () => {
+      expect(cx("heading1", "body1")).toBe("body1");
+    });
+
+    it("resolves heading vs label variants", () => {
+      expect(cx("heading3", "label2")).toBe("label2");
+    });
+
+    it("keeps non-conflicting classes alongside font variants", () => {
+      const result = cx("heading1", "text-red-500", "body2");
+      expect(result).toContain("body2");
+      expect(result).toContain("text-red-500");
+      expect(result).not.toContain("heading1");
+    });
+  });
+
+  describe("custom button-sizes class group", () => {
+    it("resolves conflicting button size classes", () => {
+      expect(cx("btn-small", "btn-large")).toBe("btn-large");
+    });
+
+    it("resolves btn-medium vs btn-x-large", () => {
+      expect(cx("btn-medium", "btn-x-large")).toBe("btn-x-large");
+    });
+  });
+
+  describe("conditional and falsy values (via clsx)", () => {
+    it("filters out falsy values", () => {
+      expect(cx("p-4", false, null, undefined, 0, "", "m-2")).toBe("p-4 m-2");
+    });
+
+    it("supports conditional object syntax", () => {
+      expect(cx({ "bg-red-500": true, "bg-blue-500": false })).toBe(
+        "bg-red-500"
+      );
+    });
+
+    it("supports arrays", () => {
+      expect(cx(["p-2", "m-4"])).toBe("p-2 m-4");
+    });
+
+    it("supports mixed arguments", () => {
+      const result = cx("base", ["arr1"], { conditional: true }, undefined);
+      expect(result).toContain("base");
+      expect(result).toContain("arr1");
+      expect(result).toContain("conditional");
+    });
+  });
+
+  describe("exports", () => {
+    it("exports clsx function", () => {
+      expect(typeof clsx).toBe("function");
+    });
+  });
+});

package/src/utils/index.test.ts

@@ -0,0 +1,115 @@
+/**
+ * This test ensures all re-exports from the utils barrel file are resolved,
+ * which satisfies the function coverage requirement for the barrel module.
+ */
+import {
+  buildPreservedQueryHref,
+  clsx,
+  combineExistingAndNewUTMs,
+  cx,
+  getCampaignProperties,
+  getCookie,
+  getOrganicTrafficUtmParameters,
+  getParsedCookie,
+  getUtmParametersFromURL,
+  getUTMs,
+  label1BoldOptions,
+  removeUTMs,
+  renderContentfulRichText,
+  renderContentfulRichTextTable,
+  setCookie,
+  setUTMs,
+  SpeedCardBg,
+  toDocument,
+  useContentfulRichText,
+  useProcessedChecklist,
+  UTM_PARAM_NAMES,
+} from "./index";
+
+describe("utils barrel exports", () => {
+  it("exports cx", () => {
+    expect(typeof cx).toBe("function");
+  });
+
+  it("exports clsx", () => {
+    expect(typeof clsx).toBe("function");
+  });
+
+  it("exports SpeedCardBg", () => {
+    expect(typeof SpeedCardBg).toBe("function");
+  });
+
+  it("exports getUTMs", () => {
+    expect(typeof getUTMs).toBe("function");
+  });
+
+  it("exports setUTMs", () => {
+    expect(typeof setUTMs).toBe("function");
+  });
+
+  it("exports removeUTMs", () => {
+    expect(typeof removeUTMs).toBe("function");
+  });
+
+  it("exports getCookie", () => {
+    expect(typeof getCookie).toBe("function");
+  });
+
+  it("exports getParsedCookie", () => {
+    expect(typeof getParsedCookie).toBe("function");
+  });
+
+  it("exports setCookie", () => {
+    expect(typeof setCookie).toBe("function");
+  });
+
+  it("exports getUtmParametersFromURL", () => {
+    expect(typeof getUtmParametersFromURL).toBe("function");
+  });
+
+  it("exports combineExistingAndNewUTMs", () => {
+    expect(typeof combineExistingAndNewUTMs).toBe("function");
+  });
+
+  it("exports getOrganicTrafficUtmParameters", () => {
+    expect(typeof getOrganicTrafficUtmParameters).toBe("function");
+  });
+
+  it("exports getCampaignProperties", () => {
+    expect(typeof getCampaignProperties).toBe("function");
+  });
+
+  it("exports buildPreservedQueryHref", () => {
+    expect(typeof buildPreservedQueryHref).toBe("function");
+  });
+
+  it("exports UTM_PARAM_NAMES", () => {
+    expect(UTM_PARAM_NAMES).toBeDefined();
+    expect(Array.isArray(UTM_PARAM_NAMES)).toBe(true);
+  });
+
+  it("exports toDocument", () => {
+    expect(typeof toDocument).toBe("function");
+  });
+
+  it("exports renderContentfulRichText", () => {
+    expect(typeof renderContentfulRichText).toBe("function");
+  });
+
+  it("exports useContentfulRichText", () => {
+    expect(typeof useContentfulRichText).toBe("function");
+  });
+
+  it("exports renderContentfulRichTextTable", () => {
+    expect(typeof renderContentfulRichTextTable).toBe("function");
+  });
+
+  it("exports useProcessedChecklist", () => {
+    expect(typeof useProcessedChecklist).toBe("function");
+  });
+
+  it("exports label1BoldOptions", () => {
+    expect(label1BoldOptions).toBeDefined();
+    expect(label1BoldOptions.renderMark).toBeDefined();
+  });
+});

package/src/utils/speed-card-bg.test.ts

@@ -0,0 +1,46 @@
+import SpeedCardBg, { SpeedCardBg as namedExport } from "./speed-card-bg";
+
+describe("SpeedCardBg", () => {
+  it("returns a valid SVG string", () => {
+    const svg = SpeedCardBg();
+    expect(svg).toContain("<svg");
+    expect(svg).toContain("</svg>");
+    expect(svg).toContain('xmlns="http://www.w3.org/2000/svg"');
+  });
+
+  it("uses default color #24A76A when no argument provided", () => {
+    const svg = SpeedCardBg();
+    expect(svg).toContain('fill="#24A76A"');
+    expect(svg).not.toContain("${color}");
+  });
+
+  it("applies custom color to fill attributes", () => {
+    const svg = SpeedCardBg("#FF0000");
+    expect(svg).toContain('fill="#FF0000"');
+    expect(svg).not.toContain('fill="#24A76A"');
+  });
+
+  it("has correct SVG dimensions", () => {
+    const svg = SpeedCardBg();
+    expect(svg).toContain('width="684"');
+    expect(svg).toContain('height="107"');
+    expect(svg).toContain('viewBox="0 0 684 107"');
+  });
+
+  it("contains two path elements for the pinwheel", () => {
+    const svg = SpeedCardBg();
+    const pathMatches = svg.match(/<path /g);
+    expect(pathMatches).toHaveLength(2);
+  });
+
+  it("fills both paths with the provided color", () => {
+    const color = "#ABCDEF";
+    const svg = SpeedCardBg(color);
+    const fillMatches = svg.match(new RegExp(`fill="${color}"`, "g"));
+    expect(fillMatches).toHaveLength(2);
+  });
+
+  it("exports the same function as both default and named", () => {
+    expect(namedExport).toBe(SpeedCardBg);
+  });
+});