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

package/src/teams/decodeSubmitData.test.ts

@@ -1,7 +1,223 @@
 import { describe, expect, it } from "vitest";
 import { decodeSubmitData } from "./decodeSubmitData";
+import { toAdaptiveCard } from "./toAdaptiveCard";
 
 describe("decodeSubmitData", () => {
+  describe.each(["2025-12-15T17:00:30.123456+02:00", "2025-12-15T17:00", ""])(
+    "partial datetime submission for %j",
+    (value) => {
+      it.each(["Input.Date", "Input.Time"])(
+        "clears the field when only %s is submitted",
+        (submittedType) => {
+          const { card } = toAdaptiveCard({
+            $type: "DatePicker",
+            name: "when",
+            inputType: "datetime",
+            value,
+            $action: {
+              type: "save",
+              selected: { $field: "when", fallback: "missing" },
+            },
+          });
+          const input = card.body.find(
+            (element) => element.type === submittedType,
+          );
+          const action = card.body.find(
+            (element) => element.type === "ActionSet",
+          );
+          if (!input || !("id" in input) || action?.type !== "ActionSet")
+            throw new Error("Missing picker input or action");
+          const submitted = {
+            ...action.actions[0]!.data,
+            [input.id]: submittedType === "Input.Date" ? "2025-12-16" : "18:20",
+          };
+          expect(Object.keys(submitted)).toHaveLength(2);
+          expect(decodeSubmitData(submitted)).toEqual({
+            type: "save",
+            selected: "",
+            $input: { when: "" },
+          });
+        },
+      );
+    },
+  );
+
+  it.each([
+    "aui:datetime:",
+    "aui:datetime:when",
+    "aui:datetime:time:when::extra",
+    "aui:datetime:time:when:%",
+    "aui:datetime:time:%E0%A4%A:",
+    "aui:datetime:time:%77hen:",
+    "aui:datetime:time:when:not-an-instant",
+    "aui:datetime:time:when:2025-02-30T17%3A00%3A00Z",
+    "aui:datetime:time:when:2025-12-15T17%3A00",
+    "aui:datetime:time:when:%7B%22dateId%22%3A%22other%22%7D",
+    "aui:datetime:time::",
+    "aui:datetime:time:aui:",
+    "aui:datetime:time:aui%3Adatetime%3Awhen%3A:",
+    "aui:datetime:missing:",
+    "aui:datetime:time:other:",
+  ])("rejects forged or malformed time input id %j", (id) => {
+    const value = {
+      aui: { type: "save", payload: { selected: { $field: "when" } } },
+      when: "2025-12-15",
+      other: "untouched",
+      [id]: "17:00",
+    };
+    expect(decodeSubmitData(value)).toBeUndefined();
+    expect(value.when).toBe("2025-12-15");
+    expect(value.other).toBe("untouched");
+  });
+
+  it.each([
+    "aui:datetime:date:",
+    "aui:datetime:date:when:",
+    "aui:datetime:date:when:2025-12-15T17%3A00Z",
+    "aui:datetime:date:%",
+    "aui:datetime:date:%E0%A4%A",
+    "aui:datetime:date:%77hen",
+    "aui:datetime:date:aui",
+    "aui:datetime:date:aui%3Adatetime%3Awhen",
+    "aui:datetime:time:when",
+    "aui:datetime:time:%77hen:",
+    "aui:datetime:time:when:not-an-instant",
+    "aui:datetime:time:when:2025-02-30T17%3A00%3A00Z",
+    "aui:datetime:time:when:2025-12-15T17%3a00%3a00Z",
+    "aui:datetime:other:when",
+    "aui:datetime:when:",
+  ])("rejects malformed temporal id %j even without another field", (id) => {
+    expect(
+      decodeSubmitData({ aui: { type: "save" }, [id]: "" }),
+    ).toBeUndefined();
+  });
+
+  it.each(["date", "time"])(
+    "rejects a forged %s id targeting an ordinary field",
+    (role) => {
+      const id = `aui:datetime:${role}:other${role === "time" ? ":" : ""}`;
+      const submitted = role === "date" ? "2025-12-16" : "18:20";
+      for (const other of ["2025-12-15", "17:00", "", "untouched"]) {
+        for (const entries of [
+          [
+            ["other", other],
+            [id, submitted],
+          ],
+          [
+            [id, submitted],
+            ["other", other],
+          ],
+        ]) {
+          const value = Object.freeze({
+            aui: { type: "save" },
+            ...Object.fromEntries(entries),
+          });
+          expect(decodeSubmitData(value)).toBeUndefined();
+          expect(value["other"]).toBe(other);
+        }
+      }
+    },
+  );
+
+  it.each([
+    ["date", "2025-02-30"],
+    ["date", "18:20"],
+    ["date", null],
+    ["date", undefined],
+    ["date", 20251215],
+    ["time", "24:00"],
+    ["time", "2025-12-15"],
+    ["time", {}],
+    ["time", []],
+    ["time", false],
+  ])("rejects invalid %s half %j", (role, submitted) => {
+    const id = `aui:datetime:${role}:when${role === "time" ? ":" : ""}`;
+    expect(
+      decodeSubmitData({ aui: { type: "save" }, [id]: submitted }),
+    ).toBeUndefined();
+  });
+
+  it.each([false, true])(
+    "rejects conflicting metadata regardless of submission order (%s)",
+    (reverse) => {
+      const entries = [
+        ["aui:datetime:time:when:", "17:00"],
+        ["aui:datetime:time:when:2025-12-15T17%3A00%3A00Z", "18:00"],
+      ];
+      expect(
+        decodeSubmitData({
+          aui: { type: "save" },
+          "aui:datetime:date:when": "2025-12-15",
+          ...Object.fromEntries(reverse ? entries.reverse() : entries),
+        }),
+      ).toBeUndefined();
+    },
+  );
+
+  it("never reads temporal metadata from the action envelope or its prototype", () => {
+    const temporal = {
+      get() {
+        throw new Error("Unexpected temporal read");
+      },
+    };
+    for (const aui of [
+      Object.defineProperty({ type: "save" }, "temporal", temporal),
+      Object.assign(
+        Object.create(Object.defineProperty({}, "temporal", temporal)),
+        { type: "save" },
+      ),
+    ]) {
+      expect(
+        decodeSubmitData({
+          aui,
+          "aui:datetime:date:when": "2025-12-15",
+          "aui:datetime:time:when:": "17:00",
+        }),
+      ).toEqual({
+        type: "save",
+        $input: { when: "2025-12-15T17:00" },
+      });
+    }
+  });
+
+  it("rejects a legacy time id with an inherited date half", () => {
+    const value = Object.assign(Object.create({ when: "2025-12-15" }), {
+      aui: { type: "save" },
+      "aui:datetime:when:": "17:00",
+    });
+    expect(decodeSubmitData(value)).toBeUndefined();
+  });
+
+  it.each([
+    [
+      "aui:datetime:date:when",
+      "2025-12-15",
+      "aui:datetime:time:when:",
+      "17:00",
+    ],
+    [
+      "aui:datetime:time:when:",
+      "17:00",
+      "aui:datetime:date:when",
+      "2025-12-15",
+    ],
+  ])(
+    "ignores an inherited half %s",
+    (inheritedId, inheritedValue, id, submitted) => {
+      const value = Object.assign(
+        Object.create({ [inheritedId]: inheritedValue }),
+        {
+          aui: { type: "save" },
+          [id]: submitted,
+        },
+      );
+      expect(decodeSubmitData(value)).toEqual({
+        type: "save",
+        $input: { when: "" },
+      });
+    },
+  );
+
   it("decodes the aui envelope, spreading its payload into the result", () => {
     const value = { aui: { type: "approve", payload: { requestId: "r1" } } };
     expect(decodeSubmitData(value)).toEqual({

package/src/teams/decodeSubmitData.ts

@@ -1,5 +1,11 @@
 import { resolveFieldReferences } from "../fieldReferences";
 import type { Action } from "../ir";
+import {
+  classifyTemporal,
+  fromOffsetDateTime,
+  mergeTemporalMinutes,
+} from "../temporal";
+import { decodeTemporalInputId, TEMPORAL_INPUT_PREFIX } from "./temporalId";
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value);
@@ -48,16 +54,55 @@ export function decodeSubmitData(value: unknown): Action | undefined {
       ([key]) => key !== "$input",
     );
     const inputEntries = Object.entries(value).filter(([key]) => key !== "aui");
-    const input =
-      inputEntries.length > 0 ? Object.fromEntries(inputEntries) : undefined;
+    const input = Object.fromEntries(inputEntries);
+    const temporalFields = new Map<
+      string,
+      { date?: string; time?: string; previousValue?: string }
+    >();
+    for (const [id, submitted] of inputEntries) {
+      if (!id.startsWith(TEMPORAL_INPUT_PREFIX)) continue;
+      const metadata = decodeTemporalInputId(id);
+      if (
+        !metadata ||
+        Object.hasOwn(input, metadata.fieldId) ||
+        typeof submitted !== "string" ||
+        (submitted !== "" && classifyTemporal(submitted).kind !== metadata.role)
+      )
+        return undefined;
+      const field = temporalFields.get(metadata.fieldId) ?? {};
+      if (field[metadata.role] !== undefined) return undefined;
+      field[metadata.role] = submitted;
+      if (metadata.role === "time" && metadata.previousValue !== undefined)
+        field.previousValue = metadata.previousValue;
+      temporalFields.set(metadata.fieldId, field);
+      delete input[id];
+    }
+    for (const [fieldId, field] of temporalFields) {
+      Object.defineProperty(input, fieldId, {
+        value: fromOffsetDateTime(
+          mergeTemporalMinutes(field.date ?? "", field.time ?? ""),
+          field.previousValue,
+        ),
+        enumerable: true,
+        configurable: true,
+        writable: true,
+      });
+    }
+    const hasInput = inputEntries.length > 0;
 
     return {
       ...(resolveFieldReferences(
         Object.fromEntries(payloadEntries),
-        input ?? {},
+        Object.fromEntries(
+          Object.entries(input).flatMap(([id, submitted]) =>
+            /^_+aui:datetime:/.test(id)
+              ? [[id.slice(1), submitted]]
+              : [[id, submitted]],
+          ),
+        ),
       ) as Record<string, unknown>),
       type,
-      ...(input !== undefined ? { $input: input } : {}),
+      ...(hasInput ? { $input: input } : {}),
     };
   } catch {
     return undefined;