@windstream/react-shared-components 0.1.93 → 0.1.94

package/src/components/list/index.test.tsx

@@ -0,0 +1,166 @@
+import React from "react";
+import { List } from "./index";
+import { ListItem } from "./list-item";
+
+import { render, screen } from "@testing-library/react";
+
+import "@testing-library/jest-dom";
+
+describe("List", () => {
+  describe("Rendering", () => {
+    it("renders as ul by default", () => {
+      const { container } = render(<List />);
+      expect(container.querySelector("ul")).toBeInTheDocument();
+    });
+
+    it("renders as ol when type='ol'", () => {
+      const { container } = render(<List type="ol" />);
+      expect(container.querySelector("ol")).toBeInTheDocument();
+    });
+
+    it("has correct displayName", () => {
+      expect(List.displayName).toBe("List");
+    });
+
+    it("renders children content", () => {
+      render(
+        <List>
+          <li>Item 1</li>
+        </List>
+      );
+      expect(screen.getByText("Item 1")).toBeInTheDocument();
+    });
+
+    it("renders items from items prop", () => {
+      const items = [
+        { id: 1, content: "First" },
+        { id: 2, content: "Second" },
+      ];
+      render(<List items={items} />);
+      expect(screen.getByText("First")).toBeInTheDocument();
+      expect(screen.getByText("Second")).toBeInTheDocument();
+    });
+
+    it("renders nothing when items is empty", () => {
+      const { container } = render(<List items={[]} />);
+      expect(container.querySelector("ul")?.children).toHaveLength(0);
+    });
+
+    it("uses renderItem when provided", () => {
+      const items = [
+        { id: 1, content: "First" },
+        { id: 2, content: "Second" },
+      ];
+      const renderItem = (item: any, index: number) => (
+        <li key={index} data-testid={`custom-${index}`}>
+          Custom: {item.content}
+        </li>
+      );
+      render(<List items={items} renderItem={renderItem} />);
+      expect(screen.getByText("Custom: First")).toBeInTheDocument();
+      expect(screen.getByTestId("custom-0")).toBeInTheDocument();
+    });
+  });
+
+  describe("Variants", () => {
+    it("applies unstyled variant with no extra classes", () => {
+      const { container } = render(<List variant="unstyled" />);
+      const el = container.querySelector("ul");
+      expect(el?.className).toContain("list--unstyled");
+    });
+
+    it("applies default variant classes for ul", () => {
+      const { container } = render(<List variant="default" />);
+      const el = container.querySelector("ul");
+      expect(el?.className).toContain("list--default");
+      expect(el?.className).toContain("list-disc");
+    });
+
+    it("applies default variant classes for ol", () => {
+      const { container } = render(<List type="ol" variant="default" />);
+      const el = container.querySelector("ol");
+      expect(el?.className).toContain("list-decimal");
+    });
+  });
+
+  describe("Props", () => {
+    it("applies custom className", () => {
+      const { container } = render(<List className="my-list" />);
+      expect(container.querySelector("ul")?.className).toContain("my-list");
+    });
+
+    it("applies inline style", () => {
+      const { container } = render(<List style={{ color: "blue" }} />);
+      expect(container.querySelector("ul")?.style.color).toBe("blue");
+    });
+
+    it("forwards ref to ul element", () => {
+      const ref = React.createRef<HTMLUListElement>();
+      render(<List ref={ref} />);
+      expect(ref.current).toBeInstanceOf(HTMLUListElement);
+    });
+
+    it("forwards ref to ol element", () => {
+      const ref = React.createRef<HTMLOListElement>();
+      render(<List ref={ref} type="ol" />);
+      expect(ref.current).toBeInstanceOf(HTMLOListElement);
+    });
+
+    it("passes item className to ListItem", () => {
+      const items = [{ id: 1, content: "Item", className: "item-class" }];
+      render(<List items={items} />);
+      const li = screen.getByText("Item");
+      expect(li.className).toContain("item-class");
+    });
+  });
+});
+
+describe("ListItem", () => {
+  it("renders children content", () => {
+    render(<ListItem>Hello</ListItem>);
+    expect(screen.getByText("Hello")).toBeInTheDocument();
+  });
+
+  it("has correct displayName", () => {
+    expect(ListItem.displayName).toBe("ListItem");
+  });
+
+  it("renders as li element", () => {
+    render(<ListItem>Item</ListItem>);
+    expect(screen.getByText("Item").tagName).toBe("LI");
+  });
+
+  it("applies custom className", () => {
+    render(<ListItem className="custom">Item</ListItem>);
+    expect(screen.getByText("Item").className).toContain("custom");
+  });
+
+  it("applies unstyled variant", () => {
+    render(<ListItem variant="unstyled">Item</ListItem>);
+    const el = screen.getByText("Item");
+    expect(el.className).toContain("list-item--unstyled");
+  });
+
+  it("applies default variant classes", () => {
+    render(<ListItem variant="default">Item</ListItem>);
+    const el = screen.getByText("Item");
+    expect(el.className).toContain("list-item--default");
+    expect(el.className).toContain("mb-1");
+  });
+
+  it("applies inline style", () => {
+    render(<ListItem style={{ color: "green" }}>Item</ListItem>);
+    expect(screen.getByText("Item").style.color).toBe("green");
+  });
+
+  it("forwards ref to li element", () => {
+    const ref = React.createRef<HTMLLIElement>();
+    render(<ListItem ref={ref}>Item</ListItem>);
+    expect(ref.current).toBeInstanceOf(HTMLLIElement);
+  });
+
+  it("passes additional HTML attributes", () => {
+    render(<ListItem data-testid="li-item">Item</ListItem>);
+    expect(screen.getByTestId("li-item")).toBeInTheDocument();
+  });
+});

package/src/components/list/index.tsx

@@ -1,88 +1,88 @@
-"use client";
-
-import React, { forwardRef } from "react";
-import { cx } from "../../utils/cx";
-import { ListItem, ListItemProps } from "./list-item";
-import { ListProps } from "./types";
-
-export const List = forwardRef<HTMLUListElement | HTMLOListElement, ListProps>(
-  (
-    {
-      type = "ul",
-      items,
-      className = "",
-      renderItem,
-      children,
-      variant = "unstyled",
-      style,
-      ...props
-    },
-    ref
-  ) => {
-    // Get Tailwind classes for different variants
-    const getVariantClasses = () => {
-      if (variant === "unstyled") {
-        return "";
-      }
-
-      // TODO: Add styles based on the figma design for all variants
-      const baseClasses = "m-0 p-0";
-      const typeClasses =
-        type === "ol" ? "pl-6 list-decimal" : "pl-5 list-disc";
-
-      return `${baseClasses} ${typeClasses}`;
-    };
-
-    const tailwindClasses = getVariantClasses();
-    const combinedClassName = cx(
-      tailwindClasses,
-      `list--${type}`,
-      `list--${variant}`,
-      className
-    );
-
-    // Render items if provided
-    const renderItems = () => {
-      if (!items || items.length === 0) return null;
-
-      return items.map((item, index) => {
-        if (renderItem) {
-          return renderItem(item, index);
-        }
-
-        return (
-          <ListItem
-            key={item.id || index}
-            className={item.className}
-            variant={variant}
-          >
-            {item.content}
-          </ListItem>
-        );
-      });
-    };
-
-    const content = children || renderItems();
-
-    // Create props object to avoid duplication
-    const listProps = {
-      className: combinedClassName,
-      style,
-      ...props,
-      children: content,
-    };
-
-    // Return appropriate list type with conditional rendering for proper TypeScript inference
-    if (type === "ol") {
-      return <ol {...listProps} ref={ref as React.Ref<HTMLOListElement>} />;
-    }
-
-    return <ul {...listProps} ref={ref as React.Ref<HTMLUListElement>} />;
-  }
-);
-
-List.displayName = "List";
-
-export { ListItem };
-
-export type { ListProps, ListItemProps };
+"use client";
+
+import React, { forwardRef } from "react";
+import { cx } from "../../utils/cx";
+import { ListItem, ListItemProps } from "./list-item";
+import { ListProps } from "./types";
+
+export const List = forwardRef<HTMLUListElement | HTMLOListElement, ListProps>(
+  (
+    {
+      type = "ul",
+      items,
+      className = "",
+      renderItem,
+      children,
+      variant = "unstyled",
+      style,
+      ...props
+    },
+    ref
+  ) => {
+    // Get Tailwind classes for different variants
+    const getVariantClasses = () => {
+      if (variant === "unstyled") {
+        return "";
+      }
+
+      // TODO: Add styles based on the figma design for all variants
+      const baseClasses = "m-0 p-0";
+      const typeClasses =
+        type === "ol" ? "pl-6 list-decimal" : "pl-5 list-disc";
+
+      return `${baseClasses} ${typeClasses}`;
+    };
+
+    const tailwindClasses = getVariantClasses();
+    const combinedClassName = cx(
+      tailwindClasses,
+      `list--${type}`,
+      `list--${variant}`,
+      className
+    );
+
+    // Render items if provided
+    const renderItems = () => {
+      if (!items || items.length === 0) return null;
+
+      return items.map((item, index) => {
+        if (renderItem) {
+          return renderItem(item, index);
+        }
+
+        return (
+          <ListItem
+            key={item.id || index}
+            className={item.className}
+            variant={variant}
+          >
+            {item.content}
+          </ListItem>
+        );
+      });
+    };
+
+    const content = children || renderItems();
+
+    // Create props object to avoid duplication
+    const listProps = {
+      className: combinedClassName,
+      style,
+      ...props,
+      children: content,
+    };
+
+    // Return appropriate list type with conditional rendering for proper TypeScript inference
+    if (type === "ol") {
+      return <ol {...listProps} ref={ref as React.Ref<HTMLOListElement>} />;
+    }
+
+    return <ul {...listProps} ref={ref as React.Ref<HTMLUListElement>} />;
+  }
+);
+
+List.displayName = "List";
+
+export { ListItem };
+
+export type { ListProps, ListItemProps };

package/src/components/list/list-item/index.tsx

@@ -1,38 +1,38 @@
-"use client";
-
-import { forwardRef } from "react";
-import { cx } from "../../../utils/cx";
-import { ListItemProps } from "./types";
-
-export const ListItem = forwardRef<HTMLLIElement, ListItemProps>(
-  (
-    { children, className = "", variant = "unstyled", style, ...props },
-    ref
-  ) => {
-    // Get Tailwind classes for different variants
-    const getVariantClasses = () => {
-      if (variant === "unstyled") return "";
-
-      // TODO: Add styles based on the figma design for all variants
-      return "mb-1 leading-6";
-    };
-
-    const tailwindClasses = getVariantClasses();
-    const combinedClassName = cx(
-      tailwindClasses,
-      "list-item",
-      `list-item--${variant}`,
-      className
-    );
-
-    return (
-      <li ref={ref} className={combinedClassName} style={style} {...props}>
-        {children}
-      </li>
-    );
-  }
-);
-
-ListItem.displayName = "ListItem";
-
-export type { ListItemProps };
+"use client";
+
+import { forwardRef } from "react";
+import { cx } from "../../../utils/cx";
+import { ListItemProps } from "./types";
+
+export const ListItem = forwardRef<HTMLLIElement, ListItemProps>(
+  (
+    { children, className = "", variant = "unstyled", style, ...props },
+    ref
+  ) => {
+    // Get Tailwind classes for different variants
+    const getVariantClasses = () => {
+      if (variant === "unstyled") return "";
+
+      // TODO: Add styles based on the figma design for all variants
+      return "mb-1 leading-6";
+    };
+
+    const tailwindClasses = getVariantClasses();
+    const combinedClassName = cx(
+      tailwindClasses,
+      "list-item",
+      `list-item--${variant}`,
+      className
+    );
+
+    return (
+      <li ref={ref} className={combinedClassName} style={style} {...props}>
+        {children}
+      </li>
+    );
+  }
+);
+
+ListItem.displayName = "ListItem";
+
+export type { ListItemProps };

package/src/components/list/list-item/types.ts

@@ -1,13 +1,13 @@
-import { CSSProperties, LiHTMLAttributes, ReactNode } from "react";
-import { ListVariant } from "../types";
-
-export interface ListItemProps extends LiHTMLAttributes<HTMLLIElement> {
-  /** Content to render inside the list item */
-  children: ReactNode;
-  /** Custom className for the list item */
-  className?: string;
-  /** Additional styling options */
-  variant?: ListVariant;
-  /** Custom styles */
-  style?: CSSProperties;
-}
+import { CSSProperties, LiHTMLAttributes, ReactNode } from "react";
+import { ListVariant } from "../types";
+
+export interface ListItemProps extends LiHTMLAttributes<HTMLLIElement> {
+  /** Content to render inside the list item */
+  children: ReactNode;
+  /** Custom className for the list item */
+  className?: string;
+  /** Additional styling options */
+  variant?: ListVariant;
+  /** Custom styles */
+  style?: CSSProperties;
+}

package/src/components/list/types.ts

@@ -1,29 +1,29 @@
-import { CSSProperties, HTMLAttributes, ReactNode } from "react";
-
-export type ListType = "ul" | "ol";
-export type ListVariant = "default" | "unstyled";
-
-export type ListItem = {
-  id: string | number;
-  content: ReactNode;
-  className?: string;
-  [key: string]: any;
-};
-
-export interface ListProps
-  extends Omit<HTMLAttributes<HTMLUListElement | HTMLOListElement>, "type"> {
-  /** List type - unordered (ul) or ordered (ol) */
-  type?: ListType;
-  /** Array of items to render */
-  items?: ListItem[];
-  /** Custom className for the list */
-  className?: string;
-  /** Custom item renderer function */
-  renderItem?: (item: ListItem, index: number) => ReactNode;
-  /** Children to render instead of items */
-  children?: ReactNode;
-  /** Additional styling options */
-  variant?: ListVariant;
-  /** Custom styles */
-  style?: CSSProperties;
-}
+import { CSSProperties, HTMLAttributes, ReactNode } from "react";
+
+export type ListType = "ul" | "ol";
+export type ListVariant = "default" | "unstyled";
+
+export type ListItem = {
+  id: string | number;
+  content: ReactNode;
+  className?: string;
+  [key: string]: any;
+};
+
+export interface ListProps
+  extends Omit<HTMLAttributes<HTMLUListElement | HTMLOListElement>, "type"> {
+  /** List type - unordered (ul) or ordered (ol) */
+  type?: ListType;
+  /** Array of items to render */
+  items?: ListItem[];
+  /** Custom className for the list */
+  className?: string;
+  /** Custom item renderer function */
+  renderItem?: (item: ListItem, index: number) => ReactNode;
+  /** Children to render instead of items */
+  children?: ReactNode;
+  /** Additional styling options */
+  variant?: ListVariant;
+  /** Custom styles */
+  style?: CSSProperties;
+}