@satorijs/adapter-lark 3.10.5 → 3.10.6

package/lib/content.d.ts

@@ -360,6 +360,7 @@ export declare namespace MessageContent {
         interface SelectElement extends BaseSelectElement<'select_static'> {
             options: OptionElement[];
             initial_option?: string;
+            behaviors?: ActionBehavior[];
         }
         interface MultiSelectElement extends BaseSelectElement<'multi_select_static'> {
             options: OptionElement[];
@@ -441,7 +442,7 @@ export declare namespace MessageContent {
             type Width = 'default' | 'fill' | string;
             type Type = 'default' | 'primary' | 'danger' | 'text' | 'primary_text' | 'danger_text' | 'primary_filled' | 'danger_filled' | 'laser';
         }
-        type Element = DivElement | MarkdownElement | HRElement | ActionElement | NoteElement | ChartElement | TableElement | ImageElement | FormElement | InputElement | ButtonElement | CheckerElement | ColumnSetElement;
+        type Element = DivElement | MarkdownElement | HRElement | ActionElement | NoteElement | ChartElement | TableElement | ImageElement | FormElement | InputElement | ButtonElement | CheckerElement | ColumnSetElement | SelectElement;
     }
     interface Template {
         type: 'template';

package/lib/index.cjs

@@ -47,6 +47,353 @@ var import_core2 = require("@satorijs/core");
 // src/utils.ts
 var import_crypto = __toESM(require("crypto"), 1);
 var import_core = require("@satorijs/core");
+
+// node_modules/cosmokit/lib/index.mjs
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+function noop() {
+}
+__name(noop, "noop");
+__name2(noop, "noop");
+function isNullable(value) {
+  return value === null || value === void 0;
+}
+__name(isNullable, "isNullable");
+__name2(isNullable, "isNullable");
+function isNonNullable(value) {
+  return !isNullable(value);
+}
+__name(isNonNullable, "isNonNullable");
+__name2(isNonNullable, "isNonNullable");
+function isPlainObject(data) {
+  return data && typeof data === "object" && !Array.isArray(data);
+}
+__name(isPlainObject, "isPlainObject");
+__name2(isPlainObject, "isPlainObject");
+function filterKeys(object, filter) {
+  return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+__name(filterKeys, "filterKeys");
+__name2(filterKeys, "filterKeys");
+function mapValues(object, transform) {
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+__name(mapValues, "mapValues");
+__name2(mapValues, "mapValues");
+function pick(source, keys, forced) {
+  if (!keys) return { ...source };
+  const result = {};
+  for (const key of keys) {
+    if (forced || source[key] !== void 0) result[key] = source[key];
+  }
+  return result;
+}
+__name(pick, "pick");
+__name2(pick, "pick");
+function omit(source, keys) {
+  if (!keys) return { ...source };
+  const result = { ...source };
+  for (const key of keys) {
+    Reflect.deleteProperty(result, key);
+  }
+  return result;
+}
+__name(omit, "omit");
+__name2(omit, "omit");
+function defineProperty(object, key, value) {
+  return Object.defineProperty(object, key, { writable: true, value, enumerable: false });
+}
+__name(defineProperty, "defineProperty");
+__name2(defineProperty, "defineProperty");
+function contain(array1, array2) {
+  return array2.every((item) => array1.includes(item));
+}
+__name(contain, "contain");
+__name2(contain, "contain");
+function intersection(array1, array2) {
+  return array1.filter((item) => array2.includes(item));
+}
+__name(intersection, "intersection");
+__name2(intersection, "intersection");
+function difference(array1, array2) {
+  return array1.filter((item) => !array2.includes(item));
+}
+__name(difference, "difference");
+__name2(difference, "difference");
+function union(array1, array2) {
+  return Array.from(/* @__PURE__ */ new Set([...array1, ...array2]));
+}
+__name(union, "union");
+__name2(union, "union");
+function deduplicate(array) {
+  return [...new Set(array)];
+}
+__name(deduplicate, "deduplicate");
+__name2(deduplicate, "deduplicate");
+function remove(list, item) {
+  const index = list?.indexOf(item);
+  if (index >= 0) {
+    list.splice(index, 1);
+    return true;
+  } else {
+    return false;
+  }
+}
+__name(remove, "remove");
+__name2(remove, "remove");
+function makeArray(source) {
+  return Array.isArray(source) ? source : isNullable(source) ? [] : [source];
+}
+__name(makeArray, "makeArray");
+__name2(makeArray, "makeArray");
+function is(type, value) {
+  if (arguments.length === 1) return (value2) => is(type, value2);
+  return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+__name(is, "is");
+__name2(is, "is");
+function isArrayBufferLike(value) {
+  return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+__name(isArrayBufferLike, "isArrayBufferLike");
+__name2(isArrayBufferLike, "isArrayBufferLike");
+function isArrayBufferSource(value) {
+  return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+__name(isArrayBufferSource, "isArrayBufferSource");
+__name2(isArrayBufferSource, "isArrayBufferSource");
+var Binary;
+((Binary2) => {
+  Binary2.is = isArrayBufferLike;
+  Binary2.isSource = isArrayBufferSource;
+  function fromSource(source) {
+    if (ArrayBuffer.isView(source)) {
+      return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+    } else {
+      return source;
+    }
+  }
+  __name(fromSource, "fromSource");
+  Binary2.fromSource = fromSource;
+  __name2(fromSource, "fromSource");
+  function toBase64(source) {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(source).toString("base64");
+    }
+    let binary = "";
+    const bytes = new Uint8Array(source);
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  __name(toBase64, "toBase64");
+  Binary2.toBase64 = toBase64;
+  __name2(toBase64, "toBase64");
+  function fromBase64(source) {
+    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+    return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+  }
+  __name(fromBase64, "fromBase64");
+  Binary2.fromBase64 = fromBase64;
+  __name2(fromBase64, "fromBase64");
+  function toHex(source) {
+    if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+    return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  __name(toHex, "toHex");
+  Binary2.toHex = toHex;
+  __name2(toHex, "toHex");
+  function fromHex(source) {
+    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+    const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+    const buffer = [];
+    for (let i = 0; i < hex.length; i += 2) {
+      buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+    }
+    return Uint8Array.from(buffer).buffer;
+  }
+  __name(fromHex, "fromHex");
+  Binary2.fromHex = fromHex;
+  __name2(fromHex, "fromHex");
+})(Binary || (Binary = {}));
+var base64ToArrayBuffer = Binary.fromBase64;
+var arrayBufferToBase64 = Binary.toBase64;
+var hexToArrayBuffer = Binary.fromHex;
+var arrayBufferToHex = Binary.toHex;
+function clone(source) {
+  if (!source || typeof source !== "object") return source;
+  if (Array.isArray(source)) return source.map(clone);
+  if (is("Date", source)) return new Date(source.valueOf());
+  if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+  if (isArrayBufferLike(source)) return source.slice(0);
+  if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+  const result = Object.create(Object.getPrototypeOf(source));
+  for (const key of Reflect.ownKeys(source)) {
+    Reflect.defineProperty(result, key, Reflect.getOwnPropertyDescriptor(source, key));
+  }
+  return result;
+}
+__name(clone, "clone");
+__name2(clone, "clone");
+function deepEqual(a, b, strict) {
+  if (a === b) return true;
+  if (!strict && isNullable(a) && isNullable(b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (!a || !b) return false;
+  function check(test, then) {
+    return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+  }
+  __name(check, "check");
+  __name2(check, "check");
+  return check(Array.isArray, (a2, b2) => a2.length === b2.length && a2.every((item, index) => deepEqual(item, b2[index]))) ?? check(is("Date"), (a2, b2) => a2.valueOf() === b2.valueOf()) ?? check(is("RegExp"), (a2, b2) => a2.source === b2.source && a2.flags === b2.flags) ?? check(isArrayBufferLike, (a2, b2) => {
+    if (a2.byteLength !== b2.byteLength) return false;
+    const viewA = new Uint8Array(a2);
+    const viewB = new Uint8Array(b2);
+    for (let i = 0; i < viewA.length; i++) {
+      if (viewA[i] !== viewB[i]) return false;
+    }
+    return true;
+  }) ?? Object.keys({ ...a, ...b }).every((key) => deepEqual(a[key], b[key], strict));
+}
+__name(deepEqual, "deepEqual");
+__name2(deepEqual, "deepEqual");
+function capitalize(source) {
+  return source.charAt(0).toUpperCase() + source.slice(1);
+}
+__name(capitalize, "capitalize");
+__name2(capitalize, "capitalize");
+function uncapitalize(source) {
+  return source.charAt(0).toLowerCase() + source.slice(1);
+}
+__name(uncapitalize, "uncapitalize");
+__name2(uncapitalize, "uncapitalize");
+function camelCase(source) {
+  return source.replace(/[_-][a-z]/g, (str) => str.slice(1).toUpperCase());
+}
+__name(camelCase, "camelCase");
+__name2(camelCase, "camelCase");
+function paramCase(source) {
+  return uncapitalize(source).replace(/_/g, "-").replace(/.[A-Z]+/g, (str) => str[0] + "-" + str.slice(1).toLowerCase());
+}
+__name(paramCase, "paramCase");
+__name2(paramCase, "paramCase");
+function snakeCase(source) {
+  return uncapitalize(source).replace(/-/g, "_").replace(/.[A-Z]+/g, (str) => str[0] + "_" + str.slice(1).toLowerCase());
+}
+__name(snakeCase, "snakeCase");
+__name2(snakeCase, "snakeCase");
+var hyphenate = paramCase;
+function trimSlash(source) {
+  return source.replace(/\/$/, "");
+}
+__name(trimSlash, "trimSlash");
+__name2(trimSlash, "trimSlash");
+function sanitize(source) {
+  if (!source.startsWith("/")) source = "/" + source;
+  return trimSlash(source);
+}
+__name(sanitize, "sanitize");
+__name2(sanitize, "sanitize");
+var Time;
+((Time22) => {
+  Time22.millisecond = 1;
+  Time22.second = 1e3;
+  Time22.minute = Time22.second * 60;
+  Time22.hour = Time22.minute * 60;
+  Time22.day = Time22.hour * 24;
+  Time22.week = Time22.day * 7;
+  let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  function setTimezoneOffset(offset) {
+    timezoneOffset = offset;
+  }
+  __name(setTimezoneOffset, "setTimezoneOffset");
+  Time22.setTimezoneOffset = setTimezoneOffset;
+  __name2(setTimezoneOffset, "setTimezoneOffset");
+  function getTimezoneOffset() {
+    return timezoneOffset;
+  }
+  __name(getTimezoneOffset, "getTimezoneOffset");
+  Time22.getTimezoneOffset = getTimezoneOffset;
+  __name2(getTimezoneOffset, "getTimezoneOffset");
+  function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+    if (typeof date === "number") date = new Date(date);
+    if (offset === void 0) offset = timezoneOffset;
+    return Math.floor((date.valueOf() / Time22.minute - offset) / 1440);
+  }
+  __name(getDateNumber, "getDateNumber");
+  Time22.getDateNumber = getDateNumber;
+  __name2(getDateNumber, "getDateNumber");
+  function fromDateNumber(value, offset) {
+    const date = new Date(value * Time22.day);
+    if (offset === void 0) offset = timezoneOffset;
+    return new Date(+date + offset * Time22.minute);
+  }
+  __name(fromDateNumber, "fromDateNumber");
+  Time22.fromDateNumber = fromDateNumber;
+  __name2(fromDateNumber, "fromDateNumber");
+  const numeric = /\d+(?:\.\d+)?/.source;
+  const timeRegExp = new RegExp(`^${[
+    "w(?:eek(?:s)?)?",
+    "d(?:ay(?:s)?)?",
+    "h(?:our(?:s)?)?",
+    "m(?:in(?:ute)?(?:s)?)?",
+    "s(?:ec(?:ond)?(?:s)?)?"
+  ].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+  function parseTime(source) {
+    const capture = timeRegExp.exec(source);
+    if (!capture) return 0;
+    return (parseFloat(capture[1]) * Time22.week || 0) + (parseFloat(capture[2]) * Time22.day || 0) + (parseFloat(capture[3]) * Time22.hour || 0) + (parseFloat(capture[4]) * Time22.minute || 0) + (parseFloat(capture[5]) * Time22.second || 0);
+  }
+  __name(parseTime, "parseTime");
+  Time22.parseTime = parseTime;
+  __name2(parseTime, "parseTime");
+  function parseDate(date) {
+    const parsed = parseTime(date);
+    if (parsed) {
+      date = Date.now() + parsed;
+    } else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+    } else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+    }
+    return date ? new Date(date) : /* @__PURE__ */ new Date();
+  }
+  __name(parseDate, "parseDate");
+  Time22.parseDate = parseDate;
+  __name2(parseDate, "parseDate");
+  function format(ms) {
+    const abs = Math.abs(ms);
+    if (abs >= Time22.day - Time22.hour / 2) {
+      return Math.round(ms / Time22.day) + "d";
+    } else if (abs >= Time22.hour - Time22.minute / 2) {
+      return Math.round(ms / Time22.hour) + "h";
+    } else if (abs >= Time22.minute - Time22.second / 2) {
+      return Math.round(ms / Time22.minute) + "m";
+    } else if (abs >= Time22.second) {
+      return Math.round(ms / Time22.second) + "s";
+    }
+    return ms + "ms";
+  }
+  __name(format, "format");
+  Time22.format = format;
+  __name2(format, "format");
+  function toDigits(source, length = 2) {
+    return source.toString().padStart(length, "0");
+  }
+  __name(toDigits, "toDigits");
+  Time22.toDigits = toDigits;
+  __name2(toDigits, "toDigits");
+  function template(template2, time = /* @__PURE__ */ new Date()) {
+    return template2.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+  }
+  __name(template, "template");
+  Time22.template = template;
+  __name2(template, "template");
+})(Time || (Time = {}));
+
+// src/utils.ts
 function adaptSender(sender, session) {
   let userId;
   if ("sender_id" in sender) {
@@ -171,11 +518,11 @@ async function adaptSession(bot, body) {
         }
         for (const [key, value] of Object.entries(options)) {
           if (value === true) {
-            content += ` --${key} 1`;
+            content += ` --${hyphenate(key)} 1`;
           } else if (value === false) {
-            content += ` --${key} 0`;
+            content += ` --${hyphenate(key)} 0`;
           } else {
-            content += ` --${key} ${toArg(value)}`;
+            content += ` --${hyphenate(key)} ${toArg(value)}`;
           }
         }
         if (body.event.action.input_value) {
@@ -424,6 +771,7 @@ var LarkMessageEncoder = class extends import_core3.MessageEncoder {
   card;
   noteElements;
   actionElements = [];
+  isForm = false;
   editMessageIds;
   async post(data) {
     try {
@@ -641,7 +989,9 @@ var LarkMessageEncoder = class extends import_core3.MessageEncoder {
     } else if (type === "form") {
       this.flushText();
       const length = this.card?.elements.length;
+      this.isForm = true;
       await this.render(children);
+      this.isForm = false;
       if (this.card?.elements.length > length) {
         const elements = this.card?.elements.splice(length);
         this.card.elements.push({
@@ -657,7 +1007,7 @@ var LarkMessageEncoder = class extends import_core3.MessageEncoder {
         this.card?.elements.push({
           tag: "checker",
           name: (attrs.argument ? "@@" : attrs.option ? `@${attrs.option}=` : "") + attrs.name,
-          checked: attrs.checked,
+          checked: attrs.value,
           text: {
             tag: "plain_text",
             content: this.textContent
@@ -683,20 +1033,68 @@ var LarkMessageEncoder = class extends import_core3.MessageEncoder {
         this.textContent = "";
       } else {
         this.flushText();
+        const input = {
+          tag: "input",
+          name: attrs.name,
+          width: attrs.width,
+          label: attrs.label && {
+            tag: "plain_text",
+            content: attrs.label
+          },
+          placeholder: attrs.placeholder && {
+            tag: "plain_text",
+            content: attrs.placeholder
+          },
+          default_value: attrs.value,
+          disabled: attrs.disabled,
+          required: attrs.required
+        };
+        if (this.isForm) {
+          this.card?.elements.push(input);
+        } else {
+          this.card?.elements.push({
+            tag: "action",
+            actions: [{
+              ...input,
+              behaviors: this.createBehavior(attrs)
+            }]
+          });
+        }
+      }
+    } else if (type === "select") {
+      this.flushText();
+      const select = {
+        tag: "select_static",
+        name: attrs.name,
+        width: attrs.width,
+        initial_option: attrs.value,
+        disabled: attrs.disabled,
+        required: attrs.required,
+        placeholder: attrs.placeholder && {
+          tag: "plain_text",
+          content: attrs.placeholder
+        },
+        options: []
+      };
+      for (const child of children) {
+        if (child.type !== "option") continue;
+        await this.render(child.children);
+        select.options.push({
+          value: child.attrs.value,
+          text: {
+            tag: "plain_text",
+            content: this.textContent ?? child.attrs.value
+          }
+        });
+        this.textContent = "";
+      }
+      if (this.isForm) {
+        this.card?.elements.push(select);
+      } else {
         this.card?.elements.push({
           tag: "action",
           actions: [{
-            tag: "input",
-            name: attrs.name,
-            width: attrs.width,
-            label: attrs.label && {
-              tag: "plain_text",
-              content: attrs.label
-            },
-            placeholder: attrs.placeholder && {
-              tag: "plain_text",
-              content: attrs.placeholder
-            },
+            ...select,
             behaviors: this.createBehavior(attrs)
           }]
         });
@@ -826,13 +1224,14 @@ var LarkMessageEncoder = class extends import_core3.MessageEncoder {
           }
           this.card = { elements: [] };
           await this.render(child.children);
+          this.flushText();
           columns.push({
             tag: "column",
             width: child.attrs.width,
             weight: child.attrs.weight,
             padding: child.attrs.padding,
-            vertical_align: child.attrs.verticalAlign,
-            vertical_spacing: child.attrs.verticalSpacing,
+            vertical_align: child.attrs.verticalAlign ?? "center",
+            vertical_spacing: child.attrs.verticalSpacing ?? "0px",
             background_style: child.attrs.backgroundStyle,
             elements: this.card.elements
           });

package/lib/message.d.ts

@@ -9,6 +9,7 @@ export declare class LarkMessageEncoder<C extends Context = Context> extends Mes
     private card;
     private noteElements;
     private actionElements;
+    private isForm;
     editMessageIds: string[] | undefined;
     post(data?: any): Promise<void>;
     private flushText;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@satorijs/adapter-lark",
   "description": "Lark (飞书) Adapter for Satorijs",
-  "version": "3.10.5",
+  "version": "3.10.6",
   "type": "module",
   "main": "lib/index.cjs",
   "types": "lib/index.d.ts",

package/src/content.ts

@@ -447,6 +447,7 @@ export namespace MessageContent {
     export interface SelectElement extends BaseSelectElement<'select_static'> {
       options: OptionElement[]
       initial_option?: string
+      behaviors?: ActionBehavior[]
     }
 
     export interface MultiSelectElement extends BaseSelectElement<'multi_select_static'> {
@@ -553,6 +554,7 @@ export namespace MessageContent {
       | ButtonElement
       | CheckerElement
       | ColumnSetElement
+      | SelectElement
   }
 
   export interface Template {

package/src/message.ts

@@ -13,6 +13,7 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
   private card: MessageContent.Card | undefined
   private noteElements: MessageContent.Card.NoteElement.InnerElement[] | undefined
   private actionElements: MessageContent.Card.Element[] = []
+  private isForm = false
 
   public editMessageIds: string[] | undefined
 
@@ -251,7 +252,9 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
     } else if (type === 'form') {
       this.flushText()
       const length = this.card?.elements.length
+      this.isForm = true
       await this.render(children)
+      this.isForm = false
       if (this.card?.elements.length > length) {
         const elements = this.card?.elements.splice(length)
         this.card.elements.push({
@@ -267,7 +270,7 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
         this.card?.elements.push({
           tag: 'checker',
           name: (attrs.argument ? '@@' : attrs.option ? `@${attrs.option}=` : '') + attrs.name,
-          checked: attrs.checked,
+          checked: attrs.value,
           text: {
             tag: 'plain_text',
             content: this.textContent,
@@ -293,20 +296,68 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
         this.textContent = ''
       } else {
         this.flushText()
+        const input: MessageContent.Card.InputElement = {
+          tag: 'input',
+          name: attrs.name,
+          width: attrs.width,
+          label: attrs.label && {
+            tag: 'plain_text',
+            content: attrs.label,
+          },
+          placeholder: attrs.placeholder && {
+            tag: 'plain_text',
+            content: attrs.placeholder,
+          },
+          default_value: attrs.value,
+          disabled: attrs.disabled,
+          required: attrs.required,
+        }
+        if (this.isForm) {
+          this.card?.elements.push(input)
+        } else {
+          this.card?.elements.push({
+            tag: 'action',
+            actions: [{
+              ...input,
+              behaviors: this.createBehavior(attrs),
+            }],
+          })
+        }
+      }
+    } else if (type === 'select') {
+      this.flushText()
+      const select: MessageContent.Card.SelectElement = {
+        tag: 'select_static',
+        name: attrs.name,
+        width: attrs.width,
+        initial_option: attrs.value,
+        disabled: attrs.disabled,
+        required: attrs.required,
+        placeholder: attrs.placeholder && {
+          tag: 'plain_text',
+          content: attrs.placeholder,
+        },
+        options: [],
+      }
+      for (const child of children) {
+        if (child.type !== 'option') continue
+        await this.render(child.children)
+        select.options.push({
+          value: child.attrs.value,
+          text: {
+            tag: 'plain_text',
+            content: this.textContent ?? child.attrs.value,
+          },
+        })
+        this.textContent = ''
+      }
+      if (this.isForm) {
+        this.card?.elements.push(select)
+      } else {
         this.card?.elements.push({
           tag: 'action',
           actions: [{
-            tag: 'input',
-            name: attrs.name,
-            width: attrs.width,
-            label: attrs.label && {
-              tag: 'plain_text',
-              content: attrs.label,
-            },
-            placeholder: attrs.placeholder && {
-              tag: 'plain_text',
-              content: attrs.placeholder,
-            },
+            ...select,
             behaviors: this.createBehavior(attrs),
           }],
         })
@@ -437,13 +488,14 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
           }
           this.card = { elements: [] }
           await this.render(child.children)
+          this.flushText()
           columns.push({
             tag: 'column',
             width: child.attrs.width,
             weight: child.attrs.weight,
             padding: child.attrs.padding,
-            vertical_align: child.attrs.verticalAlign,
-            vertical_spacing: child.attrs.verticalSpacing,
+            vertical_align: child.attrs.verticalAlign ?? 'center',
+            vertical_spacing: child.attrs.verticalSpacing ?? '0px',
             background_style: child.attrs.backgroundStyle,
             elements: this.card.elements,
           })

package/src/utils.ts

@@ -3,6 +3,7 @@ import { Context, h, pick, Session, Universal } from '@satorijs/core'
 import { LarkBot } from './bot'
 import { GetImChatResponse, ListChat, Message, User } from './types'
 import { MessageContent } from './content'
+import { hyphenate } from 'cosmokit'
 
 export interface EventHeader<K extends keyof Events> {
   event_id: string
@@ -291,11 +292,11 @@ export async function adaptSession<C extends Context>(bot: LarkBot<C>, body: Eve
         }
         for (const [key, value] of Object.entries(options)) {
           if (value === true) {
-            content += ` --${key} 1`
+            content += ` --${hyphenate(key)} 1`
           } else if (value === false) {
-            content += ` --${key} 0`
+            content += ` --${hyphenate(key)} 0`
           } else {
-            content += ` --${key} ${toArg(value)}`
+            content += ` --${hyphenate(key)} ${toArg(value)}`
           }
         }
         if (body.event.action.input_value) {