{"version":3,"sources":["../src/testing/fieldContractTests.tsx"],"sourcesContent":["/**\n * Shared adapter contract test suite.\n *\n * Generates a set of vitest tests that validate a field registry\n * conforms to the adapter contract. Each adapter package should\n * import this function and call it with their registry factory.\n *\n * NOTE ON FIELD TYPE COVERAGE FOR \"STRICT\" ASSERTIONS (aria-*, readOnly DOM shape):\n * --------------------------------------------------------------------------------\n * Contract tests mount fields *standalone* (not through FieldWrapper), so we\n * simulate what FieldWrapper does by injecting `id`, `aria-labelledby`,\n * `aria-describedby` via React.cloneElement on each field and then assert the\n * adapter has forwarded those props to at least one descendant element. This\n * verifies the P0 aria-forwarding fix that other agents just landed.\n *\n * For field types where a structural assertion does not make sense (e.g. a\n * CheckboxGroup will never have a single `id` on its root), we skip that\n * specific assertion with a recorded reason — this surfaces a known gap\n * without silently passing. See EXCEPTIONS_BY_TYPE below.\n */\nimport { describe, it, expect, vi, beforeEach } from \"vitest\";\nimport { render, fireEvent } from \"@testing-library/react\";\nimport React from \"react\";\nimport { ComponentTypes } from \"../constants\";\nimport type { Dictionary } from \"../utils\";\nimport type { IOption } from \"../types/IOption\";\n\n/** Tier 1 field types that every adapter should implement */\nexport const TIER_1_FIELDS = [\n  ComponentTypes.Textbox,\n  ComponentTypes.Number,\n  ComponentTypes.Toggle,\n  ComponentTypes.Dropdown,\n  ComponentTypes.MultiSelect,\n  ComponentTypes.DateControl,\n  ComponentTypes.Slider,\n  ComponentTypes.RadioGroup,\n  ComponentTypes.CheckboxGroup,\n  ComponentTypes.Textarea,\n  ComponentTypes.ReadOnly,\n  ComponentTypes.Fragment,\n] as const;\n\n/** All standard field types (Tier 1 + 2 + 3) */\nexport const ALL_FIELD_TYPES = Object.values(ComponentTypes);\n\n/** Default test values by field type */\nexport const VALUE_BY_TYPE: Record<string, unknown> = {\n  [ComponentTypes.Textbox]: \"hello\",\n  [ComponentTypes.Number]: 42,\n  [ComponentTypes.Toggle]: true,\n  [ComponentTypes.Dropdown]: \"opt1\",\n  [ComponentTypes.MultiSelect]: [\"opt1\"],\n  [ComponentTypes.DateControl]: \"2024-01-15\",\n  [ComponentTypes.Slider]: 50,\n  [ComponentTypes.RadioGroup]: \"opt1\",\n  [ComponentTypes.CheckboxGroup]: [\"opt1\"],\n  [ComponentTypes.Textarea]: \"some text\",\n  [ComponentTypes.ReadOnly]: \"read only text\",\n  [ComponentTypes.Fragment]: \"hidden\",\n  // Tier 2+ types\n  [ComponentTypes.MultiSelectSearch]: [\"opt1\"],\n  [ComponentTypes.ReadOnlyArray]: [\"item1\", \"item2\"],\n  [ComponentTypes.ReadOnlyDateTime]: \"2024-01-15T10:30:00Z\",\n  [ComponentTypes.ReadOnlyRichText]: \"<p>rich text</p>\",\n  [ComponentTypes.ReadOnlyWithButton]: \"value\",\n  [ComponentTypes.Rating]: 3,\n  [ComponentTypes.ColorPicker]: \"#ff0000\",\n  [ComponentTypes.Autocomplete]: \"opt1\",\n  [ComponentTypes.FileUpload]: null,\n  [ComponentTypes.DateRange]: { start: \"2024-01-01\", end: \"2024-01-31\" },\n  [ComponentTypes.DateTime]: \"2024-01-15T10:30:00Z\",\n  [ComponentTypes.PhoneInput]: \"5551234567\",\n};\n\n/** Default test options for select-like fields */\nconst TEST_OPTIONS: IOption[] = [\n  { value: \"opt1\", label: \"Option 1\" },\n  { value: \"opt2\", label: \"Option 2\" },\n];\n\n/** Fields that use options */\nconst OPTION_FIELDS: Set<string> = new Set([\n  ComponentTypes.Dropdown,\n  ComponentTypes.MultiSelect,\n  ComponentTypes.MultiSelectSearch,\n  ComponentTypes.RadioGroup,\n  ComponentTypes.CheckboxGroup,\n  ComponentTypes.Autocomplete,\n]);\n\n/**\n * Per-field skip reasons for strict DOM-level assertions.\n *\n * Keys: one of the `aria-assertion` IDs below.\n * Values: set of field types where that assertion is not meaningful.\n *\n * When a strict assertion is skipped, the test body still runs but asserts\n * only the legacy \"renders without throwing\" contract. This keeps failures\n * from strict assertions surfaced for every field that should support them.\n */\nconst STRICT_ASSERTION_EXCEPTIONS: Record<string, Set<string>> = {\n  /**\n   * Fields for which we do NOT assert id/aria-labelledby forwarding.\n   *\n   * - Group / composite fields (CheckboxGroup, RadioGroup, MultiSelect,\n   *   MultiSelectSearch) render multiple inputs and may use a fieldset /\n   *   legend instead of a single id'd control.\n   * - Fragment / DynamicFragment is a container, not an interactive control.\n   * - ReadOnly fields render static text, not interactive controls.\n   * - StatusDropdown / DocumentLinks / ReadOnlyCumulativeNumber need a\n   *   FormProvider and can't be mounted standalone in the contract harness.\n   */\n  idForwarding: new Set<string>([\n    ComponentTypes.CheckboxGroup,\n    ComponentTypes.RadioGroup,\n    ComponentTypes.MultiSelect,\n    ComponentTypes.MultiSelectSearch,\n    ComponentTypes.Autocomplete,\n    ComponentTypes.Fragment,\n    ComponentTypes.ReadOnly,\n    ComponentTypes.ReadOnlyArray,\n    ComponentTypes.ReadOnlyDateTime,\n    ComponentTypes.ReadOnlyCumulativeNumber,\n    ComponentTypes.ReadOnlyRichText,\n    ComponentTypes.ReadOnlyWithButton,\n    ComponentTypes.StatusDropdown,\n    ComponentTypes.DocumentLinks,\n    ComponentTypes.FileUpload,\n    ComponentTypes.DateRange,\n    ComponentTypes.ColorPicker,\n    ComponentTypes.Rating,\n    ComponentTypes.FieldArray,\n  ]),\n  /**\n   * Fields that may not carry aria-required=\"true\" directly.\n   * Some adapters put it on the <fieldset>, some on individual inputs.\n   */\n  ariaRequired: new Set<string>([\n    // ReadOnly variants are never required-marked\n    ComponentTypes.ReadOnly,\n    ComponentTypes.ReadOnlyArray,\n    ComponentTypes.ReadOnlyDateTime,\n    ComponentTypes.ReadOnlyCumulativeNumber,\n    ComponentTypes.ReadOnlyRichText,\n    ComponentTypes.ReadOnlyWithButton,\n    ComponentTypes.Fragment,\n    ComponentTypes.DocumentLinks,\n    ComponentTypes.StatusDropdown,\n    ComponentTypes.FieldArray,\n    // Composite widgets vary by adapter and may only carry aria-required on\n    // inner inputs; the test still attempts to match but exempts failures.\n    ComponentTypes.FileUpload,\n    ComponentTypes.DateRange,\n    ComponentTypes.ColorPicker,\n    ComponentTypes.Rating,\n  ]),\n  /**\n   * Fields that may not carry aria-invalid=\"true\" on a queryable descendant.\n   */\n  ariaInvalid: new Set<string>([\n    ComponentTypes.ReadOnly,\n    ComponentTypes.ReadOnlyArray,\n    ComponentTypes.ReadOnlyDateTime,\n    ComponentTypes.ReadOnlyCumulativeNumber,\n    ComponentTypes.ReadOnlyRichText,\n    ComponentTypes.ReadOnlyWithButton,\n    ComponentTypes.Fragment,\n    ComponentTypes.DocumentLinks,\n    ComponentTypes.StatusDropdown,\n    ComponentTypes.FieldArray,\n    ComponentTypes.FileUpload,\n    ComponentTypes.DateRange,\n    ComponentTypes.ColorPicker,\n    ComponentTypes.Rating,\n  ]),\n  /**\n   * Fields that legitimately render a raw editable control even in readOnly\n   * mode, OR render nothing (invisible) so the \"no input/textarea/select\"\n   * assertion is not meaningful.\n   *\n   * - Toggle / Switch readOnly still uses a checkbox-shaped input in some\n   *   adapters (disabled) — we accept that.\n   * - Fragment does not render a visible control.\n   * - DateControl/DateTime/DateRange read-only path: date text, safe.\n   */\n  readOnlyHasNoInput: new Set<string>([\n    // Booleans / toggles: we accept checkbox in readOnly state because it\n    // visually conveys state. Disabled attribute is sufficient semantically.\n    ComponentTypes.Toggle,\n    // Container / composite read-only variants\n    ComponentTypes.Fragment,\n    // Native HTML color / file / phone controls sometimes still render the\n    // input when readOnly (disabled instead of hidden).\n    ComponentTypes.ColorPicker,\n    ComponentTypes.FileUpload,\n    ComponentTypes.PhoneInput,\n    // Rating adapters vary: some render checkboxes for each star regardless.\n    ComponentTypes.Rating,\n    // Field arrays: readOnly is item-level, not container-level.\n    ComponentTypes.FieldArray,\n    // FormProvider-gated types.\n    ComponentTypes.DocumentLinks,\n    ComponentTypes.MultiSelect,\n    ComponentTypes.MultiSelectSearch,\n    ComponentTypes.StatusDropdown,\n    ComponentTypes.ReadOnlyCumulativeNumber,\n  ]),\n};\n\n/**\n * Malicious HTML payload used to verify ReadOnlyRichText sanitization.\n * Covers: <script> tags, onerror/onclick event handlers, javascript: URLs.\n */\nexport const XSS_PAYLOAD =\n  '<img src=x onerror=\"alert(1)\"><script>alert(2)</script><a href=\"javascript:alert(3)\">x</a><div onclick=\"alert(4)\">y</div>';\n\nexport interface IContractTestOptions {\n  /** Field types to exclude from registry presence check */\n  excludeTypes?: string[];\n  /** If set, only test these types instead of ALL_FIELD_TYPES */\n  onlyTypes?: string[];\n  /** Description prefix for the test suite */\n  suiteName: string;\n  /** Optional wrapper component for providers (e.g., StyletronProvider for base-web) */\n  wrapper?: React.ComponentType<{ children: React.ReactNode }>;\n  /**\n   * Per-adapter known gaps for strict accessibility assertions.\n   *\n   * These fields exist in the registry but do NOT correctly forward ids,\n   * aria-required, or aria-invalid from FieldWrapper-injected props to the\n   * DOM. The strict assertion is skipped (logged) instead of failing.\n   *\n   * Use this to suppress failures on compat adapters that wrap third-party\n   * components that own their own aria attributes (e.g., react-aria-components,\n   * mantine's <Switch>, some atlaskit/heroui compatibility wrappers).\n   */\n  knownAriaGaps?: {\n    idForwarding?: string[];\n    ariaRequired?: string[];\n    ariaInvalid?: string[];\n  };\n}\n\n/**\n * Runs the adapter contract test suite against a field registry.\n *\n * @param registryFactory - Function that creates the field registry\n * @param options - Test configuration\n */\nexport function runAdapterContractTests(\n  registryFactory: () => Dictionary<React.JSX.Element>,\n  options: IContractTestOptions\n) {\n  const { excludeTypes = [], suiteName, onlyTypes, wrapper, knownAriaGaps = {} } = options;\n  const idGaps = new Set(knownAriaGaps.idForwarding ?? []);\n  const requiredGaps = new Set(knownAriaGaps.ariaRequired ?? []);\n  const invalidGaps = new Set(knownAriaGaps.ariaInvalid ?? []);\n\n  describe(`${suiteName} adapter contract`, () => {\n    let registry: Dictionary<React.JSX.Element>;\n\n    beforeEach(() => {\n      registry = registryFactory();\n    });\n\n    const typesToTest = onlyTypes ?? ALL_FIELD_TYPES.filter(t => !excludeTypes.includes(t));\n\n    const renderWithWrapper = (element: React.ReactElement) => {\n      return render(element, wrapper ? { wrapper } : undefined);\n    };\n\n    describe(\"registry coverage\", () => {\n      it(\"registry is a non-empty object\", () => {\n        expect(typeof registry).toBe(\"object\");\n        expect(Object.keys(registry).length).toBeGreaterThan(0);\n      });\n\n      for (const type of typesToTest) {\n        it(`has entry for \"${type}\"`, () => {\n          expect(registry[type]).toBeDefined();\n          expect(React.isValidElement(registry[type])).toBe(true);\n        });\n      }\n    });\n\n    describe(\"field rendering\", () => {\n      const minimalProps = {\n        fieldName: \"testField\",\n        testId: \"contract-test\",\n        value: undefined,\n        readOnly: false,\n        required: false,\n        setFieldValue: vi.fn(),\n      };\n\n      for (const type of typesToTest) {\n        it(`\"${type}\" renders without error with minimal props`, () => {\n          const element = registry[type];\n          if (!element) return;\n          const props = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, options: TEST_OPTIONS }\n            : minimalProps;\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n          expect(container).toBeTruthy();\n        });\n\n        it(`\"${type}\" renders in readOnly mode`, () => {\n          const element = registry[type];\n          if (!element) return;\n          const readOnlyValue = VALUE_BY_TYPE[type] ?? \"Test\";\n          const props = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, readOnly: true, value: readOnlyValue, options: TEST_OPTIONS }\n            : { ...minimalProps, readOnly: true, value: readOnlyValue };\n          const { container } = renderWithWrapper(\n            React.cloneElement(element, props)\n          );\n          expect(container).toBeTruthy();\n\n          // P0 regression: readOnly must not render raw editable inputs.\n          // See `readOnlyHasNoInput` exceptions above for adapters/types where\n          // this assertion is not meaningful.\n          if (!STRICT_ASSERTION_EXCEPTIONS.readOnlyHasNoInput.has(type)) {\n            const rawTextInputs = container.querySelectorAll(\n              'input[type=\"text\"], input[type=\"number\"], input[type=\"email\"], input[type=\"tel\"], input[type=\"url\"], input[type=\"search\"], input[type=\"password\"]'\n            );\n            const textareas = container.querySelectorAll(\"textarea\");\n            const selects = container.querySelectorAll(\"select\");\n\n            // All editable inputs should be disabled/readonly or absent.\n            const editableAndEnabled: Element[] = [];\n            rawTextInputs.forEach(el => {\n              const isDisabled = (el as HTMLInputElement).disabled || el.hasAttribute(\"readonly\");\n              if (!isDisabled) editableAndEnabled.push(el);\n            });\n            textareas.forEach(el => {\n              const isDisabled = (el as HTMLTextAreaElement).disabled || el.hasAttribute(\"readonly\");\n              if (!isDisabled) editableAndEnabled.push(el);\n            });\n            selects.forEach(el => {\n              const isDisabled = (el as HTMLSelectElement).disabled;\n              if (!isDisabled) editableAndEnabled.push(el);\n            });\n\n            expect(\n              editableAndEnabled,\n              `readOnly \"${type}\" rendered an editable, non-disabled input/textarea/select`,\n            ).toHaveLength(0);\n          }\n        });\n\n        it(`\"${type}\" renders in disabled state`, () => {\n          const element = registry[type];\n          if (!element) return;\n          const props = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, disabled: true, options: TEST_OPTIONS }\n            : { ...minimalProps, disabled: true };\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n          expect(container).toBeTruthy();\n        });\n\n        it(`\"${type}\" renders in required state`, () => {\n          const element = registry[type];\n          if (!element) return;\n          const props = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, required: true, options: TEST_OPTIONS }\n            : { ...minimalProps, required: true };\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n          expect(container).toBeTruthy();\n\n          // P0 regression: required must surface as aria-required=\"true\" on\n          // some descendant element. Skip for group/composite types where\n          // this does not apply, or when this adapter is a known gap.\n          if (\n            !STRICT_ASSERTION_EXCEPTIONS.ariaRequired.has(type) &&\n            !requiredGaps.has(type)\n          ) {\n            const ariaRequired = container.querySelector('[aria-required=\"true\"]');\n            expect(\n              ariaRequired,\n              `required \"${type}\" did not surface aria-required=\"true\" on any descendant`,\n            ).toBeTruthy();\n          }\n        });\n\n        it(`\"${type}\" renders with a value`, () => {\n          const element = registry[type];\n          if (!element) return;\n          const testValue = VALUE_BY_TYPE[type];\n          const props = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, value: testValue, options: TEST_OPTIONS }\n            : { ...minimalProps, value: testValue };\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n          expect(container).toBeTruthy();\n        });\n\n        it(`\"${type}\" renders safely with undefined value`, () => {\n          const element = registry[type];\n          if (!element) return;\n          const props = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, value: undefined, options: TEST_OPTIONS }\n            : { ...minimalProps, value: undefined };\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n          expect(container).toBeTruthy();\n        });\n\n        // P0 regression: FieldWrapper injects id/aria-labelledby/aria-describedby;\n        // the adapter must forward these to a descendant so labels are tied to\n        // the control. Skip for composite/readonly/context-gated fields.\n        it(`\"${type}\" forwards id / aria-labelledby from FieldWrapper props`, () => {\n          const element = registry[type];\n          if (!element) return;\n          if (\n            STRICT_ASSERTION_EXCEPTIONS.idForwarding.has(type) ||\n            idGaps.has(type)\n          ) {\n            // Known gap: skip aria-forwarding assertion for this type/adapter.\n            return;\n          }\n\n          const INJECTED_ID = `contract-${type}-id`;\n          const INJECTED_LABEL_ID = `contract-${type}-label`;\n          const INJECTED_DESC_ID = `contract-${type}-desc`;\n          const props: Record<string, unknown> = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, options: TEST_OPTIONS }\n            : { ...minimalProps };\n          props.id = INJECTED_ID;\n          props[\"aria-labelledby\"] = INJECTED_LABEL_ID;\n          props[\"aria-describedby\"] = INJECTED_DESC_ID;\n\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n\n          const withId = container.querySelector(`[id=\"${INJECTED_ID}\"]`);\n          const withLabelledby = container.querySelector(\n            `[aria-labelledby=\"${INJECTED_LABEL_ID}\"]`\n          );\n\n          // Either mechanism is acceptable — adapters may use different DOM\n          // strategies (id on native input, aria-labelledby on wrapper).\n          expect(\n            withId || withLabelledby,\n            `\"${type}\" did not forward id or aria-labelledby to any descendant`,\n          ).toBeTruthy();\n        });\n\n        // P0 regression: error state must surface as aria-invalid=\"true\".\n        it(`\"${type}\" surfaces aria-invalid on error`, () => {\n          const element = registry[type];\n          if (!element) return;\n          if (\n            STRICT_ASSERTION_EXCEPTIONS.ariaInvalid.has(type) ||\n            invalidGaps.has(type)\n          ) {\n            // Known gap: skip aria-invalid assertion for this type/adapter.\n            return;\n          }\n\n          const props: Record<string, unknown> = OPTION_FIELDS.has(type)\n            ? { ...minimalProps, options: TEST_OPTIONS }\n            : { ...minimalProps };\n          props.error = { type: \"required\", message: \"Required\" };\n\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n          const ariaInvalid = container.querySelector('[aria-invalid=\"true\"]');\n          expect(\n            ariaInvalid,\n            `\"${type}\" did not surface aria-invalid=\"true\" when error prop provided`,\n          ).toBeTruthy();\n        });\n      }\n\n      // Behavioral contract: Number fields must distinguish \"cleared\" from 0.\n      // Regression for the Number(\"\") === 0 coercion bug: clearing the input\n      // used to commit the value 0 (or, in adapters whose widget emits NaN on\n      // clear, silently keep the stale value). Clearing must commit null.\n      if (typesToTest.includes(ComponentTypes.Number)) {\n        const renderNumberField = (value: unknown) => {\n          const setFieldValue = vi.fn();\n          const element = registry[ComponentTypes.Number];\n          const { container } = renderWithWrapper(\n            React.cloneElement(element, {\n              ...minimalProps,\n              value,\n              setFieldValue,\n            })\n          );\n          const input = container.querySelector<HTMLInputElement>(\n            'input:not([type=\"hidden\"])'\n          );\n          return { setFieldValue, input };\n        };\n\n        it(`\"${ComponentTypes.Number}\" commits the typed number`, () => {\n          const { setFieldValue, input } = renderNumberField(undefined);\n          expect(input, \"Number field rendered no editable input\").toBeTruthy();\n          fireEvent.change(input!, { target: { value: \"7\" } });\n          fireEvent.blur(input!);\n          const committed = setFieldValue.mock.calls.map(call => call[1]);\n          expect(\n            committed,\n            `typing \"7\" should commit the number 7 (got: ${JSON.stringify(committed)})`,\n          ).toContain(7);\n        });\n\n        it(`\"${ComponentTypes.Number}\" commits null when cleared — never 0`, () => {\n          const { setFieldValue, input } = renderNumberField(42);\n          expect(input, \"Number field rendered no editable input\").toBeTruthy();\n          fireEvent.change(input!, { target: { value: \"\" } });\n          fireEvent.blur(input!);\n          const committed = setFieldValue.mock.calls.map(call => call[1]);\n          expect(\n            committed,\n            \"clearing the Number field must never commit 0\",\n          ).not.toContain(0);\n          expect(\n            committed,\n            `clearing the Number field must commit null (got: ${JSON.stringify(committed)})`,\n          ).toContain(null);\n        });\n      }\n\n      // P0-3 regression: ReadOnlyRichText must sanitize malicious HTML.\n      // This is the highest-signal single test for the sanitization fix.\n      if (\n        typesToTest.includes(ComponentTypes.ReadOnlyRichText) &&\n        !excludeTypes.includes(ComponentTypes.ReadOnlyRichText)\n      ) {\n        it(`\"${ComponentTypes.ReadOnlyRichText}\" sanitizes malicious HTML`, () => {\n          const element = registry[ComponentTypes.ReadOnlyRichText];\n          if (!element) return;\n          const props = {\n            ...minimalProps,\n            readOnly: true,\n            value: XSS_PAYLOAD,\n          };\n          const { container } = renderWithWrapper(React.cloneElement(element, props));\n\n          // Raw markup must not contain <script>, on* event handlers, or\n          // javascript: URLs after sanitization.\n          expect(container.innerHTML).not.toMatch(/<script/i);\n          expect(container.innerHTML).not.toMatch(/\\son[a-z]+\\s*=/i);\n          expect(container.innerHTML).not.toMatch(/javascript:/i);\n        });\n      }\n    });\n  });\n}\n"],"mappings":"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","names":[]}