chore: cover v7 changes — compat fallback exempt from coverage, add state/events/composer tests

Author: foxhound87

src/compat.ts

@@ -37,6 +37,11 @@ export const makeObservable = (target: any, annotations: Annotations): any => {
     return M.makeObservable(target, annotations);
   }
 
+  return fallbackMakeObservable(target, annotations);
+};
+
+/* istanbul ignore next -- MobX 5 only: no makeObservable in 5.x and no decorate in 6/7, not runnable on the MobX 6/7 test matrix */
+function fallbackMakeObservable(target: any, annotations: Annotations): any {
   const members = Object.entries(annotations).filter(([key]) =>
     key in target
   );

tests/unit/test.composer.ts

@@ -179,4 +179,27 @@ describe("Composer", () => {
     expect(wizard.select("step1").isPristine).to.be.true;
     expect(wizard.select("step2").isPristine).to.be.true;
   });
+
+  it("should accept explicit option objects for clear/reset (default-arg branches)", () => {
+    const wizard = buildWizard();
+
+    wizard.select("step1").$("email").value = "test@test.com";
+
+    expect(() => wizard.clear({ deep: false })).to.not.throw();
+    expect(() => wizard.reset({ deep: true, execHook: true })).to.not.throw();
+
+    expect(wizard.get("value").step1.email).to.equal("");
+  });
+
+  it("should accept explicit option objects for validate/submit (default-arg branches)", () => {
+    const wizard = buildWizard();
+
+    return wizard
+      .validate({ showErrors: false })
+      .then(() => wizard.submit({ validate: false, execOnSubmitHook: true, execValidationHooks: true }))
+      .then((result: any) => {
+        expect(result.valid).to.be.false;
+        expect(result.error).to.be.true;
+      });
+  });
 });

tests/unit/test.events.field.ts

@@ -238,6 +238,29 @@ describe("Field Event Handlers", () => {
       expect(field.files).to.have.lengthOf(1);
       expect(field.files[0]).to.deep.equal(file);
     });
+
+    it("should dedupe repeated drops of the same file (FIXES row 28)", () => {
+      const fileA = { name: "a.txt", size: 10, lastModified: 1700000000000 };
+      const fileB = { name: "b.txt", size: 20, lastModified: 1700000000001 };
+
+      field.onDrop(fileA);
+      field.onDrop({ ...fileA });
+      field.onDrop(fileB);
+
+      expect(field.files).to.have.lengthOf(2);
+      expect(field.files.map((f: any) => f.name)).to.have.members([
+        "a.txt",
+        "b.txt",
+      ]);
+    });
+
+    it("should keep a distinct file whose size differs only in lastModified", () => {
+      const base = { name: "a.txt", size: 10, lastModified: 1700000000000 };
+      field.onDrop(base);
+      field.onDrop({ name: "a.txt", size: 10, lastModified: 1700000000002 });
+
+      expect(field.files).to.have.lengthOf(2);
+    });
   });
 
   describe("focus() and blur() actions", () => {

tests/unit/test.state.ts

@@ -1,5 +1,6 @@
 import { expect } from "chai";
 import Form from "../../src/Form";
+import vjf from "../../src/validators/VJF";
 import { StateInterface } from "../../src/models/StateInterface";
 
 describe("State — extra() coverage", () => {
@@ -172,3 +173,111 @@ describe("State — observeOptions exec callbacks", () => {
     expect(form.state.options.get("validateOnChange")).to.be.false;
   });
 });
+
+describe("State — set() current subtype", () => {
+  it("should assign only the current subtype (not initial)", () => {
+    const form = new Form({
+      fields: { k: { label: "K", value: "v" } },
+    });
+    const state: any = (form as any).state;
+
+    state.set("current", "props", { marker: "current-only" });
+
+    expect(state.current.props.marker).to.equal("current-only");
+    expect(state.initial.props.marker).to.be.undefined;
+  });
+});
+
+describe("State — dispose guards on fields without observers", () => {
+  it("validateOnChange -> false skips fields without disposeValidationOnChange", () => {
+    const form = new Form(
+      {
+        fields: {
+          email: {
+            label: "Email",
+            value: "x",
+            rules: "required",
+            options: { validateOnChange: false } as any,
+          },
+        },
+      },
+      { name: "Guard1", options: { validateOnChange: true } as any }
+    );
+
+    expect(() =>
+      form.state.options.set({ validateOnChange: false })
+    ).to.not.throw();
+    expect(form.state.options.get("validateOnChange")).to.be.false;
+  });
+
+  it("validateOnBlur -> false skips fields without disposeValidationOnBlur", () => {
+    const form = new Form(
+      {
+        fields: {
+          email: {
+            label: "Email",
+            value: "x",
+            rules: "required",
+            options: { validateOnBlur: false } as any,
+          },
+        },
+      },
+      { name: "Guard2", options: { validateOnBlur: true } as any }
+    );
+
+    expect(() =>
+      form.state.options.set({ validateOnBlur: false })
+    ).to.not.throw();
+    expect(form.state.options.get("validateOnBlur")).to.be.false;
+  });
+});
+
+describe("Form — deep showErrors() and resetValidation()", () => {
+  it("should propagate deep and accept shallow flag", async () => {
+    const form = new Form(
+      {
+        fields: {
+          email: {
+            label: "Email",
+            value: "",
+            validators: [
+              ({ field }: any) => (field.value ? true : "Email required"),
+            ],
+          },
+          nested: {
+            fields: [
+              {
+                name: "user",
+                label: "User",
+                value: "",
+                validators: [
+                  ({ field }: any) => (field.value ? true : "User required"),
+                ],
+              },
+            ],
+          },
+        },
+      },
+      {
+        name: "Deep",
+        plugins: { vjf: vjf() },
+        options: { validateOnInit: false } as any,
+      }
+    );
+
+    await form.validate({ showErrors: false });
+
+    expect(form.hasError).to.be.true;
+
+    form.showErrors(true);
+    expect(form.$("email").hasError).to.be.true;
+
+    form.showErrors(false);
+    expect(form.$("email").hasError).to.be.true;
+
+    form.resetValidation();
+    form.resetValidation(false);
+    expect(form.validator.error).to.be.null;
+    expect(form.$("email").error).to.be.null;
+  });
+});