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

package/src/slack/types.ts

@@ -1,5 +1,15 @@
 import type { UIElement } from "../ir";
 
+export type FieldMapping = {
+  readonly actionId: string;
+  readonly name: string;
+  readonly component: string;
+  readonly inputType?: "time" | "datetime";
+  readonly offset?: string;
+  readonly part?: "date" | "time";
+  readonly pairId?: number;
+};
+
 /** A Slack plain-text composition object. */
 export interface SlackPlainText {
   readonly type: "plain_text";
@@ -35,6 +45,7 @@ export interface SlackStaticSelectElement {
   readonly type: "static_select";
   readonly action_id: string;
   readonly options: readonly SlackOption[];
+  readonly initial_option?: SlackOption;
   readonly placeholder?: SlackPlainText;
 }
 
@@ -45,6 +56,18 @@ export interface SlackDatePickerElement {
   readonly initial_date?: string;
 }
 
+export interface SlackTimePickerElement {
+  readonly type: "timepicker";
+  readonly action_id: string;
+  readonly initial_time?: string;
+}
+
+export interface SlackDateTimePickerElement {
+  readonly type: "datetimepicker";
+  readonly action_id: string;
+  readonly initial_date_time?: number;
+}
+
 /** A Slack checkbox-group element. */
 export interface SlackCheckboxesElement {
   readonly type: "checkboxes";
@@ -66,6 +89,7 @@ export interface SlackPlainTextInputElement {
   readonly type: "plain_text_input";
   readonly action_id: string;
   readonly multiline?: boolean;
+  readonly initial_value?: string;
   readonly placeholder?: SlackPlainText;
 }
 
@@ -74,6 +98,8 @@ export type SlackActionElement =
   | SlackButtonElement
   | SlackStaticSelectElement
   | SlackDatePickerElement
+  | SlackTimePickerElement
+  | SlackDateTimePickerElement
   | SlackCheckboxesElement
   | SlackRadioButtonsElement;
 
@@ -112,12 +138,14 @@ export interface SlackDividerBlock {
 /** A Slack actions block. */
 export interface SlackActionsBlock {
   readonly type: "actions";
+  readonly block_id?: string;
   readonly elements: readonly SlackActionElement[];
 }
 
 /** A Slack input block. */
 export interface SlackInputBlock {
   readonly type: "input";
+  readonly block_id?: string;
   readonly label: SlackPlainText;
   readonly element: SlackPlainTextInputElement;
 }

package/src/slack.ts

@@ -20,6 +20,7 @@ export type {
   SlackDataTableRawNumberCell,
   SlackDataTableRawTextCell,
   SlackDatePickerElement,
+  SlackDateTimePickerElement,
   SlackDividerBlock,
   SlackHeaderBlock,
   SlackImageBlock,
@@ -33,5 +34,6 @@ export type {
   SlackSectionBlock,
   SlackStaticSelectElement,
   SlackTextObject,
+  SlackTimePickerElement,
   ToSlackBlocksOptions,
 } from "./slack/types";

package/src/teams/constants.ts

@@ -29,7 +29,7 @@ export const TABLE_ROW_CAP = 100;
 /** The maximum number of columns in a Table. */
 export const TABLE_COLUMN_CAP = 20;
 
-/** The maximum number of choices in a Select or RadioGroup. */
+/** The maximum number of choices in a Select, RadioGroup, or CheckboxGroup. */
 export const CHOICE_OPTION_CAP = 100;
 
 /** The soft byte-count budget for a serialized card, past which a warning notes Teams' 100 KB bot message limit (the card is never truncated to fit it). */

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({
@@ -23,6 +239,39 @@ describe("decodeSubmitData", () => {
     });
   });
 
+  it("keeps a number input as a number", () => {
+    const value = {
+      aui: { type: "set_quantity" },
+      quantity: 3.5,
+    };
+    expect(decodeSubmitData(value)).toEqual({
+      type: "set_quantity",
+      $input: { quantity: 3.5 },
+    });
+  });
+
+  it("resolves $field references in the payload from same-card inputs, else their fallback", () => {
+    const value = {
+      aui: {
+        type: "save",
+        payload: {
+          note: { $field: "note" },
+          form: { plan: [{ $field: "plan" }], missing: { $field: "gone" } },
+          renamed: { $field: "aui", fallback: "kept" },
+        },
+      },
+      note: "Ship it",
+      plan: "pro",
+    };
+    expect(decodeSubmitData(value)).toEqual({
+      type: "save",
+      note: "Ship it",
+      form: { plan: ["pro"] },
+      renamed: "kept",
+      $input: { note: "Ship it", plan: "pro" },
+    });
+  });
+
   it("omits $input when there are no other top-level keys", () => {
     expect(decodeSubmitData({ aui: { type: "approve" } })).toEqual({
       type: "approve",

package/src/teams/decodeSubmitData.ts

@@ -1,4 +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);
@@ -9,6 +16,10 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
  * the resume action under. Adaptive Cards fold every other same-card input's
  * value into the same submit object keyed by its `id`, so every top-level key
  * besides `aui` is collected into `$input` (omitted when there are none).
+ * Each `{ "$field": name }` reference inside the payload resolves to the
+ * same-card input value with that id, as the string Adaptive Cards submitted,
+ * and a reference with no such input resolves to its `fallback`, or is dropped
+ * without one.
  * `aui` is reserved for the envelope: `toAdaptiveCard` renames any input
  * whose id would collide to an unused id derived from it before encoding, so
  * a same-card input value can never land on this key. `$input` and `type`
@@ -43,13 +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 {
-      ...Object.fromEntries(payloadEntries),
+      ...(resolveFieldReferences(
+        Object.fromEntries(payloadEntries),
+        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;