@scrippsproduct/networks-ui-library 1.1.8 → 1.1.10-alpha.0

package/dist/components/StringList/StringList.test.js

@@ -0,0 +1,311 @@
+import { jsx as n } from "react/jsx-runtime";
+import { v as m, d as c, b as C, i as o, r as s, g as e, s as h } from "../../react.esm-DLSrfVwM.mjs";
+import { StringList as i } from "./StringList.js";
+const p = m.fn((t) => t.filter(Boolean).join(" "));
+m.mock("./../../utils/helpers", () => ({
+  classes: (t) => p(t)
+}));
+const r = m.fn((t) => t);
+m.mock("html-react-parser", () => ({
+  default: (t) => r(t)
+}));
+m.mock("./StringList.module.scss", () => ({
+  default: {
+    "string-list__pipe": "string-list__pipe",
+    "string-list--block": "string-list--block"
+  }
+}));
+c("StringList Component", () => {
+  C(() => {
+    p.mockClear(), r.mockClear();
+  }), c("Basic Rendering", () => {
+    o("renders a span element with string-list class", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Item 1", "Item 2"] })), a = t.querySelector("span.string-list");
+      e(a).toBeInTheDocument();
+    }), o("calls classes helper with appropriate array", () => {
+      s(/* @__PURE__ */ n(i, { list: ["Item 1"] })), e(p).toHaveBeenCalledWith(["string-list", ""]);
+    }), o("renders with default separatorType of comma", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"] }));
+      e(t.textContent).toContain(",");
+    }), o("renders with default makeBlock of false", () => {
+      s(/* @__PURE__ */ n(i, { list: ["A"] })), e(p).toHaveBeenCalledWith(["string-list", ""]);
+    });
+  }), c("List Filtering", () => {
+    o("filters out empty string values", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Item 1", "", "Item 2"] }));
+      e(t.textContent).toBe("Item 1, Item 2");
+    }), o("filters out undefined values", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Item 1", void 0, "Item 2"] }));
+      e(t.textContent).toBe("Item 1, Item 2");
+    }), o("filters out null values", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Item 1", null, "Item 2"] }));
+      e(t.textContent).toBe("Item 1, Item 2");
+    }), o("filters out multiple falsy values", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "", null, void 0, "B", "", "C"] }));
+      e(t.textContent).toBe("A, B, C");
+    }), o("returns empty fragment when list is empty", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [] }));
+      e(t.firstChild).toBeNull();
+    }), o("returns empty fragment when all items are filtered out", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["", null, void 0] }));
+      e(t.firstChild).toBeNull();
+    }), o("does not filter out 0 (falsy but valid number)", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [0, 1, 2] }));
+      e(t.textContent).toBe("0, 1, 2");
+    }), o("does not filter out false (not in filter condition)", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Item 1", "Item 2"] }));
+      e(t.textContent).toBe("Item 1, Item 2");
+    });
+  }), c("Separator Type - Comma", () => {
+    o("renders items separated by comma with space", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B", "C"], separatorType: "comma" }));
+      e(t.textContent).toBe("A, B, C");
+    }), o("renders first item without leading comma", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["First", "Second"], separatorType: "comma" }));
+      e(t.textContent).toMatch(/^First,/);
+    }), o("renders single item without comma", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Only"], separatorType: "comma" }));
+      e(t.textContent).toBe("Only"), e(t.textContent).not.toContain(",");
+    }), o("renders two items with one comma", () => {
+      var l;
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: "comma" })), a = (((l = t.textContent) == null ? void 0 : l.match(/,/g)) || []).length;
+      e(a).toBe(1);
+    }), o("renders multiple items with correct number of commas", () => {
+      var l;
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B", "C", "D", "E"], separatorType: "comma" })), a = (((l = t.textContent) == null ? void 0 : l.match(/,/g)) || []).length;
+      e(a).toBe(4);
+    }), o("does not render pipe separator with comma type", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: "comma" }));
+      e(t.textContent).not.toContain("|");
+    });
+  }), c("Separator Type - Pipe", () => {
+    o("renders items separated by pipe", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B", "C"], separatorType: "pipe" }));
+      e(t.textContent).toContain("|");
+    }), o("renders first item without leading pipe", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["First", "Second"], separatorType: "pipe" }));
+      e(t.textContent).toMatch(/^First/);
+    }), o("renders single item without pipe", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Only"], separatorType: "pipe" }));
+      e(t.textContent).toBe("Only"), e(t.textContent).not.toContain("|");
+    }), o("renders pipe with spaces around it", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: "pipe" }));
+      e(t.textContent).toContain(" | ");
+    }), o("applies string-list__pipe class to pipe separator span", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: "pipe" })), a = t.querySelector(".string-list__pipe");
+      e(a).toBeInTheDocument(), e(a == null ? void 0 : a.textContent).toBe(" | ");
+    }), o("renders correct number of pipe separators", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B", "C", "D"], separatorType: "pipe" })), a = t.querySelectorAll(".string-list__pipe");
+      e(a.length).toBe(3);
+    }), o("does not render comma with pipe type", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: "pipe" }));
+      e(t.textContent).not.toContain(",");
+    }), o("calls classes helper for each pipe separator", () => {
+      p.mockClear(), s(/* @__PURE__ */ n(i, { list: ["A", "B", "C"], separatorType: "pipe" })), e(p).toHaveBeenCalledTimes(3);
+    });
+  }), c("MakeBlock Prop", () => {
+    o("applies string-list--block class when makeBlock is true", () => {
+      s(/* @__PURE__ */ n(i, { makeBlock: !0, list: ["Item"] })), e(p).toHaveBeenCalledWith(["string-list", "string-list--block"]);
+    }), o("does not apply string-list--block class when makeBlock is false", () => {
+      s(/* @__PURE__ */ n(i, { list: ["Item"], makeBlock: !1 })), e(p).toHaveBeenCalledWith(["string-list", ""]);
+    }), o("does not apply string-list--block class when makeBlock is undefined (default)", () => {
+      s(/* @__PURE__ */ n(i, { list: ["Item"] })), e(p).toHaveBeenCalledWith(["string-list", ""]);
+    }), o("applies block class with comma separator", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { makeBlock: !0, list: ["A", "B"], separatorType: "comma" })), a = t.querySelector("span.string-list");
+      e(a == null ? void 0 : a.className).toContain("string-list--block");
+    }), o("applies block class with pipe separator", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { makeBlock: !0, list: ["A", "B"], separatorType: "pipe" })), a = t.querySelector("span.string-list");
+      e(a == null ? void 0 : a.className).toContain("string-list--block");
+    });
+  }), c("String Items with HTML", () => {
+    o("parses string items using html-react-parser", () => {
+      s(/* @__PURE__ */ n(i, { list: ["<b>Bold</b>", "Normal"] })), e(r).toHaveBeenCalledWith("<b>Bold</b>"), e(r).toHaveBeenCalledWith("Normal");
+    }), o("parses all string items in the list", () => {
+      r.mockClear(), s(/* @__PURE__ */ n(i, { list: ["A", "B", "C"] })), e(r).toHaveBeenCalledTimes(3);
+    }), o("parses first string item without separator", () => {
+      r.mockClear(), s(/* @__PURE__ */ n(i, { list: ["First", "Second"] })), e(r).toHaveBeenNthCalledWith(1, "First");
+    }), o("parses subsequent string items after separator", () => {
+      r.mockClear(), s(/* @__PURE__ */ n(i, { list: ["First", "Second"] })), e(r).toHaveBeenNthCalledWith(2, "Second");
+    }), o("handles special HTML characters in strings", () => {
+      s(/* @__PURE__ */ n(i, { list: ["<div>HTML</div>", "<span>More</span>"] })), e(r).toHaveBeenCalledWith("<div>HTML</div>"), e(r).toHaveBeenCalledWith("<span>More</span>");
+    });
+  }), c("JSX.Element Items", () => {
+    o("renders JSX elements without parsing", () => {
+      r.mockClear(), s(/* @__PURE__ */ n(i, { list: [/* @__PURE__ */ n("strong", { children: "Bold" })] })), e(r).not.toHaveBeenCalled();
+    }), o("renders JSX elements with comma separator", () => {
+      const t = /* @__PURE__ */ n("em", { children: "Italic" }), a = /* @__PURE__ */ n("strong", { children: "Bold" }), { container: l } = s(/* @__PURE__ */ n(i, { list: [t, a], separatorType: "comma" }));
+      e(l.querySelector("em")).toBeInTheDocument(), e(l.querySelector("strong")).toBeInTheDocument(), e(l.textContent).toContain(",");
+    }), o("renders JSX elements with pipe separator", () => {
+      const t = /* @__PURE__ */ n("span", { children: "One" }), a = /* @__PURE__ */ n("span", { children: "Two" }), { container: l } = s(/* @__PURE__ */ n(i, { list: [t, a], separatorType: "pipe" }));
+      e(l.querySelectorAll("span").length).toBeGreaterThan(2), e(l.textContent).toContain("|");
+    }), o("mixes string and JSX elements", () => {
+      r.mockClear(), s(/* @__PURE__ */ n(i, { list: ["String", /* @__PURE__ */ n("strong", { children: "Bold" }), "Another"] })), e(r).toHaveBeenCalledWith("String"), e(r).toHaveBeenCalledWith("Another"), e(r).toHaveBeenCalledTimes(2);
+    }), o("renders first item as JSX without separator", () => {
+      s(/* @__PURE__ */ n(i, { list: [/* @__PURE__ */ n("span", { "data-testid": "first", children: "First" }), "Second"] })), e(h.getByTestId("first")).toBeInTheDocument();
+    });
+  }), c("Number Items", () => {
+    o("renders number items directly without parsing", () => {
+      r.mockClear();
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [1, 2, 3] }));
+      e(r).not.toHaveBeenCalled(), e(t.textContent).toBe("1, 2, 3");
+    }), o("renders 0 as a valid number", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [0] }));
+      e(t.textContent).toBe("0");
+    }), o("renders negative numbers", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [-1, -5, -10] }));
+      e(t.textContent).toBe("-1, -5, -10");
+    }), o("renders decimal numbers", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [1.5, 2.75, 3.14] }));
+      e(t.textContent).toBe("1.5, 2.75, 3.14");
+    }), o("mixes numbers and strings with comma separator", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [1, "Two", 3, "Four"], separatorType: "comma" }));
+      e(t.textContent).toBe("1, Two, 3, Four");
+    }), o("mixes numbers and strings with pipe separator", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [1, "Two", 3], separatorType: "pipe" }));
+      e(t.textContent).toContain("1"), e(t.textContent).toContain("Two"), e(t.textContent).toContain("3"), e(t.textContent).toContain("|");
+    }), o("renders large numbers", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [1e6, 999999999] }));
+      e(t.textContent).toBe("1000000, 999999999");
+    });
+  }), c("Mixed Content Types", () => {
+    o("renders strings, numbers, and JSX together with comma", () => {
+      const t = /* @__PURE__ */ n("strong", { children: "Bold" }), { container: a } = s(/* @__PURE__ */ n(i, { list: ["String", 42, t], separatorType: "comma" }));
+      e(a.textContent).toContain("String"), e(a.textContent).toContain("42"), e(a.querySelector("strong")).toBeInTheDocument();
+    }), o("renders strings, numbers, and JSX together with pipe", () => {
+      const t = /* @__PURE__ */ n("em", { children: "Italic" }), { container: a } = s(/* @__PURE__ */ n(i, { list: [100, t, "Text"], separatorType: "pipe" }));
+      e(a.textContent).toContain("100"), e(a.querySelector("em")).toBeInTheDocument(), e(a.textContent).toContain("Text");
+    }), o("filters falsy values from mixed content", () => {
+      const t = /* @__PURE__ */ n("span", { children: "Elem" }), { container: a } = s(/* @__PURE__ */ n(i, { list: ["A", null, 1, void 0, t, "", 2] }));
+      e(a.textContent).toContain("A"), e(a.textContent).toContain("1"), e(a.querySelector("span")).toBeInTheDocument(), e(a.textContent).toContain("2");
+    }), o("parses only string items in mixed list", () => {
+      r.mockClear(), s(/* @__PURE__ */ n(i, { list: ["String1", 5, /* @__PURE__ */ n("div", { children: "Div" }), "String2"] })), e(r).toHaveBeenCalledWith("String1"), e(r).toHaveBeenCalledWith("String2"), e(r).toHaveBeenCalledTimes(2);
+    });
+  }), c("Fragment Keys", () => {
+    o("renders items within Fragment elements", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B", "C"] }));
+      e(t.textContent).toBe("A, B, C");
+    }), o("generates unique keys for fragments (via random)", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B", "C", "D", "E"] }));
+      e(t.textContent).toBe("A, B, C, D, E");
+    });
+  }), c("Edge Cases", () => {
+    o("handles very long list", () => {
+      const t = Array.from({ length: 100 }, (l, d) => `Item ${d + 1}`), { container: a } = s(/* @__PURE__ */ n(i, { list: t }));
+      e(a.textContent).toContain("Item 1"), e(a.textContent).toContain("Item 100");
+    }), o("handles list with single item", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Single"] }));
+      e(t.textContent).toBe("Single");
+    }), o("handles empty strings mixed with valid strings", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "", "B", "", "", "C"] }));
+      e(t.textContent).toBe("A, B, C");
+    }), o("handles special characters in strings", () => {
+      s(/* @__PURE__ */ n(i, { list: ["<special>", '"quotes"', "&amp;"] })), e(r).toHaveBeenCalledWith("<special>"), e(r).toHaveBeenCalledWith('"quotes"'), e(r).toHaveBeenCalledWith("&amp;");
+    }), o("handles unicode characters", () => {
+      s(/* @__PURE__ */ n(i, { list: ["😀", "你好", "Привет"] })), e(r).toHaveBeenCalledWith("😀"), e(r).toHaveBeenCalledWith("你好"), e(r).toHaveBeenCalledWith("Привет");
+    }), o("handles very long strings", () => {
+      const t = "A".repeat(1e3), { container: a } = s(/* @__PURE__ */ n(i, { list: [t] }));
+      e(a.textContent).toBe(t);
+    }), o("handles numbers with scientific notation", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [1e5, 2500] }));
+      e(t.textContent).toContain("100000"), e(t.textContent).toContain("2500");
+    }), o("returns empty fragment for list with only filtered items", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: [null, void 0, "", null] }));
+      e(t.firstChild).toBeNull();
+    });
+  }), c("CSS Classes", () => {
+    o("always applies string-list base class", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A"] }));
+      e(t.querySelector(".string-list")).toBeInTheDocument();
+    }), o("applies both base and block classes when makeBlock is true", () => {
+      p.mockClear(), s(/* @__PURE__ */ n(i, { makeBlock: !0, list: ["A"] })), e(p).toHaveBeenCalledWith(["string-list", "string-list--block"]);
+    }), o("pipe separator has correct classes", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: "pipe" })), a = t.querySelector(".string-list__pipe");
+      e(a).toHaveAttribute("class", "string-list__pipe string-list__pipe");
+    }), o("calls classes helper for pipe separators", () => {
+      p.mockClear(), s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: "pipe" })), e(p).toHaveBeenCalledWith(["string-list__pipe", "string-list__pipe"]);
+    });
+  }), c("Type Safety", () => {
+    o("accepts array of strings", () => {
+      const t = ["A", "B", "C"], { container: a } = s(/* @__PURE__ */ n(i, { list: t }));
+      e(a.textContent).toBe("A, B, C");
+    }), o("accepts array of numbers", () => {
+      const t = [1, 2, 3], { container: a } = s(/* @__PURE__ */ n(i, { list: t }));
+      e(a.textContent).toBe("1, 2, 3");
+    }), o("accepts array of JSX elements", () => {
+      const t = [/* @__PURE__ */ n("span", { children: "A" }, "1"), /* @__PURE__ */ n("span", { children: "B" }, "2")], { container: a } = s(/* @__PURE__ */ n(i, { list: t }));
+      e(a.querySelectorAll("span").length).toBeGreaterThan(0);
+    }), o("accepts array with mixed types", () => {
+      const t = ["A", 1, /* @__PURE__ */ n("em", { children: "B" }, "1"), null], { container: a } = s(/* @__PURE__ */ n(i, { list: t }));
+      e(a.textContent).toContain("A"), e(a.textContent).toContain("1");
+    }), o('accepts separatorType as "comma"', () => {
+      const t = "comma", { container: a } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: t }));
+      e(a.textContent).toContain(",");
+    }), o('accepts separatorType as "pipe"', () => {
+      const t = "pipe", { container: a } = s(/* @__PURE__ */ n(i, { list: ["A", "B"], separatorType: t }));
+      e(a.textContent).toContain("|");
+    }), o("accepts makeBlock as boolean", () => {
+      s(/* @__PURE__ */ n(i, { list: ["A"], makeBlock: !0 })), e(p).toHaveBeenCalledWith(["string-list", "string-list--block"]);
+    });
+  }), c("Default Values", () => {
+    o("uses comma separator by default", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["A", "B"] }));
+      e(t.textContent).toBe("A, B");
+    }), o("uses makeBlock false by default", () => {
+      s(/* @__PURE__ */ n(i, { list: ["A"] })), e(p).toHaveBeenCalledWith(["string-list", ""]);
+    }), o("works with only required list prop", () => {
+      const { container: t } = s(/* @__PURE__ */ n(i, { list: ["Item"] }));
+      e(t.textContent).toBe("Item");
+    });
+  }), c("Integration Tests", () => {
+    o("renders complete comma-separated list with block styling", () => {
+      const { container: t } = s(
+        /* @__PURE__ */ n(
+          i,
+          {
+            makeBlock: !0,
+            list: ["Drama", "Comedy", "Action"],
+            separatorType: "comma"
+          }
+        )
+      );
+      e(t.textContent).toBe("Drama, Comedy, Action"), e(t.querySelector(".string-list--block")).toBeInTheDocument();
+    }), o("renders complete pipe-separated list with mixed content", () => {
+      const { container: t } = s(
+        /* @__PURE__ */ n(
+          i,
+          {
+            list: ["TV Series", "PG-13", /* @__PURE__ */ n("strong", { children: "120 min" }, "1")],
+            separatorType: "pipe"
+          }
+        )
+      );
+      e(t.textContent).toContain("TV Series"), e(t.textContent).toContain("PG-13"), e(t.querySelector("strong")).toBeInTheDocument(), e(t.querySelectorAll(".string-list__pipe").length).toBe(2);
+    }), o("filters and renders mixed content with comma separator", () => {
+      var l;
+      const { container: t } = s(
+        /* @__PURE__ */ n(
+          i,
+          {
+            list: ["Item 1", null, 2, void 0, /* @__PURE__ */ n("span", { children: "Elem" }, "1"), ""],
+            separatorType: "comma"
+          }
+        )
+      );
+      e(t.textContent).toContain("Item 1"), e(t.textContent).toContain("2"), e(t.querySelector("span")).toBeInTheDocument();
+      const a = (((l = t.textContent) == null ? void 0 : l.match(/,/g)) || []).length;
+      e(a).toBe(2);
+    }), o("handles complete real-world scenario: rating and time", () => {
+      const t = [2020, "PG-13", "2h 5m"], { container: a } = s(
+        /* @__PURE__ */ n(
+          i,
+          {
+            makeBlock: !0,
+            list: t,
+            separatorType: "pipe"
+          }
+        )
+      );
+      e(a.textContent).toContain("2020"), e(a.textContent).toContain("PG-13"), e(a.textContent).toContain("2h 5m"), e(a.querySelector(".string-list--block")).toBeInTheDocument();
+    });
+  });
+});

package/dist/components/TabContent/TabContent.js

@@ -1,5 +1,5 @@
 import { jsx as a } from "react/jsx-runtime";
-import { p as o } from "../../index-VjANCDXC.mjs";
+import { p as o } from "../../index-06PEPfBQ.mjs";
 function p({
   content: r,
   classname: t

package/dist/components/TabContent/TabContent.test.js

@@ -0,0 +1,274 @@
+import { jsx as e, jsxs as m, Fragment as p } from "react/jsx-runtime";
+import { v as h, d as i, b as u, i as a, r as s, g as n } from "../../react.esm-DLSrfVwM.mjs";
+import { TabContent as c } from "./TabContent.js";
+const l = h.fn((t) => t);
+h.mock("html-react-parser", () => ({
+  default: (t) => l(t)
+}));
+i("TabContent Component", () => {
+  u(() => {
+    l.mockClear();
+  }), i("Basic Rendering", () => {
+    a("renders tab-content custom element", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: "Test content" }));
+      n(t.querySelector("tab-content")).toBeInTheDocument();
+    }), a("renders content inside tab-content element", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: "Test content" })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toContain("Test content");
+    }), a("returns JSX.Element", () => {
+      const t = s(/* @__PURE__ */ e(c, { content: "Test" }));
+      n(t.container.firstChild).toBeInstanceOf(HTMLElement);
+    });
+  }), i("String Content", () => {
+    a("parses string content using html-react-parser", () => {
+      s(/* @__PURE__ */ e(c, { content: "Plain text" })), n(l).toHaveBeenCalledWith("Plain text");
+    }), a("parses HTML string content", () => {
+      s(/* @__PURE__ */ e(c, { content: "<b>Bold text</b>" })), n(l).toHaveBeenCalledWith("<b>Bold text</b>");
+    }), a("parses complex HTML strings", () => {
+      const t = "<div><p>Paragraph</p><span>Span</span></div>";
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("parses strings with special characters", () => {
+      const t = `Special & characters < > " '`;
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("parses empty string", () => {
+      s(/* @__PURE__ */ e(c, { content: "" })), n(l).toHaveBeenCalledWith("");
+    }), a("parses strings with HTML entities", () => {
+      const t = "&amp; &lt; &gt; &copy;";
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("parses very long strings", () => {
+      const t = "A".repeat(1e3);
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("parses strings with newlines", () => {
+      const t = `Line 1
+Line 2
+Line 3`;
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    });
+  }), i("JSX.Element Content", () => {
+    a("does not parse JSX.Element content", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: /* @__PURE__ */ e("div", { children: "JSX Element" }) })), n(l).not.toHaveBeenCalled();
+    }), a("renders JSX.Element content directly", () => {
+      const t = /* @__PURE__ */ e("div", { "data-testid": "jsx-content", children: "JSX Content" }), { container: o } = s(/* @__PURE__ */ e(c, { content: t })), r = o.querySelector("tab-content");
+      n(r == null ? void 0 : r.querySelector('[data-testid="jsx-content"]')).toBeInTheDocument();
+    }), a("renders complex JSX structures", () => {
+      const t = /* @__PURE__ */ m("div", { children: [
+        /* @__PURE__ */ e("h1", { children: "Title" }),
+        /* @__PURE__ */ e("p", { children: "Paragraph" }),
+        /* @__PURE__ */ m("ul", { children: [
+          /* @__PURE__ */ e("li", { children: "Item 1" }),
+          /* @__PURE__ */ e("li", { children: "Item 2" })
+        ] })
+      ] }), { container: o } = s(/* @__PURE__ */ e(c, { content: t })), r = o.querySelector("tab-content");
+      n(r == null ? void 0 : r.querySelector("h1")).toBeInTheDocument(), n(r == null ? void 0 : r.querySelector("ul")).toBeInTheDocument();
+    }), a("renders JSX with props", () => {
+      const t = /* @__PURE__ */ e("button", { disabled: !0, onClick: () => {
+      }, children: "Click me" }), { container: o } = s(/* @__PURE__ */ e(c, { content: t })), r = o.querySelector("button");
+      n(r).toBeDisabled();
+    }), a("renders nested JSX components", () => {
+      const o = /* @__PURE__ */ e("div", { children: /* @__PURE__ */ e(() => /* @__PURE__ */ e("span", { children: "Nested" }), {}) }), { container: r } = s(/* @__PURE__ */ e(c, { content: o }));
+      n(r.textContent).toContain("Nested");
+    });
+  }), i("Number Content", () => {
+    a("does not parse number content", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: 42 })), n(l).not.toHaveBeenCalled();
+    }), a("renders number content directly", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: 42 })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("42");
+    }), a("renders zero", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: 0 })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("0");
+    }), a("renders negative numbers", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: -100 })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("-100");
+    }), a("renders decimal numbers", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: 3.14159 })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("3.14159");
+    });
+  }), i("Boolean Content", () => {
+    a("does not parse boolean true", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: !0 })), n(l).not.toHaveBeenCalled();
+    }), a("does not parse boolean false", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: !1 })), n(l).not.toHaveBeenCalled();
+    }), a("renders boolean true as empty", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: !0 })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("");
+    }), a("renders boolean false as empty", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: !1 })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("");
+    });
+  }), i("Null and Undefined Content", () => {
+    a("does not parse null content", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: null })), n(l).not.toHaveBeenCalled();
+    }), a("does not parse undefined content", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: void 0 })), n(l).not.toHaveBeenCalled();
+    }), a("renders null content as empty", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: null })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("");
+    }), a("renders undefined content as empty", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: void 0 })), o = t.querySelector("tab-content");
+      n(o == null ? void 0 : o.textContent).toBe("");
+    });
+  }), i("Array Content", () => {
+    a("does not parse array content", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: [/* @__PURE__ */ e("div", { children: "Item 1" }, "1"), /* @__PURE__ */ e("div", { children: "Item 2" }, "2")] })), n(l).not.toHaveBeenCalled();
+    }), a("renders array of JSX elements", () => {
+      const t = [
+        /* @__PURE__ */ e("div", { "data-testid": "item-1", children: "Item 1" }, "1"),
+        /* @__PURE__ */ e("div", { "data-testid": "item-2", children: "Item 2" }, "2")
+      ], { container: o } = s(/* @__PURE__ */ e(c, { content: t })), r = o.querySelector("tab-content");
+      n(r == null ? void 0 : r.querySelector('[data-testid="item-1"]')).toBeInTheDocument(), n(r == null ? void 0 : r.querySelector('[data-testid="item-2"]')).toBeInTheDocument();
+    }), a("renders mixed array content", () => {
+      const t = [
+        "String",
+        /* @__PURE__ */ e("span", { children: "Element" }, "1"),
+        42
+      ], { container: o } = s(/* @__PURE__ */ e(c, { content: t })), r = o.querySelector("tab-content");
+      n(r == null ? void 0 : r.textContent).toContain("String"), n(r == null ? void 0 : r.textContent).toContain("Element"), n(r == null ? void 0 : r.textContent).toContain("42");
+    });
+  }), i("Classname Prop", () => {
+    a("applies classname when provided", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { classname: "custom-class", content: "Test" })), o = t.querySelector("tab-content");
+      n(o).toHaveAttribute("class", "custom-class");
+    }), a("does not render class attribute when classname is undefined", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: "Test" })), o = t.querySelector("tab-content");
+      n(o).not.toHaveAttribute("class");
+    }), a("applies empty string as classname", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { classname: "", content: "Test" })), o = t.querySelector("tab-content");
+      n(o).toHaveAttribute("class", "");
+    }), a("applies multiple classes", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { classname: "class-one class-two", content: "Test" })), o = t.querySelector("tab-content");
+      n(o).toHaveAttribute("class", "class-one class-two");
+    }), a("applies classname with special characters", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { classname: "my-class_123", content: "Test" })), o = t.querySelector("tab-content");
+      n(o).toHaveAttribute("class", "my-class_123");
+    }), a("applies classname with hyphen and underscore", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { classname: "btn-primary_active", content: "Test" })), o = t.querySelector("tab-content");
+      n(o).toHaveAttribute("class", "btn-primary_active");
+    });
+  }), i("Type Checking", () => {
+    a("uses typeof to check for string content", () => {
+      const { container: t } = s(/* @__PURE__ */ e(c, { content: "string" })), o = t.querySelector("tab-content");
+      n(o).toBeInTheDocument(), n(l).toHaveBeenCalledWith("string");
+    }), a("correctly identifies non-string React.ReactNode", () => {
+      l.mockClear(), s(/* @__PURE__ */ e(c, { content: /* @__PURE__ */ e("div", { children: "Not a string" }) })), n(l).not.toHaveBeenCalled();
+    }), a("handles content type changes", () => {
+      const { rerender: t } = s(/* @__PURE__ */ e(c, { content: "string content" }));
+      n(l).toHaveBeenCalledWith("string content"), l.mockClear(), t(/* @__PURE__ */ e(c, { content: /* @__PURE__ */ e("div", { children: "JSX content" }) })), n(l).not.toHaveBeenCalled();
+    });
+  }), i("Edge Cases", () => {
+    a("handles whitespace-only strings", () => {
+      s(/* @__PURE__ */ e(c, { content: "   " })), n(l).toHaveBeenCalledWith("   ");
+    }), a("handles strings with only newlines", () => {
+      s(/* @__PURE__ */ e(c, { content: `
+
+
+` })), n(l).toHaveBeenCalledWith(`
+
+
+`);
+    }), a("handles strings with tabs", () => {
+      const t = "		Tabbed		";
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("handles unicode content", () => {
+      const t = "😀 Hello 世界 Привет";
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("handles malformed HTML in strings", () => {
+      const t = "<div><p>Unclosed tags";
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("handles self-closing tags in strings", () => {
+      const t = '<img src="test.jpg" /><br />';
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("handles script tags in strings", () => {
+      const t = '<script>alert("test")<\/script>';
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("handles inline styles in HTML strings", () => {
+      const t = '<div style="color: red;">Styled</div>';
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("handles data attributes in HTML strings", () => {
+      const t = '<div data-test="value" data-id="123">Test</div>';
+      s(/* @__PURE__ */ e(c, { content: t })), n(l).toHaveBeenCalledWith(t);
+    });
+  }), i("Type Safety", () => {
+    a("accepts string as React.ReactNode", () => {
+      const t = "String content";
+      n(() => s(/* @__PURE__ */ e(c, { content: t }))).not.toThrow();
+    }), a("accepts JSX.Element as React.ReactNode", () => {
+      const t = /* @__PURE__ */ e("div", { children: "Element" });
+      n(() => s(/* @__PURE__ */ e(c, { content: t }))).not.toThrow();
+    }), a("accepts number as React.ReactNode", () => {
+      n(() => s(/* @__PURE__ */ e(c, { content: 42 }))).not.toThrow();
+    }), a("accepts null as React.ReactNode", () => {
+      n(() => s(/* @__PURE__ */ e(c, { content: null }))).not.toThrow();
+    }), a("accepts undefined as React.ReactNode", () => {
+      n(() => s(/* @__PURE__ */ e(c, { content: void 0 }))).not.toThrow();
+    }), a("accepts array as React.ReactNode", () => {
+      const t = [/* @__PURE__ */ e("div", { children: "Item" }, "1")];
+      n(() => s(/* @__PURE__ */ e(c, { content: t }))).not.toThrow();
+    }), a("accepts optional classname prop", () => {
+      n(() => s(/* @__PURE__ */ e(c, { content: "Test" }))).not.toThrow(), n(() => s(/* @__PURE__ */ e(c, { classname: "class", content: "Test" }))).not.toThrow();
+    }), a("accepts empty string as classname", () => {
+      n(() => s(/* @__PURE__ */ e(c, { classname: "", content: "Test" }))).not.toThrow();
+    }), a("accepts string as classname", () => {
+      const t = "my-class";
+      n(() => s(/* @__PURE__ */ e(c, { classname: t, content: "Test" }))).not.toThrow();
+    });
+  }), i("Integration Tests", () => {
+    a("renders string content with classname", () => {
+      const { container: t } = s(
+        /* @__PURE__ */ e(c, { classname: "tab-panel", content: "<p>Parsed HTML</p>" })
+      ), o = t.querySelector("tab-content");
+      n(o).toHaveAttribute("class", "tab-panel"), n(l).toHaveBeenCalledWith("<p>Parsed HTML</p>");
+    }), a("renders JSX content with classname", () => {
+      const t = /* @__PURE__ */ e("div", { "data-testid": "content", children: "JSX Content" }), { container: o } = s(
+        /* @__PURE__ */ e(c, { classname: "active-tab", content: t })
+      ), r = o.querySelector("tab-content");
+      n(r).toHaveAttribute("class", "active-tab"), n(r == null ? void 0 : r.querySelector('[data-testid="content"]')).toBeInTheDocument(), n(l).not.toHaveBeenCalled();
+    }), a("switches between string and JSX content", () => {
+      const { container: t, rerender: o } = s(
+        /* @__PURE__ */ e(c, { classname: "panel", content: "String" })
+      );
+      let r = t.querySelector("tab-content");
+      n(r == null ? void 0 : r.textContent).toContain("String"), n(l).toHaveBeenCalledWith("String"), l.mockClear(), o(/* @__PURE__ */ e(c, { classname: "panel", content: /* @__PURE__ */ e("span", { children: "JSX" }) })), r = t.querySelector("tab-content"), n(r == null ? void 0 : r.querySelector("span")).toBeInTheDocument(), n(l).not.toHaveBeenCalled();
+    }), a("handles real-world HTML content", () => {
+      const t = `
+                <div class="article">
+                    <h1>Title</h1>
+                    <p>This is a <strong>bold</strong> paragraph.</p>
+                    <ul>
+                        <li>Item 1</li>
+                        <li>Item 2</li>
+                    </ul>
+                </div>
+            `;
+      s(/* @__PURE__ */ e(c, { classname: "article-tab", content: t })), n(l).toHaveBeenCalledWith(t);
+    }), a("handles real-world JSX content", () => {
+      const t = () => /* @__PURE__ */ m("div", { className: "video-list", children: [
+        /* @__PURE__ */ e("div", { className: "video-item", children: "Video 1" }),
+        /* @__PURE__ */ e("div", { className: "video-item", children: "Video 2" })
+      ] }), { container: o } = s(
+        /* @__PURE__ */ e(c, { classname: "videos-tab", content: /* @__PURE__ */ e(t, {}) })
+      ), r = o.querySelector("tab-content");
+      n(r).toHaveAttribute("class", "videos-tab"), n(r == null ? void 0 : r.querySelectorAll(".video-item").length).toBe(2);
+    }), a("preserves classname across content changes", () => {
+      const { container: t, rerender: o } = s(
+        /* @__PURE__ */ e(c, { classname: "persistent-class", content: "Content 1" })
+      );
+      let r = t.querySelector("tab-content");
+      n(r).toHaveAttribute("class", "persistent-class"), o(/* @__PURE__ */ e(c, { classname: "persistent-class", content: "Content 2" })), r = t.querySelector("tab-content"), n(r).toHaveAttribute("class", "persistent-class");
+    });
+  }), i("Content Type Combinations", () => {
+    a("handles Fragment content", () => {
+      const t = /* @__PURE__ */ m(p, { children: [
+        /* @__PURE__ */ e("div", { children: "Part 1" }),
+        /* @__PURE__ */ e("div", { children: "Part 2" })
+      ] }), { container: o } = s(/* @__PURE__ */ e(c, { content: t })), r = o.querySelector("tab-content");
+      n(r == null ? void 0 : r.textContent).toContain("Part 1"), n(r == null ? void 0 : r.textContent).toContain("Part 2");
+    }), a("handles component as content", () => {
+      const t = () => /* @__PURE__ */ e("div", { children: "Component Content" }), { container: o } = s(/* @__PURE__ */ e(c, { content: /* @__PURE__ */ e(t, {}) })), r = o.querySelector("tab-content");
+      n(r == null ? void 0 : r.textContent).toContain("Component Content");
+    }), a("handles content with event handlers", () => {
+      const t = h.fn(), o = /* @__PURE__ */ e("button", { onClick: t, children: "Click" }), { container: r } = s(/* @__PURE__ */ e(c, { content: o })), d = r.querySelector("button");
+      n(d).toBeInTheDocument(), d == null || d.click(), n(t).toHaveBeenCalled();
+    });
+  });
+});