@teselagen/ui 0.9.4 → 0.9.6

package/README.md

@@ -4,12 +4,16 @@ This library was generated with [Nx](https://nx.dev).
 
 ## Running unit tests
 
-Run `nx test ui` to execute the unit tests via bun test
+Run `bun test` from the root of the repo to execute all unit tests.
+
+## Running end-to-end tests locally
+
+Run `nx run ui:launch-e2e` to launch the Cypress test runner locally
 
 ## Installation (react)
 
 ```
-yarn add @teselagen/ove react react-dom
+yarn add @teselagen/ui react react-dom
 ```
 
 ## Running locally

package/index.cjs.js

@@ -37093,6 +37093,9 @@ const defaultValidators = {
   }, "dropdownMulti"),
   number: /* @__PURE__ */ __name((newVal, field) => {
     if (isValueEmpty(newVal) && !field.isRequired) return;
+    if (field.allowNaN && Number.isNaN(newVal)) {
+      return;
+    }
     if (isNaN(newVal) || !isNumber$1(newVal)) {
       return "Must be a number";
     }

package/index.es.js

@@ -37075,6 +37075,9 @@ const defaultValidators = {
   }, "dropdownMulti"),
   number: /* @__PURE__ */ __name((newVal, field) => {
     if (isValueEmpty(newVal) && !field.isRequired) return;
+    if (field.allowNaN && Number.isNaN(newVal)) {
+      return;
+    }
     if (isNaN(newVal) || !isNumber$1(newVal)) {
       return "Must be a number";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/ui",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "main": "./src/index.js",
   "type": "module",
   "exports": {

package/src/AdvancedOptions.spec.js

@@ -1,26 +1,40 @@
 import React from "react";
 import { render, fireEvent } from "@testing-library/react";
+
 import AdvancedOptions from "./AdvancedOptions";
 
 describe("AdvancedOptions", () => {
+  // afterEach(() => {
+  //   cleanup();
+  // });
+
   test("renders correctly with given props and default state", () => {
     const { queryByText, container } = render(
       <AdvancedOptions label="Test Label" content="Test Content" />
     );
-    expect(queryByText("Test Label")).toBeInTheDocument();
-    expect(queryByText("Test Content")).not.toBeInTheDocument();
+    // Check if label is rendered
+    expect(queryByText("Test Label")).not.toBeNull();
+    // Check if content is NOT rendered initially (collapsed state)
+    expect(queryByText("Test Content")).toBeNull();
 
-    expect(
-      container.querySelector(".bp3-icon-caret-right")
-    ).toBeInTheDocument();
+    // Check if right caret icon is present (collapsed state)
+    expect(container.querySelector(".bp3-icon-caret-right")).not.toBeNull();
   });
 
   test("toggles content when clicked", () => {
-    const { getByText, queryByText, container } = render(
-      <AdvancedOptions label="Test Label" content="Test Content" />
+    const { container, queryByText } = render(
+      <AdvancedOptions label="Test Label 2" content="Test Content 2" />
     );
-    fireEvent.click(getByText("Test Label"));
-    expect(queryByText("Test Content")).toBeInTheDocument();
-    expect(container.querySelector(".bp3-icon-caret-down")).toBeInTheDocument();
+
+    // Find and click the toggle button
+    const toggleButton = container.querySelector(".tg-toggle-advanced-options");
+    expect(toggleButton).not.toBeNull();
+
+    fireEvent.click(toggleButton);
+
+    // After click, content should be visible
+    expect(queryByText("Test Content 2")).not.toBeNull();
+    // After click, down caret icon should be present (expanded state)
+    expect(container.querySelector(".bp3-icon-caret-down")).not.toBeNull();
   });
 });

package/src/DataTable/defaultValidators.js

@@ -29,6 +29,10 @@ export const defaultValidators = {
   },
   number: (newVal, field) => {
     if (isValueEmpty(newVal) && !field.isRequired) return;
+    if (field.allowNaN && Number.isNaN(newVal)) {
+      // Allow actual NaN when explicitly permitted
+      return;
+    }
     if (isNaN(newVal) || !isNumber(newVal)) {
       return "Must be a number";
     }

package/src/DataTable/defaultValidators.test.js

@@ -0,0 +1,108 @@
+// Basic unit tests without jest-dom setup
+import { describe, test, expect } from "bun:test";
+import { defaultValidators } from "./defaultValidators";
+
+describe("defaultValidators", () => {
+  describe("number validator", () => {
+    const numberValidator = defaultValidators.number;
+
+    test("should validate valid numbers", () => {
+      expect(numberValidator(123, {})).toBeUndefined();
+      expect(numberValidator(0, {})).toBeUndefined();
+      expect(numberValidator(-123, {})).toBeUndefined();
+      expect(numberValidator(123.45, {})).toBeUndefined();
+    });
+
+    test("should reject non-numeric strings", () => {
+      expect(numberValidator("hello", {})).toBe("Must be a number");
+      expect(numberValidator("abc123", {})).toBe("Must be a number");
+      expect(numberValidator("", {})).toBeUndefined(); // empty values are allowed when not required
+    });
+
+    test("should reject NaN by default", () => {
+      expect(numberValidator(NaN, {})).toBe("Must be a number");
+    });
+
+    test("should allow NaN when allowNaN is true", () => {
+      expect(numberValidator(NaN, { allowNaN: true })).toBeUndefined();
+    });
+
+    test("should still reject non-numeric strings even with allowNaN", () => {
+      expect(numberValidator("hello", { allowNaN: true })).toBe("Must be a number");
+      expect(numberValidator("not a number", { allowNaN: true })).toBe("Must be a number");
+    });
+
+    test("should handle required field validation", () => {
+      expect(numberValidator("", { isRequired: true })).toBe("Must be a number");
+      expect(numberValidator(null, { isRequired: true })).toBe("Must be a number");
+      expect(numberValidator(undefined, { isRequired: true })).toBe("Must be a number");
+    });
+
+    test("should allow empty values for non-required fields", () => {
+      expect(numberValidator("", {})).toBeUndefined();
+      expect(numberValidator(null, {})).toBeUndefined();
+      expect(numberValidator(undefined, {})).toBeUndefined();
+    });
+
+    test("should reject numeric strings (only actual numbers allowed)", () => {
+      expect(numberValidator("123", {})).toBe("Must be a number");
+      expect(numberValidator("123.45", {})).toBe("Must be a number");
+      expect(numberValidator("-123", {})).toBe("Must be a number");
+    });
+
+    test("should combine allowNaN with required field validation", () => {
+      // Required field with allowNaN should still reject empty values
+      expect(numberValidator("", { isRequired: true, allowNaN: true })).toBe("Must be a number");
+      expect(numberValidator(null, { isRequired: true, allowNaN: true })).toBe("Must be a number");
+      
+      // But should allow NaN
+      expect(numberValidator(NaN, { isRequired: true, allowNaN: true })).toBeUndefined();
+    });
+  });
+
+  describe("string validator", () => {
+    const stringValidator = defaultValidators.string;
+
+    test("should allow any string for non-required fields", () => {
+      expect(stringValidator("hello", {})).toBe(false);
+      expect(stringValidator("", {})).toBe(false);
+    });
+
+    test("should reject empty strings for required fields", () => {
+      expect(stringValidator("", { isRequired: true })).toBe("Please enter a value here");
+      expect(stringValidator(null, { isRequired: true })).toBe("Please enter a value here");
+      expect(stringValidator(undefined, { isRequired: true })).toBe("Please enter a value here");
+    });
+
+    test("should accept non-empty strings for required fields", () => {
+      expect(stringValidator("hello", { isRequired: true })).toBeUndefined();
+      expect(stringValidator("test", { isRequired: true })).toBeUndefined();
+    });
+  });
+
+  describe("dropdown validator", () => {
+    const dropdownValidator = defaultValidators.dropdown;
+    const field = { values: ["option1", "option2", "option3"] };
+
+    test("should accept valid dropdown values", () => {
+      expect(dropdownValidator("option1", field)).toBeUndefined();
+      expect(dropdownValidator("option2", field)).toBeUndefined();
+      expect(dropdownValidator("option3", field)).toBeUndefined();
+    });
+
+    test("should reject invalid dropdown values", () => {
+      expect(dropdownValidator("invalid", field)).toBe("Please choose one of the accepted values");
+      expect(dropdownValidator("option4", field)).toBe("Please choose one of the accepted values");
+    });
+
+    test("should handle required dropdown fields", () => {
+      expect(dropdownValidator("", { ...field, isRequired: true })).toBe("Please choose one of the accepted values");
+      expect(dropdownValidator(null, { ...field, isRequired: true })).toBe("Please choose one of the accepted values");
+    });
+
+    test("should allow empty values for non-required dropdown fields", () => {
+      expect(dropdownValidator("", field)).toBeUndefined();
+      expect(dropdownValidator(null, field)).toBeUndefined();
+    });
+  });
+});