import { describe, expect, it } from "@effect/vitest";import * as Option from "effect/Option";import * as Schema from "effect/Schema"; import {  coerceNumber,  defaultForSchema,  isRenderableObjectSchema,  missingRequiredFields,  removeProperty,  setProperty,} from "./json-schema-form"; // Mirror the panel's decode boundary so the round-trip assertions use the exact// same path the production code uses (no raw JSON.parse).const decodeArgsJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString); const SCHEMA = {  type: "object",  required: ["email"],  properties: {    email: { type: "string" },    age: { type: "integer" },    tags: { type: "array", items: { type: "string" } },    role: { enum: ["a", "b"] },  },} as const; describe("missingRequiredFields (Run gate)", () => {  it("reports unfilled required args, ignores optionals, never gates without required", () => {    // unset / empty-string / null required → still missing (Run stays disabled)    expect(missingRequiredFields(SCHEMA, undefined, {})).toEqual(["email"]);    expect(missingRequiredFields(SCHEMA, undefined, { email: "" })).toEqual(["email"]);    expect(missingRequiredFields(SCHEMA, undefined, { email: null })).toEqual(["email"]);    // present + non-empty required → nothing missing; optionals never gate    expect(missingRequiredFields(SCHEMA, undefined, { email: "a@b.c" })).toEqual([]);    expect(missingRequiredFields(SCHEMA, undefined, { email: "a@b.c", age: 0 })).toEqual([]);    // no required / no schema → never gates a zero-arg or schema-less tool    expect(missingRequiredFields({ type: "object", properties: {} }, undefined, {})).toEqual([]);    expect(missingRequiredFields(null, undefined, {})).toEqual([]);  });}); describe("json-schema-form value transforms", () => {  it("lossless round-trip with object + nested array + enum (omit-unset)", () => {    const valueIn: Record<string, unknown> = {      email: "x@y.z",      tags: ["p"],      role: "a",    };     // Edit email, then append a tag — the rebuilds the form would produce.    const afterEmail = setProperty(valueIn, "email", "q@y.z");    const tags = Array.isArray(afterEmail.tags) ? afterEmail.tags : [];    const rebuilt = setProperty(afterEmail, "tags", [...tags, "r"]);     const json = JSON.stringify(rebuilt, null, 2);    const decoded = decodeArgsJson(json);     expect(Option.isSome(decoded)).toBe(true);    const value = Option.getOrElse(decoded, () => ({}) as unknown);    expect(value).toEqual({ email: "q@y.z", tags: ["p", "r"], role: "a" });    // `age` was never present — it must not appear after the round-trip.    expect(Object.keys(value as object).sort()).toEqual(["email", "role", "tags"]);  });   it("omit-unset-optional: editing only required field never invents optional keys", () => {    const rebuilt = setProperty({}, "email", "a@b.c");    expect(Object.keys(rebuilt)).toEqual(["email"]);    // No `null` placeholders serialized for omitted optionals.    expect(JSON.stringify(rebuilt)).toBe('{"email":"a@b.c"}');  });   it("removeProperty deletes an optional key and leaves siblings intact", () => {    const value: Record<string, unknown> = { email: "x@y.z", age: 30 };    const next = removeProperty(value, "age");    expect("age" in next).toBe(false);    expect(next).toEqual({ email: "x@y.z" });    // Original is not mutated.    expect("age" in value).toBe(true);  });   it("number coercion stores JS numbers, not strings, and round-trips as JSON number", () => {    const next = setProperty({}, "age", coerceNumber("123", true));    expect(next.age).toBe(123);    expect(typeof next.age).toBe("number");    expect(JSON.stringify(next)).toBe('{"age":123}');     // Invalid input yields undefined (caller keeps last-valid; never emits it).    expect(coerceNumber("abc", true)).toBeUndefined();    expect(coerceNumber("", false)).toBeUndefined();    // Integer truncation.    expect(coerceNumber("3.9", true)).toBe(3);    expect(coerceNumber("3.5", false)).toBe(3.5);  });   it("defaultForSchema seeds the right empty value per type", () => {    const root = { $defs: {} };    expect(defaultForSchema({ type: "string" }, root)).toBe("");    expect(defaultForSchema({ type: "integer" }, root)).toBe(0);    expect(defaultForSchema({ type: "boolean" }, root)).toBe(false);    expect(defaultForSchema({ type: "object" }, root)).toEqual({});    expect(defaultForSchema({ type: "array" }, root)).toEqual([]);    expect(defaultForSchema({ enum: ["a", "b"] }, root)).toBe("a");    expect(defaultForSchema({ const: 7 }, root)).toBe(7);  });   it("isRenderableObjectSchema gates form-mode availability", () => {    expect(isRenderableObjectSchema(SCHEMA)).toBe(true);     // $ref resolving (via definitions) to an object is renderable.    expect(      isRenderableObjectSchema(        { $ref: "#/$defs/Args" },        { Args: { type: "object", properties: { a: { type: "string" } } } },      ),    ).toBe(true);     expect(isRenderableObjectSchema({ type: "string" })).toBe(false);    expect(isRenderableObjectSchema(undefined)).toBe(false);    // Unresolvable $ref → not renderable.    expect(isRenderableObjectSchema({ $ref: "#/$defs/Missing" })).toBe(false);  });   it("invalid / non-object JSON disables the Form tab (the toggle guard)", () => {    const parsedArgsFor = (raw: string): Record<string, unknown> | null => {      const decoded = decodeArgsJson(raw);      if (Option.isNone(decoded)) return null;      const v = decoded.value;      return typeof v === "object" && v !== null && !Array.isArray(v)        ? (v as Record<string, unknown>)        : null;    };    const formDisabled = (schemaAvailable: boolean, parsed: Record<string, unknown> | null) =>      !schemaAvailable || parsed === null;     // Malformed JSON → parsedArgs null → Form tab un-selectable.    expect(parsedArgsFor("{ broken")).toBeNull();    expect(formDisabled(true, parsedArgsFor("{ broken"))).toBe(true);     // Valid but non-object JSON also yields null.    expect(parsedArgsFor("[]")).toBeNull();    expect(parsedArgsFor("5")).toBeNull();    expect(formDisabled(true, parsedArgsFor("5"))).toBe(true);     // Valid object + available schema → form enabled.    expect(parsedArgsFor('{"email":"x@y.z"}')).toEqual({ email: "x@y.z" });    expect(formDisabled(true, parsedArgsFor('{"email":"x@y.z"}'))).toBe(false);  });});