@assistant-ui/react-generative-ui 0.0.21 → 0.0.23

package/src/teams/temporal.test.ts

@@ -0,0 +1,766 @@
+import { describe, expect, it } from "vitest";
+import type { TeamsInputTime } from "../teams";
+import type { TeamsTemporalField } from "./types";
+import { decodeSubmitData } from "./decodeSubmitData";
+import { toAdaptiveCard } from "./toAdaptiveCard";
+import { encodeTemporalInputId } from "./temporalId";
+
+const picker = (inputType: "date" | "time" | "datetime", value: string) =>
+  toAdaptiveCard({
+    $type: "DatePicker",
+    name: "when",
+    label: "When",
+    inputType,
+    value,
+    $action: { type: "pick", selected: { $field: "when" } },
+  });
+
+const submit = (
+  inputType: "date" | "time" | "datetime",
+  value: string,
+  overrides: Record<string, string> = {},
+) => {
+  const { card, warnings } = picker(inputType, value);
+  const inputs = card.body.filter(
+    (element) => element.type === "Input.Date" || element.type === "Input.Time",
+  );
+  const actionSet = card.body.find((element) => element.type === "ActionSet");
+  if (actionSet?.type !== "ActionSet") throw new Error("Missing submit action");
+  const values = Object.fromEntries(
+    inputs.map((input) => [
+      input.id,
+      overrides[
+        inputType === "datetime"
+          ? input.type === "Input.Time"
+            ? "when_time"
+            : "when"
+          : input.id
+      ] ??
+        input.value ??
+        "",
+    ]),
+  );
+  const decoded = decodeSubmitData({
+    ...actionSet.actions[0]!.data,
+    ...values,
+  });
+  return { inputs, action: actionSet.actions[0]!, decoded, warnings };
+};
+
+describe("Teams temporal DatePicker", () => {
+  it.each(["Input", "DatePicker"])(
+    "round trips a %s named in the datetime namespace",
+    ($type) => {
+      const name = "aui:datetime:when";
+      const { card, warnings } = toAdaptiveCard({
+        $type,
+        name,
+        inputType: "datetime",
+        value: "2025-12-15T17:00:30.123456Z",
+        $action: { type: "pick", selected: { $field: name } },
+      });
+      const inputs = card.body.filter((element) => "id" in element);
+      const action = card.body.find((element) => element.type === "ActionSet");
+      if (action?.type !== "ActionSet") throw new Error("Missing action");
+      const values = Object.fromEntries(
+        inputs.map((input) => [
+          input.id,
+          input.type === "Input.Date"
+            ? "2025-12-16"
+            : input.type === "Input.Time"
+              ? "18:20"
+              : "ordinary",
+        ]),
+      );
+      const selected =
+        $type === "DatePicker" ? "2025-12-16T18:20:30.123456Z" : "ordinary";
+      expect(
+        decodeSubmitData({ ...action.actions[0]!.data, ...values }),
+      ).toEqual({
+        type: "pick",
+        selected,
+        $input: { [`_${name}`]: selected },
+      });
+      expect(warnings).toContainEqual(
+        expect.objectContaining({ code: "fallback", component: $type }),
+      );
+    },
+  );
+
+  it("round trips distinct ordinary ids in the datetime namespace", () => {
+    const names = ["aui:datetime:x", "_aui:datetime:x", "__aui:datetime:x"];
+    const { card, warnings } = toAdaptiveCard([
+      {
+        $type: "Button",
+        label: "Save",
+        $action: {
+          type: "save",
+          selected: names.map((name) => ({ $field: name })),
+        },
+      },
+      ...names.map((name) => ({ $type: "Input", name })),
+    ]);
+    const action = card.body.find((element) => element.type === "ActionSet");
+    if (action?.type !== "ActionSet") throw new Error("Missing action");
+    const inputs = card.body.filter((element) => element.type === "Input.Text");
+    expect(inputs.map((input) => input.id)).toEqual(
+      names.map((name) => `_${name}`),
+    );
+    const values = Object.fromEntries(
+      inputs.map((input, index) => [input.id, String(index)]),
+    );
+    expect(decodeSubmitData({ ...action.actions[0]!.data, ...values })).toEqual(
+      {
+        type: "save",
+        selected: ["0", "1", "2"],
+        $input: values,
+      },
+    );
+    expect(warnings).toEqual([
+      expect.objectContaining({ code: "fallback", component: "Input" }),
+      expect.objectContaining({ code: "fallback", component: "Input" }),
+      expect.objectContaining({ code: "fallback", component: "Input" }),
+    ]);
+  });
+
+  it("resolves adjacent escaped namespace ids in submission order", () => {
+    const { card } = toAdaptiveCard([
+      {
+        $type: "Button",
+        label: "Save",
+        $action: {
+          type: "save",
+          underscored: { $field: "_aui:datetime:x" },
+          plain: { $field: "aui:datetime:x" },
+        },
+      },
+      { $type: "Input", name: "_aui:datetime:x" },
+      { $type: "Input", name: "aui:datetime:x" },
+    ]);
+    const action = card.body[0];
+    if (action?.type !== "ActionSet") throw new Error("Missing action");
+    expect(
+      decodeSubmitData({
+        ...action.actions[0]!.data,
+        "__aui:datetime:x": "underscored value",
+        "_aui:datetime:x": "plain value",
+      }),
+    ).toEqual({
+      type: "save",
+      underscored: "underscored value",
+      plain: "plain value",
+      $input: {
+        "__aui:datetime:x": "underscored value",
+        "_aui:datetime:x": "plain value",
+      },
+    });
+  });
+
+  it.each(["aui:datetime:x", "_aui:datetime:x", "__aui:datetime:x"])(
+    "round trips datetime field %s through the reserved namespace",
+    (name) => {
+      const { card } = toAdaptiveCard({
+        $type: "DatePicker",
+        name,
+        inputType: "datetime",
+        value: "2025-12-15T17:00:30.123456Z",
+        $action: { type: "pick", selected: { $field: name } },
+      });
+      const inputs = card.body.filter(
+        (element) =>
+          element.type === "Input.Date" || element.type === "Input.Time",
+      );
+      const action = card.body.find((element) => element.type === "ActionSet");
+      if (action?.type !== "ActionSet") throw new Error("Missing action");
+      expect(inputs.map((input) => input.id)).toEqual([
+        `aui:datetime:date:${encodeURIComponent(`_${name}`)}`,
+        `aui:datetime:time:${encodeURIComponent(`_${name}`)}:2025-12-15T17%3A00%3A30.123456Z`,
+      ]);
+      expect(
+        decodeSubmitData({
+          ...action.actions[0]!.data,
+          [inputs[0]!.id]: "2025-12-16",
+          [inputs[1]!.id]: "18:20",
+        }),
+      ).toEqual({
+        type: "pick",
+        selected: "2025-12-16T18:20:30.123456Z",
+        $input: { [`_${name}`]: "2025-12-16T18:20:30.123456Z" },
+      });
+    },
+  );
+
+  describe.each([
+    "aui:datetime:",
+    "aui:datetime:date:when",
+    "aui:datetime:time:when:2025-12-15T17%3A00%3A00Z",
+  ])("ordinary input named %j", (name) => {
+    it.each([false, true])(
+      "stays separate from a datetime picker (input first: %s)",
+      (inputFirst) => {
+        const input = { $type: "Input", name };
+        const datetime = {
+          $type: "DatePicker",
+          name: "when",
+          inputType: "datetime",
+          value: "2025-12-15T17:00:00Z",
+        };
+        const { card } = toAdaptiveCard([
+          {
+            $type: "Button",
+            label: "Save",
+            $action: {
+              type: "save",
+              ordinary: { $field: name },
+              datetime: { $field: "when" },
+            },
+          },
+          ...(inputFirst ? [input, datetime] : [datetime, input]),
+        ]);
+        const action = card.body[0];
+        if (action?.type !== "ActionSet") throw new Error("Missing action");
+        const values = Object.fromEntries(
+          card.body.flatMap((element) => {
+            if (element.type === "Input.Text") {
+              expect(element.id).toBe(`_${name}`);
+              return [[element.id, "ordinary"]];
+            }
+            if (element.type === "Input.Date" || element.type === "Input.Time")
+              return [[element.id, element.value]];
+            return [];
+          }),
+        );
+        expect(
+          decodeSubmitData({ ...action.actions[0]!.data, ...values }),
+        ).toEqual({
+          type: "save",
+          ordinary: "ordinary",
+          datetime: "2025-12-15T17:00:00Z",
+          $input: { [`_${name}`]: "ordinary", when: "2025-12-15T17:00:00Z" },
+        });
+      },
+    );
+  });
+
+  it.each([
+    ["20:45:30", true],
+    ["20:45:00.000001", true],
+    ["20:45:30.000001", true],
+    ["20:45:00.000", false],
+    ["20:45", false],
+    ["2025-12-15T20:45:30Z", false],
+  ])("reports lost time maximum precision for %s", (max, dropped) => {
+    const { warnings } = toAdaptiveCard({
+      $type: "DatePicker",
+      inputType: "time",
+      max,
+    });
+    expect(warnings).toEqual(
+      dropped
+        ? [
+            {
+              code: "dropped",
+              component: "DatePicker",
+              detail:
+                max === "20:45:00.000001"
+                  ? "Nonzero fractional seconds were dropped from the time maximum."
+                  : max === "20:45:30.000001"
+                    ? "Nonzero seconds and fractional seconds were dropped from the time maximum."
+                    : "Nonzero seconds were dropped from the time maximum.",
+            },
+          ]
+        : [],
+    );
+  });
+
+  it.each(["datetime-local", "unknown", "", null, 42])(
+    "warns when an unsupported inputType %j falls back to date",
+    (inputType) => {
+      const { card, warnings } = toAdaptiveCard({
+        $type: "DatePicker",
+        inputType,
+        value: "2025-12-15",
+      });
+      expect(card.body).toEqual([
+        { type: "Input.Date", id: "datepicker", value: "2025-12-15" },
+      ]);
+      expect(warnings).toEqual([
+        {
+          code: "dropped",
+          component: "DatePicker",
+          detail:
+            "Unsupported inputType was dropped; the picker was rendered as a date input.",
+        },
+      ]);
+    },
+  );
+
+  it.each([
+    "__proto__",
+    "constructor",
+    "/dates/a:b % 🗓",
+    "lone-\uD800",
+    "lone-\uDC00",
+    "literal-%uD800",
+  ])("round trips the field name %j as an own property", (name) => {
+    const previousValue = "2025-12-15T17:00:30.123456-00:00";
+    const metadata: TeamsTemporalField = {
+      fieldId: name,
+      role: "time",
+      previousValue,
+    };
+    const { card } = toAdaptiveCard({
+      $type: "DatePicker",
+      name,
+      inputType: "datetime",
+      value: previousValue,
+      $action: { type: "pick", selected: { $field: name } },
+    });
+    const input = card.body[1] as TeamsInputTime;
+    const action = card.body[2];
+    if (action?.type !== "ActionSet") throw new Error("Missing action");
+    expect(input.id).toBe(encodeTemporalInputId(metadata));
+    const decoded = decodeSubmitData({
+      ...action.actions[0]!.data,
+      [encodeTemporalInputId({ fieldId: name, role: "date" })]: "2025-12-16",
+      [input.id]: "18:20",
+    });
+    expect(decoded).toEqual({
+      type: "pick",
+      selected: "2025-12-16T18:20:30.123456-00:00",
+      $input: { [name]: "2025-12-16T18:20:30.123456-00:00" },
+    });
+    expect(Object.hasOwn(decoded?.["$input"] as object, name)).toBe(true);
+    expect(Object.getPrototypeOf(decoded?.["$input"])).toBe(Object.prototype);
+  });
+
+  it("keeps each field's precision and offset scoped to its own date", () => {
+    const values = [
+      "2025-12-15T17:00:30.123456+02:00",
+      "2025-12-15T17:00:45-05:30",
+      "2025-12-15T17:00",
+    ];
+    const { card } = toAdaptiveCard(
+      values.map((value, index) => ({
+        $type: "DatePicker",
+        name: `when${index}`,
+        value,
+        inputType: "datetime",
+        $action: { type: "pick" },
+      })),
+    );
+    const inputs = Object.fromEntries(
+      card.body.flatMap((element) =>
+        element.type === "Input.Date"
+          ? [[element.id, "2025-12-16"]]
+          : element.type === "Input.Time"
+            ? [[element.id, "18:20"]]
+            : [],
+      ),
+    );
+    for (const element of card.body) {
+      if (element.type !== "ActionSet") continue;
+      expect(
+        decodeSubmitData({ ...element.actions[0]!.data, ...inputs }),
+      ).toEqual({
+        type: "pick",
+        $input: {
+          when0: "2025-12-16T18:20:30.123456+02:00",
+          when1: "2025-12-16T18:20:45-05:30",
+          when2: "2025-12-16T18:20",
+        },
+      });
+    }
+  });
+
+  it("carries metadata once per field and grows linearly with companion actions", () => {
+    const sizes = [20, 40, 80].map((count) => {
+      const { card } = toAdaptiveCard(
+        Array.from({ length: count }, (_, index) => ({
+          $type: "DatePicker",
+          name: `when${String(index).padStart(3, "0")}`,
+          inputType: "datetime",
+          value: "2025-12-15T17:00:30.123456+02:00",
+          $action: { type: "pick" },
+        })),
+      );
+      const serialized = JSON.stringify(card);
+      expect(
+        card.body.filter((item) => item.type === "ActionSet"),
+      ).toHaveLength(count);
+      expect(serialized.match(/aui:datetime:date:/g)).toHaveLength(count);
+      expect(serialized.match(/aui:datetime:time:/g)).toHaveLength(count);
+      expect(
+        serialized.match(/2025-12-15T17%3A00%3A30.123456%2B02%3A00/g),
+      ).toHaveLength(count);
+      expect(serialized).not.toContain('"temporal"');
+      return new TextEncoder().encode(serialized).length;
+    });
+    expect(sizes[2]! - sizes[1]!).toBe(2 * (sizes[1]! - sizes[0]!));
+  });
+
+  it.each(["", "2025-12-15T17:00", "2025-12-15T17:00:00+02:00"])(
+    "accepts date-only bounds on datetime %j",
+    (value) => {
+      const { card } = toAdaptiveCard({
+        $type: "DatePicker",
+        inputType: "datetime",
+        value,
+        min: "2025-12-14",
+        max: "2025-12-20",
+      });
+      expect(card.body[0]).toMatchObject({
+        type: "Input.Date",
+        min: "2025-12-14",
+        max: "2025-12-20",
+      });
+      expect(card.body[1]).not.toHaveProperty("min");
+      expect(card.body[1]).not.toHaveProperty("max");
+    },
+  );
+
+  it.each([
+    ["2025-12-15T17:00:30", true],
+    ["2025-12-15T17:00:00.000001", true],
+    ["2025-12-15T17:00:00.000", false],
+    ["2025-12-15T17:00", false],
+    ["2025-12-15T17:00:30.123Z", false],
+  ])("reports lost wall-clock precision for %s", (value, dropped) => {
+    const { warnings } = picker("datetime", value);
+    expect(warnings.filter((warning) => warning.code === "dropped")).toEqual(
+      dropped
+        ? [
+            {
+              code: "dropped",
+              component: "DatePicker",
+              detail: "Nonzero seconds were dropped from the datetime value.",
+            },
+          ]
+        : [],
+    );
+  });
+
+  it("keeps date mode as one Input.Date with its submitted value", () => {
+    const result = submit("date", "2025-12-15");
+    expect(result.inputs).toEqual([
+      { type: "Input.Date", id: "when", label: "When", value: "2025-12-15" },
+    ]);
+    expect(result.decoded).toEqual({
+      type: "pick",
+      selected: "2025-12-15",
+      $input: { when: "2025-12-15" },
+    });
+  });
+
+  it.each([
+    ["17:00", false],
+    ["17:00:30", true],
+  ])("round trips time %s as an Input.Time minute", (value, dropped) => {
+    const result = submit("time", value);
+    expect(result.inputs).toEqual([
+      { type: "Input.Time", id: "when", label: "When", value: "17:00" },
+    ]);
+    expect(result.action.data.aui).not.toHaveProperty("temporal");
+    expect(result.decoded).toEqual({
+      type: "pick",
+      selected: "17:00",
+      $input: { when: "17:00" },
+    });
+    expect(
+      result.warnings.some(
+        (warning) =>
+          warning.code === "dropped" && warning.component === "DatePicker",
+      ),
+    ).toBe(dropped);
+  });
+
+  it("rounds a time minimum up and truncates a time maximum to HH:mm", () => {
+    const { card } = toAdaptiveCard({
+      $type: "DatePicker",
+      inputType: "time",
+      value: "17:00:30",
+      min: "08:15:30",
+      max: "20:45:30",
+    });
+    expect(card.body).toEqual([
+      {
+        type: "Input.Time",
+        id: "datepicker",
+        value: "17:00",
+        min: "08:16",
+        max: "20:45",
+      },
+    ]);
+  });
+
+  it("drops a time minimum that rounds past 23:59", () => {
+    const { card, warnings } = toAdaptiveCard({
+      $type: "DatePicker",
+      inputType: "time",
+      min: "23:59:30",
+    });
+    expect(card.body).toEqual([{ type: "Input.Time", id: "datepicker" }]);
+    expect(warnings).toEqual([
+      {
+        code: "dropped",
+        component: "DatePicker",
+        detail: "The time minimum rounds past 23:59 and was dropped.",
+      },
+    ]);
+  });
+
+  it.each([
+    ["2025-12-15T17:00:00Z", "When time (UTC)"],
+    ["2025-12-15T17:00:00+02:00", "When time (UTC+02:00)"],
+    ["2025-12-15T17:00", "When time"],
+    ["", "When time"],
+  ])(
+    "round trips datetime %j through the paired inputs",
+    (value, timeLabel) => {
+      const result = submit("datetime", value);
+      expect(result.inputs).toEqual([
+        {
+          type: "Input.Date",
+          id: "aui:datetime:date:when",
+          label: "When",
+          ...(value ? { value: "2025-12-15" } : {}),
+        },
+        {
+          type: "Input.Time",
+          id:
+            value.endsWith("Z") || value.endsWith("+02:00")
+              ? encodeTemporalInputId({
+                  fieldId: "when",
+                  role: "time",
+                  previousValue: value,
+                })
+              : "aui:datetime:time:when:",
+          label: timeLabel,
+          ...(value ? { value: "17:00" } : {}),
+        },
+      ]);
+      expect(result.action.data.aui).not.toHaveProperty("temporal");
+      expect(result.decoded).toEqual({
+        type: "pick",
+        selected: value,
+        $input: { when: value },
+      });
+    },
+  );
+
+  it.each([
+    ["2025-12-15T17:00", "When time"],
+    ["2025-12-15T17:00:00Z", "When time (UTC)"],
+    ["2025-12-15T17:00:00+02:00", "When time (UTC+02:00)"],
+  ])("labels both datetime inputs for %s", (value, timeLabel) => {
+    const { card } = picker("datetime", value);
+    expect(card.body.slice(0, 2)).toMatchObject([
+      { type: "Input.Date", label: "When" },
+      { type: "Input.Time", label: timeLabel },
+    ]);
+  });
+
+  it("names only the offset of an unlabeled instant", () => {
+    const { card } = toAdaptiveCard({
+      $type: "DatePicker",
+      name: "when",
+      inputType: "datetime",
+      value: "2025-12-15T17:00:00Z",
+    });
+    expect(card.body).toEqual([
+      { type: "Input.Date", id: "aui:datetime:date:when", value: "2025-12-15" },
+      {
+        type: "Input.Time",
+        id: "aui:datetime:time:when:2025-12-15T17%3A00%3A00Z",
+        label: "Time (UTC)",
+        value: "17:00",
+      },
+    ]);
+  });
+
+  it("leaves both datetime inputs unlabeled for an unlabeled local value", () => {
+    const { card } = toAdaptiveCard({
+      $type: "DatePicker",
+      name: "when",
+      inputType: "datetime",
+      value: "2025-12-15T17:00",
+    });
+    expect(card.body).toEqual([
+      { type: "Input.Date", id: "aui:datetime:date:when", value: "2025-12-15" },
+      { type: "Input.Time", id: "aui:datetime:time:when:", value: "17:00" },
+    ]);
+  });
+
+  it("submits a newly selected empty datetime as a local wall minute", () => {
+    const result = submit("datetime", "", {
+      when: "2025-12-15",
+      when_time: "17:00",
+    });
+    expect(result.decoded).toEqual({
+      type: "pick",
+      selected: "2025-12-15T17:00",
+      $input: { when: "2025-12-15T17:00" },
+    });
+  });
+
+  describe.each(["2025-12-15T17:00:00Z", "2025-12-15T17:00", ""])(
+    "clearing datetime %j",
+    (value) => {
+      it.each([
+        { when: "", when_time: "17:00" },
+        { when: "2025-12-15", when_time: "" },
+      ])(
+        "clears the field when either datetime half is empty (%j)",
+        (overrides) => {
+          expect(submit("datetime", value, overrides).decoded).toEqual({
+            type: "pick",
+            selected: "",
+            $input: { when: "" },
+          });
+        },
+      );
+    },
+  );
+
+  it("keeps the instant's offset spelling and fractional precision after an edit", () => {
+    const result = submit("datetime", "2025-12-15T17:00:30.123456-00:00", {
+      when: "2025-12-16",
+      when_time: "18:20",
+    });
+    expect(result.decoded?.["selected"]).toBe(
+      "2025-12-16T18:20:30.123456-00:00",
+    );
+  });
+
+  it("uses the instant's date parts for bounds and leaves its time unbounded", () => {
+    const { card } = toAdaptiveCard({
+      $type: "DatePicker",
+      name: "when",
+      label: "When",
+      inputType: "datetime",
+      value: "2025-12-15T17:00:00+02:00",
+      min: "2025-12-14T23:30:00Z",
+      max: "2025-12-20T23:30:00Z",
+    });
+    expect(card.body).toEqual([
+      {
+        type: "Input.Date",
+        id: "aui:datetime:date:when",
+        label: "When",
+        value: "2025-12-15",
+        min: "2025-12-15",
+        max: "2025-12-21",
+      },
+      {
+        type: "Input.Time",
+        id: "aui:datetime:time:when:2025-12-15T17%3A00%3A00%2B02%3A00",
+        label: "When time (UTC+02:00)",
+        value: "17:00",
+      },
+    ]);
+  });
+
+  it("resolves $field references in an action before the paired inputs", () => {
+    const { card } = toAdaptiveCard([
+      {
+        $type: "Button",
+        label: "Save",
+        $action: { type: "save", selected: { $field: "when" } },
+      },
+      {
+        $type: "DatePicker",
+        name: "when",
+        inputType: "datetime",
+        value: "2025-12-15T17:00:00Z",
+      },
+    ]);
+    const button = card.body[0];
+    if (button?.type !== "ActionSet") throw new Error("Missing button");
+    expect(
+      decodeSubmitData({
+        ...button.actions[0]!.data,
+        "aui:datetime:date:when": "2025-12-16",
+        "aui:datetime:time:when:2025-12-15T17%3A00%3A00Z": "18:20",
+      }),
+    ).toEqual({
+      type: "save",
+      selected: "2025-12-16T18:20:00Z",
+      $input: { when: "2025-12-16T18:20:00Z" },
+    });
+  });
+
+  it("reserves both datetime ids when another input already uses the time id", () => {
+    const { card } = toAdaptiveCard([
+      { $type: "Input", name: "when_time" },
+      {
+        $type: "DatePicker",
+        name: "when",
+        inputType: "datetime",
+        value: "2025-12-15T17:00",
+        $action: { type: "pick", selected: { $field: "when" } },
+      },
+    ]);
+    expect(
+      card.body.map((element) => ("id" in element ? element.id : undefined)),
+    ).toEqual([
+      "when_time",
+      "aui:datetime:date:when",
+      "aui:datetime:time:when:",
+      undefined,
+    ]);
+    const actionSet = card.body[3];
+    if (actionSet?.type !== "ActionSet") throw new Error("Missing action");
+    expect(
+      decodeSubmitData({
+        ...actionSet.actions[0]!.data,
+        when_time: "other",
+        "aui:datetime:date:when": "2025-12-15",
+        "aui:datetime:time:when:": "17:00",
+      }),
+    ).toEqual({
+      type: "pick",
+      selected: "2025-12-15T17:00",
+      $input: { when_time: "other", when: "2025-12-15T17:00" },
+    });
+  });
+
+  it("keeps the reserved aui key for the action envelope", () => {
+    const { card } = toAdaptiveCard({
+      $type: "DatePicker",
+      name: "aui",
+      inputType: "datetime",
+      value: "2025-12-15T17:00",
+      $action: { type: "pick" },
+    });
+    expect(
+      card.body.map((element) => ("id" in element ? element.id : undefined)),
+    ).toEqual(["aui:datetime:date:aui_", "aui:datetime:time:aui_:", undefined]);
+    const actionSet = card.body[2];
+    if (actionSet?.type !== "ActionSet") throw new Error("Missing action");
+    expect(
+      decodeSubmitData({
+        ...actionSet.actions[0]!.data,
+        "aui:datetime:date:aui_": "2025-12-15",
+        "aui:datetime:time:aui_:": "17:00",
+      }),
+    ).toEqual({ type: "pick", $input: { aui_: "2025-12-15T17:00" } });
+  });
+
+  it("uses a field fallback when neither datetime input was submitted", () => {
+    const { card } = toAdaptiveCard({
+      $type: "DatePicker",
+      name: "when",
+      inputType: "datetime",
+      $action: {
+        type: "pick",
+        selected: { $field: "when", fallback: "missing" },
+      },
+    });
+    const actionSet = card.body[2];
+    if (actionSet?.type !== "ActionSet") throw new Error("Missing action");
+    expect(decodeSubmitData(actionSet.actions[0]!.data)).toEqual({
+      type: "pick",
+      selected: "missing",
+    });
+  });
+});