@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/components/DataTable/utils/selectFieldUtils.ts

@@ -3,21 +3,69 @@
  * @package @jmruthers/pace-core
  * @module Components/DataTable/Utils
  * @since 0.6.0
- * 
+ *
  * Utility functions for handling select field label lookups in DataTable.
  */
 
 import type { CellValue, DataTableColumn } from '../types';
 
+type FieldOption = NonNullable<DataTableColumn['fieldOptions']>[number];
+type SimpleOption = { value: string | number; label: string };
+type GroupOption = { type: 'group'; label: string; items: Array<{ value: string | number; label: string }> };
+
+function optionValueMatches(
+  normalizedValue: string | number,
+  optionValue: string | number
+): boolean {
+  if (optionValue === normalizedValue) {
+    return true;
+  }
+  if (typeof optionValue === 'number' && typeof normalizedValue === 'string') {
+    const numValue = Number(normalizedValue);
+    return !isNaN(numValue) && optionValue === numValue;
+  }
+  if (typeof optionValue === 'string' && typeof normalizedValue === 'number') {
+    const numValue = Number(optionValue);
+    return !isNaN(numValue) && numValue === normalizedValue;
+  }
+  return false;
+}
+
+function getLabelFromSimpleOption(
+  normalizedValue: string | number,
+  option: FieldOption
+): string | null {
+  if (!('value' in option) || 'type' in option) {
+    return null;
+  }
+  const simple = option as SimpleOption;
+  return optionValueMatches(normalizedValue, simple.value) ? simple.label : null;
+}
+
+function isGroupOption(option: FieldOption): option is GroupOption {
+  return 'type' in option && option.type === 'group';
+}
+
+function getLabelFromGroupOption(
+  normalizedValue: string | number,
+  groupOption: GroupOption
+): string | null {
+  for (const item of groupOption.items) {
+    if (optionValueMatches(normalizedValue, item.value)) {
+      return item.label;
+    }
+  }
+  return null;
+}
 
 /**
  * Finds the label for a given value in fieldOptions.
  * Handles simple options, grouped options, and separators.
- * 
+ *
  * @param value - The value to find the label for (can be string, number, null, or undefined)
  * @param fieldOptions - The fieldOptions array from the column definition
  * @returns The label string if found, null otherwise
- * 
+ *
  * @example
  * ```tsx
  * const options = [
@@ -27,7 +75,7 @@ import type { CellValue, DataTableColumn } from '../types';
  * findSelectLabel(1, options); // Returns 'Mobile'
  * findSelectLabel(3, options); // Returns null
  * ```
- * 
+ *
  * @example
  * ```tsx
  * const groupedOptions = [
@@ -51,77 +99,66 @@ export function findSelectLabel(
     return null;
   }
 
-  // Handle null/undefined values
   if (value === null || value === undefined) {
     return null;
   }
 
-  // Normalize value for comparison (handle both string and number)
-  const normalizedValue = typeof value === 'string' && !isNaN(Number(value)) && value.trim() !== ''
-    ? Number(value)
-    : value;
+  const normalizedValue =
+    typeof value === 'string' && !isNaN(Number(value)) && value.trim() !== ''
+      ? Number(value)
+      : value;
+
+  // Option values are string | number; boolean/Date cannot match
+  if (typeof normalizedValue !== 'string' && typeof normalizedValue !== 'number') {
+    return null;
+  }
 
-  // Search through fieldOptions
   for (const option of fieldOptions) {
-    // Skip separators
     if ('type' in option && option.type === 'separator') {
       continue;
     }
 
-    // Handle simple options: { value, label }
-    if ('value' in option && !('type' in option)) {
-      const optionValue = option.value;
-      
-      // Try strict equality first
-      if (optionValue === normalizedValue) {
-        return option.label;
-      }
-      
-      // Handle type coercion: "1" (string) should match 1 (number) and vice versa
-      if (typeof optionValue === 'number' && typeof normalizedValue === 'string') {
-        const numValue = Number(normalizedValue);
-        if (!isNaN(numValue) && optionValue === numValue) {
-          return option.label;
-        }
-      }
-      
-      if (typeof optionValue === 'string' && typeof normalizedValue === 'number') {
-        const numValue = Number(optionValue);
-        if (!isNaN(numValue) && numValue === normalizedValue) {
-          return option.label;
-        }
-      }
+    const labelFromSimple = getLabelFromSimpleOption(normalizedValue, option);
+    if (labelFromSimple !== null) {
+      return labelFromSimple;
     }
 
-    // Handle grouped options: { type: 'group', items: [...] }
-    if ('type' in option && option.type === 'group') {
-      const groupOption = option as { type: 'group'; label: string; items: Array<{ value: string | number; label: string }> };
-      
-      for (const item of groupOption.items) {
-        const itemValue = item.value;
-        
-        // Try strict equality first
-        if (itemValue === normalizedValue) {
-          return item.label;
-        }
-        
-        // Handle type coercion: "1" (string) should match 1 (number) and vice versa
-        if (typeof itemValue === 'number' && typeof normalizedValue === 'string') {
-          const numValue = Number(normalizedValue);
-          if (!isNaN(numValue) && itemValue === numValue) {
-            return item.label;
-          }
-        }
-        
-        if (typeof itemValue === 'string' && typeof normalizedValue === 'number') {
-          const numValue = Number(itemValue);
-          if (!isNaN(numValue) && numValue === normalizedValue) {
-            return item.label;
-          }
-        }
+    if (isGroupOption(option)) {
+      const labelFromGroup = getLabelFromGroupOption(normalizedValue, option);
+      if (labelFromGroup !== null) {
+        return labelFromGroup;
       }
     }
   }
 
   return null;
 }
+
+/** Field option shape used for search matching (simple, group, or separator). */
+export type FieldOptionForSearch =
+  | { value: string | number; label: string }
+  | { type: 'group'; label: string; items: Array<{ value: string | number; label: string }> }
+  | { type: 'separator' };
+
+/**
+ * Returns whether an option (or any item in a group) matches the search string.
+ * Used by select edit field search to decide if "Create" option should be shown.
+ *
+ * @param option - A single field option (simple, group, or separator)
+ * @param searchLower - Lowercase, trimmed search string
+ * @returns true if the option matches
+ */
+export function optionMatchesSearch(
+  option: FieldOptionForSearch,
+  searchLower: string
+): boolean {
+  if ('value' in option && !('type' in option)) {
+    return option.label.toLowerCase().includes(searchLower);
+  }
+  if (option.type === 'group' && 'items' in option) {
+    return option.items.some((item: { value: string | number; label: string }) =>
+      item.label.toLowerCase().includes(searchLower)
+    );
+  }
+  return false;
+}

package/src/components/DatePickerWithTimezone/DatePickerWithTimezone.test.tsx

@@ -1,7 +1,7 @@
 /**
  * @file DatePickerWithTimezone Component Tests
  * @package @jmruthers/pace-core
- * @module Components/DatePickerWithTimezone/__tests__
+ * @module Components/DatePickerWithTimezone
  * @since 0.1.0
  *
  * Comprehensive test suite for DatePickerWithTimezone component.

package/src/components/DateTimeField/DateTimeField.test.tsx

@@ -1,7 +1,7 @@
 /**
  * @file DateTimeField Component Tests
  * @package @jmruthers/pace-core
- * @module Components/DateTimeField/__tests__
+ * @module Components/DateTimeField
  * @since 0.1.0
  *
  * Comprehensive test suite for DateTimeField component.

package/src/components/Dialog/Dialog.test-utils.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared test utilities for Dialog component tests.
+ */
+
+import { screen, waitFor } from '@testing-library/react';
+// Use global vi (from vitest/globals) so tsc does not require vitest to export vi
+
+/**
+ * Wait for the dialog element to be present and accessible.
+ * Uses getByRole('dialog') when available, otherwise querySelector for jsdom.
+ */
+export async function waitForDialog(): Promise<HTMLElement> {
+  return await waitFor(
+    () => {
+      try {
+        const dialog = screen.getByRole('dialog');
+        expect(dialog).toBeInTheDocument();
+        return dialog;
+      } catch {
+        const dialog = document.querySelector('dialog[role="dialog"]') as HTMLDialogElement | null;
+        if (!dialog) {
+          throw new Error('Dialog not found in DOM');
+        }
+        return dialog;
+      }
+    },
+    { timeout: 3000 }
+  );
+}
+
+/**
+ * Setup to run in beforeEach: mock HTMLDialogElement showModal/close and console.
+ */
+export function setupDialogEnv(): void {
+  if (typeof HTMLDialogElement !== 'undefined') {
+    HTMLDialogElement.prototype.showModal = vi.fn(function (this: HTMLDialogElement) {
+      this.setAttribute('open', '');
+      this.open = true;
+      this.dispatchEvent(new Event('show', { bubbles: true }));
+    });
+    HTMLDialogElement.prototype.close = vi.fn(function (this: HTMLDialogElement) {
+      this.removeAttribute('open');
+      this.open = false;
+      this.dispatchEvent(new Event('close', { bubbles: true }));
+    });
+  }
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'warn').mockImplementation(() => {});
+}