@antdv-next/x 1.2.1 → 1.2.3-beta.1

package/dist/sender/components/TextArea.js

@@ -64,11 +64,48 @@ var TextArea_default = /* @__PURE__ */ defineComponent({
 		const onInternalPaste = (e) => {
 			const ctx = senderCtx.value;
 			const files = e.clipboardData?.files;
-			if (!e.clipboardData?.getData("text/plain") && files?.length && ctx.onPasteFile) {
+			const text = e.clipboardData?.getData("text/plain");
+			const info = {
+				text: text ?? "",
+				slotConfig: [],
+				skill: void 0
+			};
+			ctx.onPaste?.(e, info);
+			if (!e.defaultPrevented && !ctx.disabled && !ctx.readOnly && !text && files?.length && ctx.onPasteFile) {
 				ctx.onPasteFile(files);
 				e.preventDefault();
 			}
-			ctx.onPaste?.(e);
+		};
+		const getSelectedText = () => {
+			const el = getNativeEl();
+			if (!el) return "";
+			const start = el.selectionStart ?? 0;
+			const end = el.selectionEnd ?? start;
+			return el.value.slice(start, end);
+		};
+		const onInternalCopy = (e) => {
+			const ctx = senderCtx.value;
+			if (!ctx.onCopy) return;
+			const text = getSelectedText();
+			const info = {
+				value: text,
+				slotConfig: [],
+				skill: void 0,
+				text
+			};
+			ctx.onCopy(e, info);
+		};
+		const onInternalCut = (e) => {
+			const ctx = senderCtx.value;
+			if (!ctx.onCut) return;
+			const text = getSelectedText();
+			const info = {
+				value: text,
+				slotConfig: [],
+				skill: void 0,
+				text
+			};
+			ctx.onCut(e, info);
 		};
 		return () => {
 			const ctx = senderCtx.value;
@@ -91,7 +128,11 @@ var TextArea_default = /* @__PURE__ */ defineComponent({
 					isComposing.value = false;
 				},
 				"onKeydown": onInternalKeyDown
-			}, { onPaste: onInternalPaste }, {
+			}, {
+				onPaste: onInternalPaste,
+				onCopy: onInternalCopy,
+				onCut: onInternalCut
+			}, {
 				"variant": "borderless",
 				"readonly": ctx.readOnly,
 				"placeholder": ctx.placeholder,

package/dist/sender/components/prosemirror/model.d.ts

@@ -0,0 +1,15 @@
+import { Node as ProseMirrorNode, Schema } from 'prosemirror-model';
+import { SkillType, SlotConfigType } from '../../interface';
+import { HistoryValueStore } from './value';
+export declare const senderSchema: Schema<"text" | "doc" | "slot" | "skill" | "hardBreak" | "contentSlot", any>;
+export declare function stringifyValue(value: unknown): string;
+export declare function getSlotValue(config: SlotConfigType): unknown;
+export declare function createDocument(configs: readonly SlotConfigType[] | undefined, skill: SkillType | undefined, values: HistoryValueStore): ProseMirrorNode;
+export type EditorResult = {
+    value: string;
+    slotConfig: SlotConfigType[];
+    skill?: SkillType;
+};
+export declare function documentToResult(doc: ProseMirrorNode, values: HistoryValueStore, definitions: ReadonlyMap<string, SlotConfigType>, skills: ReadonlyMap<string, SkillType>): EditorResult;
+export declare function isEquivalentDocument(doc: ProseMirrorNode, configs: readonly SlotConfigType[] | undefined, skill: SkillType | undefined, values: HistoryValueStore, definitions: ReadonlyMap<string, SlotConfigType>): boolean;
+export declare function collectDefinitions(definitions: Map<string, SlotConfigType>, configs: readonly SlotConfigType[] | undefined): void;

package/dist/sender/components/prosemirror/model.js

@@ -0,0 +1,276 @@
+import { isSameValue, snapshotValue } from "./value.js";
+import { Schema } from "prosemirror-model";
+//#region components/sender/components/prosemirror/model.ts
+function stringifyLabel(value) {
+	if (value === void 0 || value === null || typeof value === "boolean") return "";
+	if (typeof value === "string" || typeof value === "number") return `${value}`;
+	if (Array.isArray(value)) return value.map(stringifyLabel).join("");
+	if (value.__v_isVNode) {
+		const children = value.children;
+		if (typeof children === "function") return stringifyLabel(children());
+		if (children && typeof children === "object" && !Array.isArray(children)) {
+			const defaultSlot = children.default;
+			if (typeof defaultSlot === "function") return stringifyLabel(defaultSlot());
+		}
+		return stringifyLabel(children);
+	}
+	return stringifyValue(value);
+}
+var senderSchema = new Schema({ nodes: {
+	doc: { content: "inline*" },
+	text: { group: "inline" },
+	hardBreak: {
+		group: "inline",
+		inline: true,
+		selectable: false,
+		parseDOM: [{ tag: "br" }],
+		toDOM: () => ["br"]
+	},
+	slot: {
+		group: "inline",
+		inline: true,
+		atom: true,
+		selectable: true,
+		attrs: {
+			key: {},
+			type: {},
+			valueId: {},
+			selectionStart: { default: null },
+			selectionEnd: { default: null },
+			selectionDirection: { default: "none" }
+		},
+		toDOM: (node) => ["span", {
+			"data-slot-key": node.attrs.key,
+			"data-slot-type": node.attrs.type
+		}]
+	},
+	contentSlot: {
+		group: "inline",
+		inline: true,
+		content: "(text | hardBreak)*",
+		isolating: true,
+		selectable: true,
+		attrs: { key: {} },
+		toDOM: (node) => [
+			"span",
+			{ "data-content-key": node.attrs.key },
+			[
+				"span",
+				{ "data-slot-key": node.attrs.key },
+				0
+			]
+		]
+	},
+	skill: {
+		group: "inline",
+		inline: true,
+		atom: true,
+		selectable: true,
+		attrs: { value: {} },
+		toDOM: (node) => ["span", { "data-skill-key": node.attrs.value }]
+	}
+} });
+function stringifyValue(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return `${value}`;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "";
+	}
+}
+function getSlotValue(config) {
+	if (config.type === "text") return config.value ?? "";
+	const rawConfig = config;
+	if (Object.prototype.hasOwnProperty.call(rawConfig, "value")) return rawConfig.value;
+	if (config.type === "tag") return config.props?.value ?? stringifyLabel(config.props?.label);
+	if (config.type === "select") {
+		const defaultValue = config.props?.defaultValue;
+		const options = config.props?.options ?? [];
+		if (defaultValue !== void 0 && !options.includes(defaultValue)) return options[0] ?? "";
+		return defaultValue ?? "";
+	}
+	return config.props?.defaultValue ?? "";
+}
+function createDocument(configs, skill, values) {
+	const nodes = [];
+	if (skill?.value) nodes.push(senderSchema.nodes.skill.create({ value: skill.value }));
+	(configs ?? []).forEach((config) => {
+		if (config.type === "text") {
+			if (config.value) nodes.push(senderSchema.text(config.value));
+			return;
+		}
+		if (config.type === "content") {
+			const text = stringifyValue(getSlotValue(config));
+			const contentNodes = [];
+			if (text) {
+				const lines = text.split("\n");
+				lines.forEach((line, index) => {
+					if (line) contentNodes.push(senderSchema.text(line));
+					if (index < lines.length - 1) contentNodes.push(senderSchema.nodes.hardBreak.create());
+				});
+			}
+			nodes.push(senderSchema.nodes.contentSlot.create({ key: config.key }, contentNodes.length > 0 ? contentNodes : void 0));
+			return;
+		}
+		nodes.push(senderSchema.nodes.slot.create({
+			key: config.key,
+			type: config.type,
+			valueId: values.add(getSlotValue(config))
+		}));
+	});
+	return senderSchema.nodes.doc.create(void 0, nodes);
+}
+function documentToResult(doc, values, definitions, skills) {
+	const text = [];
+	const slotConfig = [];
+	let skill;
+	doc.forEach((node) => {
+		if (node.isText) {
+			const value = node.text ?? "";
+			text.push(value);
+			if (value) slotConfig.push({
+				type: "text",
+				value
+			});
+			return;
+		}
+		if (node.type === senderSchema.nodes.hardBreak) {
+			text.push("\n");
+			slotConfig.push({
+				type: "text",
+				value: "\n"
+			});
+			return;
+		}
+		if (node.type === senderSchema.nodes.skill) {
+			skill = skills.get(node.attrs.value);
+			return;
+		}
+		const key = node.attrs.key;
+		const definition = definitions.get(key);
+		if (!definition) return;
+		let rawValue;
+		let displayValue;
+		if (node.type === senderSchema.nodes.contentSlot) {
+			const parts = [];
+			node.forEach((child) => {
+				if (child.isText) parts.push(child.text ?? "");
+				else if (child.type === senderSchema.nodes.hardBreak) parts.push("\n");
+			});
+			rawValue = parts.join("");
+			displayValue = definition.formatResult?.(rawValue) ?? stringifyValue(rawValue);
+		} else {
+			rawValue = values.read(node.attrs.valueId);
+			displayValue = definition.formatResult?.(rawValue) ?? stringifyValue(rawValue);
+		}
+		if (definition.type === "content") text.push(displayValue);
+		else text.push(displayValue);
+		const structuredValue = definition.type === "custom" ? snapshotValue(rawValue) : displayValue;
+		slotConfig.push({
+			...definition,
+			value: structuredValue
+		});
+	});
+	return {
+		value: text.join(""),
+		slotConfig,
+		skill
+	};
+}
+function configsToComparable(configs, skill) {
+	const result = [];
+	if (skill?.value) result.push({
+		kind: "skill",
+		value: skill.value
+	});
+	(configs ?? []).forEach((config) => {
+		if (config.type === "text") {
+			if (config.value) result.push({
+				kind: "text",
+				value: config.value
+			});
+			return;
+		}
+		result.push({
+			kind: "slot",
+			key: config.key,
+			type: config.type,
+			value: getSlotValue(config),
+			definition: config
+		});
+	});
+	return result;
+}
+function docToComparable(doc, values, definitions) {
+	const result = [];
+	doc.forEach((node) => {
+		if (node.isText) {
+			if (node.text) result.push({
+				kind: "text",
+				value: node.text
+			});
+			return;
+		}
+		if (node.type === senderSchema.nodes.hardBreak) {
+			result.push({
+				kind: "text",
+				value: "\n"
+			});
+			return;
+		}
+		if (node.type === senderSchema.nodes.skill) {
+			result.push({
+				kind: "skill",
+				value: node.attrs.value
+			});
+			return;
+		}
+		const key = node.attrs.key;
+		const definition = definitions.get(key);
+		if (!definition) return;
+		let value;
+		if (node.type === senderSchema.nodes.contentSlot) {
+			const parts = [];
+			node.forEach((child) => {
+				if (child.isText) parts.push(child.text ?? "");
+				else if (child.type === senderSchema.nodes.hardBreak) parts.push("\n");
+			});
+			value = parts.join("");
+		} else value = values.peek(node.attrs.valueId);
+		result.push({
+			kind: "slot",
+			key,
+			type: definition.type,
+			value,
+			definition
+		});
+	});
+	return result;
+}
+function isEquivalentDocument(doc, configs, skill, values, definitions) {
+	const expected = configsToComparable(configs, skill);
+	const current = docToComparable(doc, values, definitions);
+	return expected.length === current.length && expected.every((node, index) => {
+		const currentNode = current[index];
+		if (!currentNode || node.kind !== currentNode.kind) return false;
+		if (node.kind === "text" && currentNode.kind === "text") return node.value === currentNode.value;
+		if (node.kind === "skill" && currentNode.kind === "skill") return node.value === currentNode.value;
+		if (node.kind !== "slot" || currentNode.kind !== "slot") return false;
+		if (node.key !== currentNode.key || node.type !== currentNode.type) return false;
+		if (isSameValue(node.value, currentNode.value)) return true;
+		if (node.type !== "custom") {
+			const currentDisplayValue = currentNode.definition.formatResult?.(currentNode.value) ?? stringifyValue(currentNode.value);
+			return isSameValue(node.value, currentDisplayValue);
+		}
+		return false;
+	});
+}
+function collectDefinitions(definitions, configs) {
+	(configs ?? []).forEach((config) => {
+		if (config.type !== "text") definitions.set(config.key, config);
+	});
+}
+//#endregion
+export { collectDefinitions, createDocument, documentToResult, getSlotValue, isEquivalentDocument, senderSchema, stringifyValue };

package/dist/sender/components/prosemirror/value.d.ts

@@ -0,0 +1,11 @@
+export declare function isSafelyCloneableValue(value: unknown, seen?: WeakSet<object>): boolean;
+export declare function snapshotValue<T>(value: T): T;
+export declare function isSameValue(left: unknown, right: unknown): boolean;
+export declare class HistoryValueStore {
+    private nextId;
+    private readonly values;
+    add(value: unknown): string;
+    read<T = unknown>(id: string): T;
+    peek<T = unknown>(id: string): T;
+    isSame(id: string, value: unknown): boolean;
+}

package/dist/sender/components/prosemirror/value.js

@@ -0,0 +1,171 @@
+import { toRaw } from "vue";
+//#region components/sender/components/prosemirror/value.ts
+var VALUE_COMPARE_LIMIT = 2048;
+var asRaw = (value) => value && typeof value === "object" ? toRaw(value) : value;
+function isSafelyCloneableValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value !== "object") return typeof value !== "function" && typeof value !== "symbol";
+	const rawValue = asRaw(value);
+	if (seen.has(rawValue)) return true;
+	seen.add(rawValue);
+	if (rawValue.__v_isVNode || typeof Node !== "undefined" && rawValue instanceof Node || rawValue instanceof Promise || rawValue instanceof WeakMap || rawValue instanceof WeakSet || typeof SharedArrayBuffer !== "undefined" && rawValue instanceof SharedArrayBuffer) return false;
+	if (rawValue instanceof Date || rawValue instanceof RegExp || rawValue instanceof ArrayBuffer) return true;
+	if (ArrayBuffer.isView(rawValue)) return isSafelyCloneableValue(rawValue.buffer, seen);
+	if (rawValue instanceof Map) return Array.from(rawValue).every(([key, entryValue]) => isSafelyCloneableValue(key, seen) && isSafelyCloneableValue(entryValue, seen));
+	if (rawValue instanceof Set) return Array.from(rawValue).every((entryValue) => isSafelyCloneableValue(entryValue, seen));
+	const prototype = Object.getPrototypeOf(rawValue);
+	if (!Array.isArray(rawValue) && prototype !== Object.prototype && prototype !== null) return false;
+	return Reflect.ownKeys(rawValue).every((key) => {
+		if (typeof key === "symbol") return false;
+		const descriptor = Object.getOwnPropertyDescriptor(rawValue, key);
+		return !!descriptor && "value" in descriptor && isSafelyCloneableValue(descriptor.value, seen);
+	});
+}
+function snapshotValue(value) {
+	const rawValue = asRaw(value);
+	if (!isSafelyCloneableValue(rawValue)) return rawValue;
+	const clones = /* @__PURE__ */ new WeakMap();
+	const clone = (input) => {
+		if (input === null || typeof input !== "object") return input;
+		const rawInput = asRaw(input);
+		const existing = clones.get(rawInput);
+		if (existing) return existing;
+		if (rawInput instanceof Date) return new Date(rawInput.getTime());
+		if (rawInput instanceof RegExp) {
+			const result = new RegExp(rawInput.source, rawInput.flags);
+			result.lastIndex = rawInput.lastIndex;
+			return result;
+		}
+		if (rawInput instanceof ArrayBuffer) return rawInput.slice(0);
+		if (ArrayBuffer.isView(rawInput)) return structuredClone(rawInput);
+		if (rawInput instanceof Error) {
+			const result = Object.create(Object.getPrototypeOf(rawInput));
+			clones.set(rawInput, result);
+			result.message = rawInput.message;
+			result.name = rawInput.name;
+			result.stack = rawInput.stack;
+			return result;
+		}
+		if (rawInput instanceof Map) {
+			const result = /* @__PURE__ */ new Map();
+			clones.set(rawInput, result);
+			rawInput.forEach((entryValue, key) => {
+				result.set(clone(key), clone(entryValue));
+			});
+			return result;
+		}
+		if (rawInput instanceof Set) {
+			const result = /* @__PURE__ */ new Set();
+			clones.set(rawInput, result);
+			rawInput.forEach((entryValue) => {
+				result.add(clone(entryValue));
+			});
+			return result;
+		}
+		const result = Array.isArray(rawInput) ? [] : Object.create(Object.getPrototypeOf(rawInput));
+		clones.set(rawInput, result);
+		Reflect.ownKeys(rawInput).forEach((key) => {
+			const descriptor = Object.getOwnPropertyDescriptor(rawInput, key);
+			Object.defineProperty(result, key, {
+				...descriptor,
+				value: clone(descriptor.value)
+			});
+		});
+		return result;
+	};
+	return clone(rawValue);
+}
+function isSameValue(left, right) {
+	const pending = [[left, right]];
+	const leftMatches = /* @__PURE__ */ new WeakMap();
+	const rightMatches = /* @__PURE__ */ new WeakMap();
+	let comparedObjects = 0;
+	let pendingPairs = 0;
+	const sameBytes = (leftBytes, rightBytes) => leftBytes.byteLength === rightBytes.byteLength && leftBytes.every((value, index) => value === rightBytes[index]);
+	while (pending.length) {
+		const [pendingLeft, pendingRight] = pending.pop();
+		if (Object.is(pendingLeft, pendingRight)) continue;
+		if (pendingLeft === null || pendingRight === null || typeof pendingLeft !== "object" || typeof pendingRight !== "object") return false;
+		const leftValue = asRaw(pendingLeft);
+		const rightValue = asRaw(pendingRight);
+		if (Object.is(leftValue, rightValue)) continue;
+		if (++comparedObjects > VALUE_COMPARE_LIMIT) return false;
+		pendingPairs += pending.length;
+		if (pendingPairs > VALUE_COMPARE_LIMIT * 2) return false;
+		const matchedRight = leftMatches.get(leftValue);
+		if (matchedRight) {
+			if (matchedRight !== rightValue) return false;
+			continue;
+		}
+		const matchedLeft = rightMatches.get(rightValue);
+		if (matchedLeft) {
+			if (matchedLeft !== leftValue) return false;
+			continue;
+		}
+		leftMatches.set(leftValue, rightValue);
+		rightMatches.set(rightValue, leftValue);
+		if (leftValue instanceof Date || rightValue instanceof Date) {
+			if (!(leftValue instanceof Date) || !(rightValue instanceof Date) || !Object.is(leftValue.getTime(), rightValue.getTime())) return false;
+			continue;
+		}
+		if (leftValue instanceof RegExp || rightValue instanceof RegExp) {
+			if (!(leftValue instanceof RegExp) || !(rightValue instanceof RegExp) || leftValue.source !== rightValue.source || leftValue.flags !== rightValue.flags || leftValue.lastIndex !== rightValue.lastIndex) return false;
+			continue;
+		}
+		if (leftValue instanceof ArrayBuffer || rightValue instanceof ArrayBuffer) {
+			if (!(leftValue instanceof ArrayBuffer) || !(rightValue instanceof ArrayBuffer) || !sameBytes(new Uint8Array(leftValue), new Uint8Array(rightValue))) return false;
+			continue;
+		}
+		if (ArrayBuffer.isView(leftValue) || ArrayBuffer.isView(rightValue)) {
+			if (!ArrayBuffer.isView(leftValue) || !ArrayBuffer.isView(rightValue) || leftValue.constructor !== rightValue.constructor || !sameBytes(new Uint8Array(leftValue.buffer, leftValue.byteOffset, leftValue.byteLength), new Uint8Array(rightValue.buffer, rightValue.byteOffset, rightValue.byteLength))) return false;
+			continue;
+		}
+		if (leftValue instanceof Map || rightValue instanceof Map) {
+			if (!(leftValue instanceof Map) || !(rightValue instanceof Map) || leftValue.size !== rightValue.size) return false;
+			const leftEntries = Array.from(leftValue);
+			const rightEntries = Array.from(rightValue);
+			for (let index = 0; index < leftEntries.length; index += 1) pending.push([leftEntries[index][0], rightEntries[index][0]], [leftEntries[index][1], rightEntries[index][1]]);
+			continue;
+		}
+		if (leftValue instanceof Set || rightValue instanceof Set) {
+			if (!(leftValue instanceof Set) || !(rightValue instanceof Set) || leftValue.size !== rightValue.size) return false;
+			const leftEntries = Array.from(leftValue);
+			const rightEntries = Array.from(rightValue);
+			for (let index = 0; index < leftEntries.length; index += 1) pending.push([leftEntries[index], rightEntries[index]]);
+			continue;
+		}
+		const leftIsArray = Array.isArray(leftValue);
+		if (leftIsArray !== Array.isArray(rightValue)) return false;
+		const leftPrototype = Object.getPrototypeOf(leftValue);
+		if (leftPrototype !== Object.getPrototypeOf(rightValue) || !leftIsArray && leftPrototype !== Object.prototype && leftPrototype !== null) return false;
+		const leftKeys = Reflect.ownKeys(leftValue);
+		const rightKeys = Reflect.ownKeys(rightValue);
+		if (leftKeys.length !== rightKeys.length || leftKeys.some((key) => !Object.prototype.hasOwnProperty.call(rightValue, key))) return false;
+		for (const key of leftKeys) {
+			const leftDescriptor = Object.getOwnPropertyDescriptor(leftValue, key);
+			const rightDescriptor = Object.getOwnPropertyDescriptor(rightValue, key);
+			if (!leftDescriptor || !rightDescriptor || !("value" in leftDescriptor) || !("value" in rightDescriptor)) return false;
+			pending.push([leftDescriptor.value, rightDescriptor.value]);
+		}
+	}
+	return true;
+}
+var HistoryValueStore = class {
+	nextId = 0;
+	values = /* @__PURE__ */ new Map();
+	add(value) {
+		const id = `value-${++this.nextId}`;
+		this.values.set(id, snapshotValue(value));
+		return id;
+	}
+	read(id) {
+		return snapshotValue(this.values.get(id));
+	}
+	peek(id) {
+		return this.values.get(id);
+	}
+	isSame(id, value) {
+		return isSameValue(this.values.get(id), value);
+	}
+};
+//#endregion
+export { HistoryValueStore, isSafelyCloneableValue, isSameValue, snapshotValue };

package/dist/sender/index.d.ts

@@ -1,8 +1,8 @@
-import { SenderProps, SenderRef, SlotConfigType } from './interface';
+import { SenderCopyInfo, SenderPasteInfo, SenderProps, SenderRef, SlotConfigType } from './interface';
 import { default as ForwardSender } from './Sender';
 import { default as SenderHeader } from './SenderHeader';
 import { default as SenderSwitch } from './SenderSwitch';
-export type { SenderProps, SenderRef, SlotConfigType };
+export type { SenderCopyInfo, SenderPasteInfo, SenderProps, SenderRef, SlotConfigType, };
 type CompoundedSender = typeof ForwardSender & {
     Header: typeof SenderHeader;
     Switch: typeof SenderSwitch;

package/dist/sender/interface.d.ts

@@ -84,6 +84,17 @@ export interface SkillType {
         disabled?: boolean;
     };
 }
+export interface SenderCopyInfo {
+    value: string;
+    slotConfig: SlotConfigType[];
+    skill?: SkillType;
+    text: string;
+}
+export interface SenderPasteInfo {
+    text: string;
+    slotConfig: SlotConfigType[];
+    skill?: SkillType;
+}
 export interface SenderProps {
     prefixCls?: string;
     defaultValue?: string;
@@ -99,8 +110,10 @@ export interface SenderProps {
     onCancel?: () => void;
     onKeyDown?: (event: KeyboardEvent) => void | false;
     onKeyUp?: (event: KeyboardEvent) => void;
-    onPaste?: (event: ClipboardEvent) => void;
+    onPaste?: (event: ClipboardEvent, info: SenderPasteInfo) => void;
     onPasteFile?: (files: FileList) => void;
+    onCopy?: (event: ClipboardEvent, info: SenderCopyInfo) => void;
+    onCut?: (event: ClipboardEvent, info: SenderCopyInfo) => void;
     onFocus?: (event: FocusEvent) => void;
     onBlur?: (event: FocusEvent) => void;
     classNames?: Partial<Record<SemanticType, string>>;

package/dist/sender/style/slot-textarea.js

@@ -17,12 +17,19 @@ var genSlotTextAreaStyle = (token) => {
 			cursor: "text",
 			whiteSpace: "pre-wrap",
 			width: "100%",
+			position: "relative",
 			caretColor: token.colorPrimary,
 			fontSize: token.fontSize,
 			lineHeight: token.lineHeight,
-			[`&:empty::before`]: {
+			[`&[data-empty]::before`]: {
 				content: "attr(data-placeholder)",
-				color: token.colorTextPlaceholder
+				color: token.colorTextPlaceholder,
+				position: "absolute",
+				insetInlineStart: 0,
+				top: 0,
+				pointerEvents: "none",
+				userSelect: "none",
+				whiteSpace: "pre-wrap"
 			}
 		},
 		[`${slotCls}:not(${slotContentCls})`]: {

package/dist/suggestion/Suggestion.js

@@ -85,10 +85,18 @@ var XSuggestion = /* @__PURE__ */ defineComponent({
 		const innerOpen = ref(false);
 		const mergedOpen = computed(() => props.open ?? innerOpen.value);
 		const itemList = ref([]);
+		/**
+		* What the last `onTrigger` asked for. A function `items` is usually an inline arrow,
+		* so it gets a new identity on every parent render — without this the watcher below
+		* would re-evaluate it with no info and drop the triggered list.
+		*/
+		const triggerInfo = ref();
+		const resolveItems = (source, info) => {
+			if (typeof source === "function") return source(info);
+			return Array.isArray(source) ? source : [];
+		};
 		watch(() => props.items, (nextItems) => {
-			if (Array.isArray(nextItems)) itemList.value = nextItems;
-			else if (typeof nextItems === "function") itemList.value = nextItems();
-			else itemList.value = [];
+			itemList.value = resolveItems(nextItems, triggerInfo.value);
 		}, { immediate: true });
 		const triggerOpen = (nextOpen) => {
 			if (props.open === void 0) innerOpen.value = nextOpen;
@@ -103,7 +111,8 @@ var XSuggestion = /* @__PURE__ */ defineComponent({
 				triggerOpen(false);
 				return;
 			}
-			if (typeof props.items === "function") itemList.value = props.items(nextInfo);
+			triggerInfo.value = nextInfo;
+			if (typeof props.items === "function") itemList.value = resolveItems(props.items, nextInfo);
 			triggerOpen(true);
 		};
 		const onInternalChange = (valuePath, selectedOptions) => {
@@ -113,10 +122,31 @@ var XSuggestion = /* @__PURE__ */ defineComponent({
 			if (lastValue !== void 0) emit("select", String(lastValue), selected);
 			triggerOpen(false);
 		};
-		const [activePath, onKeyDown] = useActive(itemList, mergedOpen, isRtl, onClose);
+		const [activePath, onKeyDown, shouldSelectOnEnter] = useActive(itemList, mergedOpen, isRtl, onClose);
 		const onInternalOpenChange = (nextOpen) => {
 			if (!nextOpen) onClose();
 		};
+		/**
+		* Cascader renders our children as its raw input element, so every keydown from the
+		* children bubbles into BaseSelect's keyboard model. That model is built for a
+		* non-editable trigger and breaks typing inside an editable one such as Sender:
+		*
+		* - Space is always `preventDefault()`ed, so no space can be typed;
+		* - Enter is always `preventDefault()`ed, even when there is nothing to select;
+		* - Backspace makes the option list step back a level or close the popup.
+		*
+		* Keep exactly those inside the content wrapper. Every other key — Escape, arrows,
+		* application shortcuts — must keep bubbling, otherwise the app around us stops
+		* receiving keyboard events while the trigger has focus.
+		*/
+		const onContentKeyDown = (event) => {
+			const { key } = event;
+			if (key === "Enter") {
+				if (!shouldSelectOnEnter(event)) event.stopPropagation();
+				return;
+			}
+			if (key === " " || key === "Backspace" && mergedOpen.value) event.stopPropagation();
+		};
 		const domAttrs = computed(() => {
 			const { class: _class, style: _style, ...rest } = attrs;
 			return rest;
@@ -190,7 +220,8 @@ var XSuggestion = /* @__PURE__ */ defineComponent({
 					contextConfig.value.classes?.content,
 					mergedClasses.value.content
 				],
-				"style": [contextConfig.value.styles?.content, mergedStyles.value.content]
+				"style": [contextConfig.value.styles?.content, mergedStyles.value.content],
+				"onKeydown": onContentKeyDown
 			}, [childNode])])] });
 		};
 	}

package/dist/suggestion/useActive.d.ts

@@ -6,5 +6,5 @@ interface ActiveItem {
 /**
  * Cascader does not expose active item control, so we use `value` to mirror focus path.
  */
-export default function useActive(items: Ref<ActiveItem[]>, open: Ref<boolean>, rtl: Ref<boolean>, onCancel: () => void): readonly [Ref<string[], string[]>, (event: KeyboardEvent) => false | undefined];
+export default function useActive(items: Ref<ActiveItem[]>, open: Ref<boolean>, rtl: Ref<boolean>, onCancel: () => void): readonly [Ref<string[], string[]>, (event: KeyboardEvent) => false | undefined, (event: KeyboardEvent) => boolean];
 export {};