@truedat/df 8.7.0 → 8.7.1

package/src/templates/components/templateForm/__tests__/FieldDefinition.spec.js

@@ -8,220 +8,246 @@ import FieldDefinition from "../FieldDefinition";
 const mockFormatMessage = jest.fn(({ id }) => id);
 
 jest.mock("react-intl", () => ({
-    ...jest.requireActual("react-intl"),
-    useIntl: () => ({
-        formatMessage: mockFormatMessage,
-    }),
+  ...jest.requireActual("react-intl"),
+  useIntl: () => ({
+    formatMessage: mockFormatMessage,
+  }),
 }));
 
 const user = userEvent.setup({ delay: null });
 
 describe("FieldDefinition", () => {
-    const baseProps = {
-        fieldNamePrefix: "field",
-        defaultField: "field.default",
-        valueName: "field.value",
-        subscribableField: "field.subscribable",
-        widget: "string",
-        type: "string",
-        cardinality: "?",
-        onChange: jest.fn(),
-        allowedTypes: [],
-        allowedWidgets: [],
-        mandatory: {},
-    };
-
-    beforeEach(() => {
-        jest.clearAllMocks();
+  const baseProps = {
+    fieldNamePrefix: "field",
+    defaultField: "field.default",
+    valueName: "field.value",
+    subscribableField: "field.subscribable",
+    widget: "string",
+    type: "string",
+    cardinality: "?",
+    onChange: jest.fn(),
+    allowedTypes: [],
+    allowedWidgets: [],
+    mandatory: {},
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("renders dropdowns with initial values", async () => {
+    const rendered = render(
+      <FieldDefinition {...baseProps} onChange={jest.fn()} />,
+    );
+    waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    const dropdowns = rendered.getAllByRole("listbox");
+    expect(dropdowns.length).toBe(3);
+
+    const widgetDropdown = dropdowns[0];
+    expect(widgetDropdown).toHaveAttribute("name", "field.widget");
+    const selectedWidget = within(widgetDropdown).getByRole("option", {
+      name: "Text Input",
     });
+    expect(selectedWidget).toHaveAttribute("aria-checked", "true");
 
-    test("renders dropdowns with initial values", async () => {
-        const rendered = render(<FieldDefinition {...baseProps} onChange={jest.fn()} />);
-        waitForLoad(rendered);
-        expect(rendered.container).toMatchSnapshot();
-        const dropdowns = rendered.getAllByRole("listbox");
-        expect(dropdowns.length).toBe(3);
-
-        const widgetDropdown = dropdowns[0];
-        expect(widgetDropdown).toHaveAttribute("name", "field.widget");
-        const selectedWidget = within(widgetDropdown).getByRole("option", { name: "Text Input" });
-        expect(selectedWidget).toHaveAttribute("aria-checked", "true");
-
-        const typeDropdown = dropdowns[1];
-        expect(typeDropdown).toHaveAttribute("name", "field.type");
-        const selectedType = within(typeDropdown).getByRole("option", { name: "template.field.type.string" });
-        expect(selectedType).toHaveAttribute("aria-checked", "true");
-
-        const cardinalityDropdown = dropdowns[2];
-        expect(cardinalityDropdown).toHaveAttribute("name", "field.cardinality");
-        const selectedCardinality = within(cardinalityDropdown).getByRole("option", { name: "template.field.cardinality.?" });
-        expect(selectedCardinality).toHaveAttribute("aria-checked", "true");
+    const typeDropdown = dropdowns[1];
+    expect(typeDropdown).toHaveAttribute("name", "field.type");
+    const selectedType = within(typeDropdown).getByRole("option", {
+      name: "template.field.type.string",
     });
-
-    test("handleWidgetChange: sets valueName to null (via getValues), resets default, sets subscribable=false, then emits type change", async () => {
-        const onChange = jest.fn();
-        const rendered = render(<FieldDefinition {...baseProps} onChange={onChange} />);
-        waitForLoad(rendered);
-
-        const numberOpt = within(rendered.getAllByRole("listbox")[0]).getByRole("option", { name: "Number" });
-        // Change type; for widget 'string' the only type is 'string', so switch the widget first to 'number'
-        await user.click(numberOpt);
-
-        // 1) reset value
-        expect(onChange).toHaveBeenNthCalledWith(
-            onChange.mock.calls.length - 3,
-            null,
-            { name: "field.value", value: null }
-        );
-
-        // // 2) reset defaultField
-        expect(onChange).toHaveBeenNthCalledWith(
-            onChange.mock.calls.length - 2,
-            expect.anything(),
-            { name: "field.default", value: { value: "", origin: "default" } }
-        );
-
-        // // 3) set subscribable=false
-        expect(onChange).toHaveBeenNthCalledWith(
-            onChange.mock.calls.length - 1,
-            expect.anything(),
-            { name: "field.subscribable", value: false }
-        );
-
-        // // 4) finally, the actual type widget event payload
-        expect(onChange).toHaveBeenLastCalledWith(
-            expect.anything(),
-            expect.objectContaining({ name: "field.widget", value: "number" })
-        );
-    });
-
-    test("handleTypeChange: recomputes default value via real getValues, resets default, sets subscribable=false, and emits widget change", async () => {
-        const onChange = jest.fn();
-        const rendered = render(<FieldDefinition {...{ ...baseProps, widget: "dropdown", type: "string" }} onChange={onChange} />);
-        waitForLoad(rendered);
-
-        // Switch Type from 'string' to 'domain'
-        const domainOpt = within(rendered.getAllByRole("listbox")[1]).getByRole("option", { name: "template.field.type.domain" });
-        await user.click(domainOpt);
-
-        // The first call in handleTypeChange is changeValue(valueName, ...) -> null
-        expect(onChange).toHaveBeenNthCalledWith(
-            1,
-            null,
-            { name: "field.value", value: null }
-        );
-
-        // 2) default reset
-        expect(onChange).toHaveBeenNthCalledWith(
-            2,
-            expect.anything(),
-            { name: "field.default", value: { value: "", origin: "default" } }
-        );
-
-        // 3) subscribable=false
-        expect(onChange).toHaveBeenNthCalledWith(
-            3,
-            expect.anything(),
-            { name: "field.subscribable", value: false }
-        );
-
-        // 4) widget change payload
-        expect(onChange).toHaveBeenNthCalledWith(
-            4,
-            expect.anything(),
-            expect.objectContaining({ name: "field.type", value: "domain" })
-        );
+    expect(selectedType).toHaveAttribute("aria-checked", "true");
+
+    const cardinalityDropdown = dropdowns[2];
+    expect(cardinalityDropdown).toHaveAttribute("name", "field.cardinality");
+    const selectedCardinality = within(cardinalityDropdown).getByRole(
+      "option",
+      { name: "template.field.cardinality.?" },
+    );
+    expect(selectedCardinality).toHaveAttribute("aria-checked", "true");
+  });
+
+  test("handleWidgetChange: sets valueName to null (via getValues), resets default, sets subscribable=false, then emits type change", async () => {
+    const onChange = jest.fn();
+    const rendered = render(
+      <FieldDefinition {...baseProps} onChange={onChange} />,
+    );
+    waitForLoad(rendered);
+
+    const numberOpt = within(rendered.getAllByRole("listbox")[0]).getByRole(
+      "option",
+      { name: "Number" },
+    );
+    // Change type; for widget 'string' the only type is 'string', so switch the widget first to 'number'
+    await user.click(numberOpt);
+
+    // 1) reset value
+    expect(onChange).toHaveBeenNthCalledWith(
+      onChange.mock.calls.length - 3,
+      null,
+      { name: "field.value", value: null },
+    );
+
+    // // 2) reset defaultField
+    expect(onChange).toHaveBeenNthCalledWith(
+      onChange.mock.calls.length - 2,
+      expect.anything(),
+      { name: "field.default", value: { value: "", origin: "default" } },
+    );
+
+    // // 3) set subscribable=false
+    expect(onChange).toHaveBeenNthCalledWith(
+      onChange.mock.calls.length - 1,
+      expect.anything(),
+      { name: "field.subscribable", value: false },
+    );
+
+    // // 4) finally, the actual type widget event payload
+    expect(onChange).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({ name: "field.widget", value: "number" }),
+    );
+  });
+
+  test("handleTypeChange: recomputes default value via real getValues, resets default, sets subscribable=false, and emits widget change", async () => {
+    const onChange = jest.fn();
+    const rendered = render(
+      <FieldDefinition
+        {...{ ...baseProps, widget: "dropdown", type: "string" }}
+        onChange={onChange}
+      />,
+    );
+    waitForLoad(rendered);
+
+    // Switch Type from 'string' to 'domain'
+    const domainOpt = within(rendered.getAllByRole("listbox")[1]).getByRole(
+      "option",
+      { name: "template.field.type.domain" },
+    );
+    await user.click(domainOpt);
+
+    // The first call in handleTypeChange is changeValue(valueName, ...) -> null
+    expect(onChange).toHaveBeenNthCalledWith(1, null, {
+      name: "field.value",
+      value: null,
     });
 
-    test("useEffect: auto-fixes invalid type/cardinality for a widget (real WIDGETS)", () => {
-        const onChange = jest.fn();
-
-        // For widget='number', valid types: ['integer','float']; cardinalities: ['?','1']
-        // Provide invalid type 'string' and invalid cardinality '+'
-        const rendered = render(<FieldDefinition {...baseProps}
-            onChange={onChange}
-            widget="number"
-            type="string"
-            cardinality="+" />);
-
-        waitForLoad(rendered);
-
-        // The effect should fire once and fix both:
-        expect(onChange).toHaveBeenCalledWith(
-            null,
-            { name: "field.type", value: "integer" } // first in WIDGETS types for 'number'
-        );
-        expect(onChange).toHaveBeenCalledWith(
-            null,
-            { name: "field.cardinality", value: "?" } // first in WIDGETS cardinalities for 'number'
-        );
+    // 2) default reset
+    expect(onChange).toHaveBeenNthCalledWith(2, expect.anything(), {
+      name: "field.default",
+      value: { value: "", origin: "default" },
     });
 
-    test("handleCardinalityChange: selecting '1' (or '+') clears mandatory when it's non-empty", async () => {
-        const onChange = jest.fn();
-
-        const rendered = render(
-            <FieldDefinition
-                {...baseProps}
-                onChange={onChange}
-                widget="string"
-                type="string"
-                cardinality="?"
-                mandatory={{ some: "value" }}
-            />);
-
-        waitForLoad(rendered);
-
-        // Select exactly-one '1'
-        const cardOpt = within(rendered.getAllByRole("listbox")[2]).getByRole("option", { name: "template.field.cardinality.1" });
-        await user.click(cardOpt);
-
-        // First: direct change emission
-        expect(onChange).toHaveBeenNthCalledWith(
-            1,
-            expect.anything(),
-            expect.objectContaining({ name: "field.cardinality", value: "1" })
-        );
-
-        // Then: clear mandatory because value ∈ ['1','+'] and mandatory was non-empty
-        expect(onChange).toHaveBeenNthCalledWith(
-            2,
-            expect.anything(),
-            { name: "field.mandatory", value: null }
-        );
+    // 3) subscribable=false
+    expect(onChange).toHaveBeenNthCalledWith(3, expect.anything(), {
+      name: "field.subscribable",
+      value: false,
     });
 
-    test("allowedWidgets & allowedTypes filter visible options (using real option generators)", () => {
-        const onChange = jest.fn();
-
-        const rendered = render(
-            <FieldDefinition
-                {...baseProps}
-                onChange={onChange}
-                allowedWidgets={["number"]}
-                allowedTypes={["float"]}
-                widget="number"
-                type="float"
-            />
-        );
-
-        waitForLoad(rendered);
-
-        const dropdowns = rendered.getAllByRole("listbox");
-        expect(dropdowns.length).toBe(3);
-
-        const widgetDropdown = dropdowns[0];
-        expect(widgetDropdown).toHaveAttribute("name", "field.widget");
-        const widgetOptions = within(widgetDropdown).getAllByRole("option");
-        expect(widgetOptions.length).toBe(1);
-        expect(widgetOptions[0]).toHaveAttribute("aria-checked", "true");
-        expect(widgetOptions[0]).toHaveTextContent("Number");
-
-        const typeDropdown = dropdowns[1];
-        expect(typeDropdown).toHaveAttribute("name", "field.type");
-        const typeOptions = within(typeDropdown).getAllByRole("option");
-        expect(typeOptions.length).toBe(1);
-        expect(typeOptions[0]).toHaveAttribute("aria-checked", "true");
-        expect(typeOptions[0]).toHaveTextContent("float");
+    // 4) widget change payload
+    expect(onChange).toHaveBeenNthCalledWith(
+      4,
+      expect.anything(),
+      expect.objectContaining({ name: "field.type", value: "domain" }),
+    );
+  });
+
+  test("useEffect: auto-fixes invalid type/cardinality for a widget (real WIDGETS)", () => {
+    const onChange = jest.fn();
+
+    // For widget='number', valid types: ['integer','float']; cardinalities: ['?','1']
+    // Provide invalid type 'string' and invalid cardinality '+'
+    const rendered = render(
+      <FieldDefinition
+        {...baseProps}
+        onChange={onChange}
+        widget="number"
+        type="string"
+        cardinality="+"
+      />,
+    );
+
+    waitForLoad(rendered);
+
+    // The effect should fire once and fix both:
+    expect(onChange).toHaveBeenCalledWith(
+      null,
+      { name: "field.type", value: "integer" }, // first in WIDGETS types for 'number'
+    );
+    expect(onChange).toHaveBeenCalledWith(
+      null,
+      { name: "field.cardinality", value: "?" }, // first in WIDGETS cardinalities for 'number'
+    );
+  });
+
+  test("handleCardinalityChange: selecting '1' (or '+') clears mandatory when it's non-empty", async () => {
+    const onChange = jest.fn();
+
+    const rendered = render(
+      <FieldDefinition
+        {...baseProps}
+        onChange={onChange}
+        widget="string"
+        type="string"
+        cardinality="?"
+        mandatory={{ some: "value" }}
+      />,
+    );
+
+    waitForLoad(rendered);
+
+    // Select exactly-one '1'
+    const cardOpt = within(rendered.getAllByRole("listbox")[2]).getByRole(
+      "option",
+      { name: "template.field.cardinality.1" },
+    );
+    await user.click(cardOpt);
+
+    // First: direct change emission
+    expect(onChange).toHaveBeenNthCalledWith(
+      1,
+      expect.anything(),
+      expect.objectContaining({ name: "field.cardinality", value: "1" }),
+    );
+
+    // Then: clear mandatory because value ∈ ['1','+'] and mandatory was non-empty
+    expect(onChange).toHaveBeenNthCalledWith(2, expect.anything(), {
+      name: "field.mandatory",
+      value: null,
     });
+  });
+
+  test("allowedWidgets & allowedTypes filter visible options (using real option generators)", () => {
+    const onChange = jest.fn();
+
+    const rendered = render(
+      <FieldDefinition
+        {...baseProps}
+        onChange={onChange}
+        allowedWidgets={["number"]}
+        allowedTypes={["float"]}
+        widget="number"
+        type="float"
+      />,
+    );
+
+    waitForLoad(rendered);
+
+    const dropdowns = rendered.getAllByRole("listbox");
+    expect(dropdowns.length).toBe(3);
+
+    const widgetDropdown = dropdowns[0];
+    expect(widgetDropdown).toHaveAttribute("name", "field.widget");
+    const widgetOptions = within(widgetDropdown).getAllByRole("option");
+    expect(widgetOptions.length).toBe(1);
+    expect(widgetOptions[0]).toHaveAttribute("aria-checked", "true");
+    expect(widgetOptions[0]).toHaveTextContent("Number");
+
+    const typeDropdown = dropdowns[1];
+    expect(typeDropdown).toHaveAttribute("name", "field.type");
+    const typeOptions = within(typeDropdown).getAllByRole("option");
+    expect(typeOptions.length).toBe(1);
+    expect(typeOptions[0]).toHaveAttribute("aria-checked", "true");
+    expect(typeOptions[0]).toHaveTextContent("float");
+  });
 });

package/src/templates/components/templateForm/__tests__/FieldForm.spec.js

@@ -55,7 +55,9 @@ describe("<FieldForm />", () => {
     const rendered = render(<FieldForm {...props} />);
     await waitForLoad(rendered);
     expect(
-      rendered.container.querySelector("input[name='undefined.fields[0].name']")
+      rendered.container.querySelector(
+        "input[name='undefined.fields[0].name']",
+      ),
     ).toHaveAttribute("disabled");
   });
 
@@ -89,7 +91,7 @@ describe("<FieldForm />", () => {
 
     const user = userEvent.setup({ delay: null });
     const fixedTupleOption = rendered.getByText(
-      "template.field.values.fixed_tuple"
+      "template.field.values.fixed_tuple",
     );
     await user.click(fixedTupleOption);
 
@@ -98,7 +100,7 @@ describe("<FieldForm />", () => {
       expect.objectContaining({
         name: "Group.fields[0].subscribable",
         value: false,
-      })
+      }),
     );
     expect(onChange).toHaveBeenCalledWith(null, {
       name: "Group.fields[0].values",
@@ -153,7 +155,7 @@ describe("<FieldForm />", () => {
       expect.anything(),
       expect.objectContaining({
         value: "string",
-      })
+      }),
     );
   });
 
@@ -193,27 +195,27 @@ describe("<FieldForm />", () => {
       expect.objectContaining({
         name: "Group.fields[0].values",
         value: { fixed: null },
-      })
+      }),
     );
     expect(onChange).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
         name: "Group.fields[0].default",
         value: { value: "", origin: "default" },
-      })
+      }),
     );
     expect(onChange).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
         name: "Group.fields[0].subscribable",
         value: false,
-      })
+      }),
     );
     expect(onChange).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
         value: "string",
-      })
+      }),
     );
   });
 
@@ -271,7 +273,7 @@ describe("<FieldForm />", () => {
     await waitForLoad(rendered);
     expect(rendered.container).toMatchSnapshot();
     expect(
-      rendered.getByText(/template.field.mandatory.depends.to_be/i)
+      rendered.getByText(/template.field.mandatory.depends.to_be/i),
     ).toBeInTheDocument();
   });
 
@@ -340,7 +342,7 @@ describe("<FieldForm />", () => {
       expect.objectContaining({
         name: "Group.fields[0].cardinality",
         value: "1",
-      })
+      }),
     );
     expect(onChange).toHaveBeenCalledWith(expect.anything(), {
       name: "Group.fields[0].mandatory",

package/src/templates/components/templateForm/__tests__/MandatoryConditional.spec.js

@@ -54,7 +54,7 @@ describe("<MandatoryConditional />", () => {
   it("matches the latest snapshot", () => {
     const { container } = render(
       <MandatoryConditional {...props} />,
-      renderOpts
+      renderOpts,
     );
     expect(container).toMatchSnapshot();
   });
@@ -62,7 +62,7 @@ describe("<MandatoryConditional />", () => {
   it("calls onChange when whe select a field", async () => {
     const { findByRole } = render(
       <MandatoryConditional {...props} />,
-      renderOpts
+      renderOpts,
     );
 
     userEvent.click(await findByRole("option", { name: /Foo/ }));
@@ -82,7 +82,7 @@ describe("<MandatoryConditional />", () => {
     onChange.mockClear();
     const { findByRole } = render(
       <MandatoryConditional {...props} />,
-      renderOpts
+      renderOpts,
     );
 
     userEvent.click(await findByRole("option", { name: /4/ }));

package/src/templates/components/templateForm/__tests__/SwitchListForm.spec.js

@@ -40,7 +40,7 @@ describe("<SwitchListForm />", () => {
     await waitForLoad(rendered);
 
     const input = rendered.getByPlaceholderText(
-      /template.field.values.switch_field/i
+      /template.field.values.switch_field/i,
     );
     await user.type(input, "1");
     expect(onChange).toHaveBeenCalledWith({ ...values, on: "test1" });
@@ -64,7 +64,7 @@ describe("<SwitchListForm />", () => {
     await waitForLoad(rendered);
 
     const deleteButton = rendered.container.querySelectorAll(
-      ".remove.circle.link.icon"
+      ".remove.circle.link.icon",
     )[0];
     await user.click(deleteButton);
     expect(onChange).toHaveBeenCalledWith({
@@ -91,7 +91,7 @@ describe("<SwitchListForm />", () => {
     await waitForLoad(rendered);
 
     const valueInput = rendered.getAllByPlaceholderText(
-      /template.field.values.add_value/i
+      /template.field.values.add_value/i,
     )[0];
     await user.clear(valueInput);
     await user.type(valueInput, "5{enter}");
@@ -123,7 +123,7 @@ describe("<SwitchListForm />", () => {
     await waitForLoad(rendered);
 
     const newValueInput = rendered.container.querySelector(
-      "input[placeholder='template.field.values.add_switch_value']"
+      "input[placeholder='template.field.values.add_switch_value']",
     );
     await user.type(newValueInput, "Test");
     await user.keyboard("{Enter}");
@@ -156,7 +156,7 @@ describe("<SwitchListForm />", () => {
     await waitForLoad(rendered);
 
     const newValueInput = rendered.getByPlaceholderText(
-      /template.field.values.add_switch_value/i
+      /template.field.values.add_switch_value/i,
     );
     await user.type(newValueInput, "a");
 

package/src/templates/components/templateForm/__tests__/SwitchSegment.spec.js

@@ -39,22 +39,22 @@ describe("<SwitchSegment />", () => {
     const user = userEvent.setup({ delay: null });
     await user.click(
       rendered.container.querySelectorAll(
-        '[class="circle outline link icon"]'
-      )[0]
+        '[class="circle outline link icon"]',
+      )[0],
     );
     expect(onDefaultValueChange).toHaveBeenCalledWith({ 1: "foo" });
 
     await user.click(
       rendered.container.querySelectorAll(
-        '[class="circle outline link icon"]'
-      )[1]
+        '[class="circle outline link icon"]',
+      )[1],
     );
     expect(onDefaultValueChange).toHaveBeenCalledWith({ 1: "bar" });
 
     await user.click(
       rendered.container.querySelectorAll(
-        '[class="circle outline link icon"]'
-      )[2]
+        '[class="circle outline link icon"]',
+      )[2],
     );
     expect(onDefaultValueChange).toHaveBeenCalledWith({ 1: "baz" });
   });
@@ -68,8 +68,8 @@ describe("<SwitchSegment />", () => {
     const user = userEvent.setup({ delay: null });
     await user.click(
       rendered.container.querySelector(
-        '[class="check circle outline link icon"]'
-      )
+        '[class="check circle outline link icon"]',
+      ),
     );
     expect(onDefaultValueChange).toHaveBeenCalledWith({});
   });