@scrippsproduct/networks-ui-library 1.1.9 → 1.1.10

package/dist/components/GetAirdateWrapper/GetAirdateWrapper.test.js

@@ -0,0 +1,689 @@
+import { jsxs as y, jsx as i } from "react/jsx-runtime";
+import { v as I, d as E, b as _, a as k, i as m, r as l, w as s, g as t, s as p } from "../../react.esm-DLSrfVwM.mjs";
+import "../../index-BVxBrkZB.mjs";
+import { GetAirdateWrapper as n } from "./GetAirdateWrapper.js";
+const a = I.fn();
+I.mock("../../hooks/useGetUpcoming", () => ({
+  default: (u) => a(u)
+}));
+const T = I.fn();
+I.mock("../../utils/helpers", () => ({
+  convert12to24: (u) => T(u)
+}));
+I.mock("../AirDateFormatter", () => ({
+  default: ({ airdateStr: u, separatorType: o }) => /* @__PURE__ */ y(
+    "div",
+    {
+      "data-airdate": u,
+      "data-separator": o,
+      "data-testid": "air-date-formatter",
+      children: [
+        "AirDateFormatter: ",
+        u
+      ]
+    }
+  )
+}));
+I.mock("../StringList", () => ({
+  default: ({ list: u, separatorType: o }) => /* @__PURE__ */ i(
+    "div",
+    {
+      "data-items-count": u.length,
+      "data-separator": o,
+      "data-testid": "string-list",
+      children: u.map(
+        (r, c) => /* @__PURE__ */ i("div", { "data-testid": `string-list-item-${c}`, children: r }, c)
+      )
+    }
+  )
+}));
+E("GetAirdateWrapper", () => {
+  let u;
+  const o = "https://api.test.com/schedule", r = "test-network", c = (e) => ({
+    program_id: "12345",
+    title_name: "Test Episode",
+    start_date_parse: "2024-01-15",
+    start_time: "8:00 PM",
+    episode_number: "S01E05",
+    title_code: "TE0105",
+    program_class: "Series",
+    ...e
+  });
+  _(() => {
+    u = document.createElement("div"), u.id = "root", document.body.appendChild(u), I.clearAllMocks(), T.mockReturnValue("20:00"), a.mockResolvedValue([]);
+  }), k(() => {
+    document.body.removeChild(u);
+  }), E("Basic Rendering", () => {
+    m("should render empty fragment when no airdate data", async () => {
+      a.mockResolvedValue([]);
+      const { container: e } = l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      );
+      await s(() => {
+        t(e.firstChild).toBeNull();
+      });
+    }), m("should render empty fragment when programId is empty string", async () => {
+      const { container: e } = l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: ""
+          }
+        )
+      );
+      await s(() => {
+        t(e.firstChild).toBeNull();
+      });
+    }), m("should render AirDateFormatter when airdate is available", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.getByTestId("air-date-formatter")).toBeInTheDocument();
+      });
+    });
+  }), E("Hook Integration", () => {
+    m("should call useGetUpcoming with correct parameters", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345",
+            programType: "series"
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith({
+          programId: "12345",
+          programType: "series",
+          SCHEDULE_ENDPOINT: o,
+          NETWORK: r
+        });
+      });
+    }), m("should convert numeric programId to string", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: 12345
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({
+            programId: "12345"
+          })
+        );
+      });
+    }), m("should pass undefined programType when type is unknown", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345",
+            programType: "unknown"
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({
+            programType: void 0
+          })
+        );
+      });
+    }), m("should pass film programType correctly", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345",
+            programType: "film"
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({
+            programType: "film"
+          })
+        );
+      });
+    });
+  }), E("Airdate Formatting", () => {
+    m("should format airdate with date and converted time", async () => {
+      const e = c({
+        start_date_parse: "2024-01-15",
+        start_time: "8:00 PM"
+      });
+      a.mockResolvedValue([e]), T.mockReturnValue("20:00"), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("air-date-formatter");
+        t(d).toHaveAttribute("data-airdate", "2024-01-15 20:00");
+      });
+    }), m("should call convert12to24 with start_time", async () => {
+      const e = c({
+        start_time: "8:00 PM"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(T).toHaveBeenCalledWith("8:00 PM");
+      });
+    }), m("should pass separatorType to AirDateFormatter", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345",
+            separatorType: "line-break"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("air-date-formatter");
+        t(d).toHaveAttribute("data-separator", "line-break");
+      });
+    }), m("should use default pipe separator", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("air-date-formatter");
+        t(d).toHaveAttribute("data-separator", "pipe");
+      });
+    });
+  }), E("Episode Information", () => {
+    m("should not include episode when includeEpisode is false", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            includeEpisode: !1,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.queryByTestId("string-list")).not.toBeInTheDocument(), t(p.getByTestId("air-date-formatter")).toBeInTheDocument();
+      });
+    }), m("should include episode when includeEpisode is true", async () => {
+      const e = c({
+        episode_number: "S01E05",
+        title_name: "Test Episode"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.getByTestId("string-list")).toBeInTheDocument();
+      });
+    }), m("should format episode with episode_number when available", async () => {
+      const e = c({
+        episode_number: "S01E05",
+        title_name: "The Great Episode"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("string-list-item-1");
+        t(d).toHaveTextContent("S01E05: The Great Episode");
+      });
+    }), m("should use title_code when episode_number is not available", async () => {
+      const e = c({
+        episode_number: void 0,
+        title_code: "ABC0105",
+        title_name: "Episode Title"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("string-list-item-1");
+        t(d).toHaveTextContent("0105: Episode Title");
+      });
+    }), m("should render StringList with pipe separator when includeEpisode is true", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("string-list");
+        t(d).toHaveAttribute("data-separator", "pipe");
+      });
+    }), m("should include AirDateFormatter in StringList", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("string-list-item-0");
+        t(d.querySelector('[data-testid="air-date-formatter"]')).toBeInTheDocument();
+      });
+    });
+  }), E("DetermineSeasonEpStr Function", () => {
+    m("should extract numeric portion from title_code starting with letters", async () => {
+      const e = c({
+        episode_number: void 0,
+        title_code: "ABC0105",
+        title_name: "Test"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.getByTestId("string-list-item-1")).toHaveTextContent("0105: Test");
+      });
+    }), m("should handle title_code with multiple letter prefix", async () => {
+      const e = c({
+        episode_number: void 0,
+        title_code: "LONGPREFIX123",
+        title_name: "Test"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.getByTestId("string-list-item-1")).toHaveTextContent("123: Test");
+      });
+    }), m("should handle title_code starting with numbers", async () => {
+      const e = c({
+        episode_number: void 0,
+        title_code: "0105ABC",
+        title_name: "Test"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.getByTestId("string-list-item-1")).toHaveTextContent("0105ABC: Test");
+      });
+    });
+  }), E("Default Props", () => {
+    m("should use series as default programType", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({
+            programType: "series"
+          })
+        );
+      });
+    }), m("should use pipe as default separatorType", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("air-date-formatter");
+        t(d).toHaveAttribute("data-separator", "pipe");
+      });
+    }), m("should use false as default includeEpisode", async () => {
+      const e = c();
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.queryByTestId("string-list")).not.toBeInTheDocument();
+      });
+    });
+  }), E("Edge Cases", () => {
+    m("should handle empty results array", async () => {
+      a.mockResolvedValue([]);
+      const { container: e } = l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      );
+      await s(() => {
+        t(e.firstChild).toBeNull();
+      });
+    }), m("should handle multiple results and use first item", async () => {
+      const e = [
+        c({ start_date_parse: "2024-01-15", start_time: "8:00 PM" }),
+        c({ start_date_parse: "2024-01-20", start_time: "9:00 PM" })
+      ];
+      a.mockResolvedValue(e), T.mockReturnValue("20:00"), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("air-date-formatter");
+        t(d).toHaveAttribute("data-airdate", "2024-01-15 20:00");
+      });
+    }), m("should handle different separator types", async () => {
+      const e = c();
+      a.mockResolvedValue([e]);
+      const d = [
+        "pipe",
+        "line-break",
+        "single-line-break",
+        "none",
+        void 0
+      ];
+      for (const g of d) {
+        const { unmount: N } = l(
+          /* @__PURE__ */ i(
+            n,
+            {
+              NETWORK: r,
+              SCHEDULE_ENDPOINT: o,
+              programId: "12345",
+              separatorType: g
+            }
+          )
+        );
+        await s(() => {
+          const h = p.getByTestId("air-date-formatter");
+          t(h).toHaveAttribute("data-separator", g || "pipe");
+        }), N();
+      }
+    }), m("should handle missing title_name in episode", async () => {
+      const e = c({
+        episode_number: "S01E05",
+        title_name: ""
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("string-list-item-1");
+        t(d).toHaveTextContent("S01E05:");
+      });
+    }), m("should handle special characters in episode title", async () => {
+      const e = c({
+        episode_number: "S01E05",
+        title_name: "The Hero's Journey & Adventure"
+      });
+      a.mockResolvedValue([e]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("string-list-item-1");
+        t(d).toHaveTextContent("S01E05: The Hero's Journey & Adventure");
+      });
+    }), m("should handle zero as programId", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: 0
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({
+            programId: "0"
+          })
+        );
+      });
+    });
+  }), E("Integration", () => {
+    m("should render complete component with all features", async () => {
+      const e = c({
+        start_date_parse: "2024-01-15",
+        start_time: "8:00 PM",
+        episode_number: "S02E10",
+        title_name: "The Final Episode"
+      });
+      a.mockResolvedValue([e]), T.mockReturnValue("20:00"), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            includeEpisode: !0,
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: 12345,
+            programType: "series",
+            separatorType: "line-break"
+          }
+        )
+      ), await s(() => {
+        const d = p.getByTestId("string-list");
+        t(d).toBeInTheDocument(), t(d).toHaveAttribute("data-separator", "pipe"), t(d).toHaveAttribute("data-items-count", "2");
+      }), await s(() => {
+        const d = p.getByTestId("air-date-formatter");
+        t(d).toHaveAttribute("data-airdate", "2024-01-15 20:00"), t(d).toHaveAttribute("data-separator", "line-break");
+      }), await s(() => {
+        const d = p.getByTestId("string-list-item-1");
+        t(d).toHaveTextContent("S02E10: The Final Episode");
+      });
+    }), m("should update when results change", async () => {
+      const e = c({
+        start_date_parse: "2024-01-15",
+        start_time: "8:00 PM"
+      });
+      a.mockResolvedValue([e]), T.mockReturnValue("20:00");
+      const { rerender: d } = l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      );
+      await s(() => {
+        t(p.getByTestId("air-date-formatter")).toBeInTheDocument();
+      });
+      const g = c({
+        start_date_parse: "2024-01-20",
+        start_time: "9:00 PM"
+      });
+      a.mockResolvedValue([g]), T.mockReturnValue("21:00"), d(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345"
+          }
+        )
+      ), await s(() => {
+        t(p.getByTestId("air-date-formatter")).toBeInTheDocument();
+      });
+    });
+  }), E("Program Types", () => {
+    m("should handle series program type", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345",
+            programType: "series"
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({ programType: "series" })
+        );
+      });
+    }), m("should handle film program type", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345",
+            programType: "film"
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({ programType: "film" })
+        );
+      });
+    }), m("should handle unknown program type", async () => {
+      a.mockResolvedValue([]), l(
+        /* @__PURE__ */ i(
+          n,
+          {
+            NETWORK: r,
+            SCHEDULE_ENDPOINT: o,
+            programId: "12345",
+            programType: "unknown"
+          }
+        )
+      ), await s(() => {
+        t(a).toHaveBeenCalledWith(
+          t.objectContaining({ programType: void 0 })
+        );
+      });
+    });
+  });
+});

package/dist/components/GradientButton/GradientButton.d.ts

@@ -12,5 +12,5 @@ type GradientButtonProps = {
     hoverGradientEndColor?: string;
     [key: string]: unknown;
 };
-export declare function GradientButton({ type, label, onClick, varient, size, classname, href, gradientStartColor, gradientEndColor, ...attributes }: GradientButtonProps): JSX.Element;
+export declare function GradientButton({ type, label, onClick, varient, size, classname, href, gradientStartColor, gradientEndColor, hoverGradientStartColor, hoverGradientEndColor, ...attributes }: GradientButtonProps): JSX.Element;
 export default GradientButton;