@neut/ui 0.0.17 → 0.0.18

package/dist/components/questionnaire/questionnaire.dom-watch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.dom-watch.js","names":["createDomVersionWatcher","version","setVersion","createSignal","createEffect","element","root","observer","v","onCleanup"],"sources":["../../../src/components/questionnaire/questionnaire.dom-watch.ts"],"sourcesContent":["import { createEffect, createSignal, onCleanup, type Accessor } from \"solid-js\";\n\n/**\n * 监视表单子树里的 DOM 增删，返回一个\"每次变化都会自增\"的版本号。\n *\n * 单一职责：把结构变化变成一条可被 memo 依赖的响应式边——注册表本身是普通数组，\n * 子节点被移动位置时注册顺序不变，只有 DOM 顺序变了，排序 memo 需要这条边才会重算。\n * 环境不支持 `MutationObserver`（SSR）时不做任何事，版本号恒为 0。\n */\nexport function createDomVersionWatcher(\n  root: Accessor<Element | undefined>,\n): Accessor<number> {\n  const [version, setVersion] = createSignal(0);\n\n  createEffect(() => {\n    const element = root();\n    if (!element || typeof MutationObserver === \"undefined\") return;\n\n    const observer = new MutationObserver(() => setVersion((v) => v + 1));\n    observer.observe(element, { childList: true, subtree: true });\n    // 初始挂载不会产生 MutationObserver 能观察到的 childList 变更，但题目的\n    // ref 是在\"插入文档之前\"执行的：这里再自增一次版本号，让排序 memo 在\n    // 节点真正连上文档之后重算一次（否则顺序会停在\"按注册顺序\"的初值上）。\n    setVersion((v) => v + 1);\n    onCleanup(() => observer.disconnect());\n  });\n\n  return version;\n}\n"],"mappings":";;AASA,SAAgBA,EACd,GACkB;CAClB,IAAM,CAACC,GAASC,KAAcC,EAAa,CAAC;CAe5C,OAbAC,QAAmB;EACjB,IAAMC,IAAUC,EAAK;EACrB,IAAI,CAACD,KAAW,OAAO,mBAAqB,KAAa;EAEzD,IAAME,IAAW,IAAI,uBAAuBL,GAAY,MAAMM,IAAI,CAAC,CAAC;EAMpE,AALAD,EAAS,QAAQF,GAAS;GAAE,WAAW;GAAM,SAAS;EAAK,CAAC,GAI5DH,GAAY,MAAMM,IAAI,CAAC,GACvBC,QAAgBF,EAAS,WAAW,CAAC;CACvC,CAAC,GAEMN;AACT"}

package/dist/components/questionnaire/questionnaire.focus.d.ts

@@ -0,0 +1,26 @@
+import { QuestionnaireAnswerEntry } from './questionnaire.context';
+/**
+ * 题目内的焦点移动。
+ *
+ * 单一职责：给定题目作用域、当前焦点元素与已注册答案，决定"下一个该聚焦谁"，
+ * 并处理随之而来的原生 radio 点击。不持有状态、不读信号，因此可以用真实 DOM
+ * 直接驱动每一个分支（无可用目标、目标不在列表内、循环回自身等）。
+ */
+/** 把焦点放到题目内最合适的元素：优先"已有值"的具名输入，其次任意可编辑控件，最后退到作用域本身 */
+export declare function focusItem(scope: HTMLElement | undefined): void;
+export interface MoveAnswerFocusOptions {
+    /** 题目作用域（fieldset） */
+    scope: HTMLElement | undefined;
+    /** 当前焦点所在元素 */
+    target: Element;
+    direction: "next" | "previous";
+    answers: readonly QuestionnaireAnswerEntry[];
+}
+/**
+ * 在可聚焦答案之间移动焦点：
+ * - 跳过禁用与已卸载的答案；
+ * - 当前目标是输入类控件时，跳过其它输入类控件（避免在文本框之间乱跳）；
+ * - 目标不在列表里但就是作用域本身时，从列表首/尾开始；否则不动；
+ * - 环形移动；落到原生 radio 上时顺带点击它（radio 的箭头语义）。
+ */
+export declare function moveAnswerFocus(options: MoveAnswerFocusOptions): boolean;

package/dist/components/questionnaire/questionnaire.focus.js

@@ -0,0 +1,19 @@
+import { isAnswerDisabled as e, isNativeRadio as t, isTypingElement as n } from "./questionnaire.utils.js";
+//#region src/components/questionnaire/questionnaire.focus.ts
+function r(e) {
+	if (!e) return;
+	let t = e.querySelector("input[data-filled][name]:not(:disabled)"), n = e.querySelector("input:not([type=hidden]):not(:disabled), textarea:not(:disabled)");
+	(t ?? n ?? e).focus();
+}
+function i(r) {
+	let { scope: i, target: a, direction: o, answers: s } = r, c = s.filter((t) => !e(t) && t.element.isConnected && !(n(a) && t.type === "input"));
+	if (!c.length) return !1;
+	let l = c.findIndex((e) => e.element === a);
+	if (l < 0 && a !== i) return !1;
+	let u = c[l < 0 ? o === "next" ? 0 : c.length - 1 : (l + (o === "next" ? 1 : -1) + c.length) % c.length];
+	return !u || u.element === a ? !1 : (u.element.focus(), u.type === "choice" && t(u.element) && u.element.click(), !0);
+}
+//#endregion
+export { r as focusItem, i as moveAnswerFocus };
+
+//# sourceMappingURL=questionnaire.focus.js.map

package/dist/components/questionnaire/questionnaire.focus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.focus.js","names":["focusItem","scope","filled","anyInput","moveAnswerFocus","options","focusable","answers","isAnswerDisabled","entry","isTypingElement","target","position","next","direction","isNativeRadio"],"sources":["../../../src/components/questionnaire/questionnaire.focus.ts"],"sourcesContent":["import type { QuestionnaireAnswerEntry } from \"./questionnaire.context\";\nimport {\n  isAnswerDisabled,\n  isNativeRadio,\n  isTypingElement,\n} from \"./questionnaire.utils\";\n\n/**\n * 题目内的焦点移动。\n *\n * 单一职责：给定题目作用域、当前焦点元素与已注册答案，决定\"下一个该聚焦谁\"，\n * 并处理随之而来的原生 radio 点击。不持有状态、不读信号，因此可以用真实 DOM\n * 直接驱动每一个分支（无可用目标、目标不在列表内、循环回自身等）。\n */\n\n/** 把焦点放到题目内最合适的元素：优先\"已有值\"的具名输入，其次任意可编辑控件，最后退到作用域本身 */\nexport function focusItem(scope: HTMLElement | undefined): void {\n  if (!scope) return;\n  const filled = scope.querySelector<HTMLElement>(\n    \"input[data-filled][name]:not(:disabled)\",\n  );\n  const anyInput = scope.querySelector<HTMLElement>(\n    \"input:not([type=hidden]):not(:disabled), textarea:not(:disabled)\",\n  );\n  (filled ?? anyInput ?? scope).focus();\n}\n\nexport interface MoveAnswerFocusOptions {\n  /** 题目作用域（fieldset） */\n  scope: HTMLElement | undefined;\n  /** 当前焦点所在元素 */\n  target: Element;\n  direction: \"next\" | \"previous\";\n  answers: readonly QuestionnaireAnswerEntry[];\n}\n\n/**\n * 在可聚焦答案之间移动焦点：\n * - 跳过禁用与已卸载的答案；\n * - 当前目标是输入类控件时，跳过其它输入类控件（避免在文本框之间乱跳）；\n * - 目标不在列表里但就是作用域本身时，从列表首/尾开始；否则不动；\n * - 环形移动；落到原生 radio 上时顺带点击它（radio 的箭头语义）。\n */\nexport function moveAnswerFocus(options: MoveAnswerFocusOptions): boolean {\n  const { scope, target, direction, answers } = options;\n\n  const focusable = answers.filter(\n    (entry) =>\n      !isAnswerDisabled(entry) &&\n      entry.element.isConnected &&\n      !(isTypingElement(target) && entry.type === \"input\"),\n  );\n  if (!focusable.length) return false;\n\n  const position = focusable.findIndex((entry) => entry.element === target);\n  if (position < 0 && target !== scope) return false;\n\n  const nextIndex =\n    position < 0\n      ? direction === \"next\"\n        ? 0\n        : focusable.length - 1\n      : (position + (direction === \"next\" ? 1 : -1) + focusable.length) %\n        focusable.length;\n\n  const next = focusable[nextIndex];\n  if (!next || next.element === target) return false;\n\n  next.element.focus();\n  if (next.type === \"choice\" && isNativeRadio(next.element)) {\n    (next.element as HTMLInputElement).click();\n  }\n  return true;\n}\n"],"mappings":";;AAgBA,SAAgBA,EAAU,GAAsC;CAC9D,IAAI,CAACC,GAAO;CACZ,IAAMC,IAASD,EAAM,cACnB,yCACF,GACME,IAAWF,EAAM,cACrB,kEACF;CACA,CAACC,KAAUC,KAAYF,EAAA,CAAO,MAAM;AACtC;AAkBA,SAAgBG,EAAgB,GAA0C;CACxE,IAAM,EAAE,UAAO,WAAQ,cAAW,eAAYC,GAExCC,IAAYC,EAAQ,QACvB,MACC,CAACC,EAAiBC,CAAK,KACvBA,EAAM,QAAQ,eACd,EAAEC,EAAgBC,CAAM,KAAKF,EAAM,SAAS,QAChD;CACA,IAAI,CAACH,EAAU,QAAQ,OAAO;CAE9B,IAAMM,IAAWN,EAAU,WAAW,MAAUG,EAAM,YAAYE,CAAM;CACxE,IAAIC,IAAW,KAAKD,MAAWV,GAAO,OAAO;CAU7C,IAAMY,IAAOP,EAPXM,IAAW,IACPE,MAAc,SACZ,IACAR,EAAU,SAAS,KACpBM,KAAYE,MAAc,SAAS,IAAI,MAAMR,EAAU,UACxDA,EAAU;CAShB,OANI,CAACO,KAAQA,EAAK,YAAYF,IAAe,MAE7CE,EAAK,QAAQ,MAAM,GACfA,EAAK,SAAS,YAAYE,EAAcF,EAAK,OAAO,KACtDA,EAAM,QAA6B,MAAM,GAEpC;AACT"}

package/dist/components/questionnaire/questionnaire.item-view.d.ts

@@ -0,0 +1,50 @@
+import { Accessor } from 'solid-js';
+import { QuestionnaireItemHandle } from './questionnaire.context';
+import { QuestionnaireItemDefinition } from './questionnaire.types';
+export interface ItemViewOptions {
+    /** 已注册的题目句柄（注册顺序） */
+    registered: Accessor<QuestionnaireItemHandle[]>;
+    /** DOM 结构版本号：子节点换位后据此重排 */
+    domVersion: Accessor<number>;
+    /** 受控的激活项名字（undefined 表示非受控） */
+    controlledItem: Accessor<string | undefined>;
+    /** 非受控模式下内部记录的激活项名字 */
+    internalName: Accessor<string | null>;
+    /** 声明式题目定义（用于快捷键与校验元数据） */
+    definitions: Accessor<readonly QuestionnaireItemDefinition[] | undefined>;
+}
+export interface ItemView {
+    /** 按 DOM 顺序排列的全部题目 */
+    ordered: Accessor<QuestionnaireItemHandle[]>;
+    /** 可参与导航的题目（排除 disabled） */
+    enabled: Accessor<QuestionnaireItemHandle[]>;
+    /** 当前激活题目的名字 */
+    activeName: Accessor<string | null>;
+    /** 当前激活题目（不在可用列表时为 null） */
+    activeItem: Accessor<QuestionnaireItemHandle | null>;
+    /** 可用题目数、激活项下标（-1 表示不在列表里） */
+    total: Accessor<number>;
+    index: Accessor<number>;
+    /** 面向用户的进度：从 1 开始，没有激活项时为 0 */
+    current: Accessor<number>;
+    first: Accessor<boolean>;
+    last: Accessor<boolean>;
+    /** 题目定义按名字建索引；未提供定义时为 null */
+    itemDefinitions: Accessor<Map<string, QuestionnaireItemDefinition> | null>;
+}
+/**
+ * 题目视图：把"注册表 + DOM 版本 + 当前项"推导成导航需要的派生状态。
+ *
+ * 单一职责：只做派生计算（排序、过滤、定位、进度、定义索引），
+ * 不改变任何状态——所以它可以在不触发导航的前提下被单独断言。
+ */
+export declare function createItemView(options: ItemViewOptions): ItemView;
+/**
+ * 该激活哪个题目：优先受控值与 `defaultItem`，两者都不在可用列表里时退到第一个。
+ * 纯函数——列表与候选值都由调用方给出。
+ */
+export declare function resolveActiveName(options: {
+    enabled: readonly QuestionnaireItemHandle[];
+    controlledItem: string | undefined;
+    defaultItem: string | undefined;
+}): string | null;

package/dist/components/questionnaire/questionnaire.item-view.js

@@ -0,0 +1,36 @@
+import { compareDocumentOrder as e } from "./questionnaire.utils.js";
+import { createMemo as t } from "solid-js";
+//#region src/components/questionnaire/questionnaire.item-view.ts
+function n(n) {
+	let r = t(() => {
+		n.domVersion();
+		let t = n.registered();
+		return [...t].sort((n, r) => {
+			let i = e(n.element, r.element);
+			return i === 0 ? t.indexOf(n) - t.indexOf(r) : i;
+		});
+	}), i = t(() => r().filter((e) => !e.disabled())), a = t(() => n.controlledItem() ?? n.internalName()), o = t(() => i().find((e) => e.name === a()) ?? null), s = t(() => i().length), c = t(() => i().findIndex((e) => e.name === a())), l = t(() => c() < 0 ? 0 : c() + 1), u = t(() => {
+		let e = n.definitions();
+		return e ? new Map(e.map((e) => [e.name, e])) : null;
+	});
+	return {
+		ordered: r,
+		enabled: i,
+		activeName: a,
+		activeItem: o,
+		total: s,
+		index: c,
+		current: l,
+		first: t(() => s() > 0 && c() === 0),
+		last: t(() => s() > 0 && c() === s() - 1),
+		itemDefinitions: u
+	};
+}
+function r(e) {
+	let { enabled: t, controlledItem: n, defaultItem: r } = e, i = n ?? r;
+	return i && t.some((e) => e.name === i) ? i : t[0]?.name ?? null;
+}
+//#endregion
+export { n as createItemView, r as resolveActiveName };
+
+//# sourceMappingURL=questionnaire.item-view.js.map

package/dist/components/questionnaire/questionnaire.item-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.item-view.js","names":["createItemView","ordered","createMemo","registered","options","byDom","compareDocumentOrder","a","b","enabled","item","activeName","activeItem","total","index","current","itemDefinitions","list","definition","resolveActiveName","candidate","controlledItem","defaultItem","entry"],"sources":["../../../src/components/questionnaire/questionnaire.item-view.ts"],"sourcesContent":["import { createMemo, type Accessor } from \"solid-js\";\nimport type { QuestionnaireItemHandle } from \"./questionnaire.context\";\nimport type { QuestionnaireItemDefinition } from \"./questionnaire.types\";\nimport { compareDocumentOrder } from \"./questionnaire.utils\";\n\nexport interface ItemViewOptions {\n  /** 已注册的题目句柄（注册顺序） */\n  registered: Accessor<QuestionnaireItemHandle[]>;\n  /** DOM 结构版本号：子节点换位后据此重排 */\n  domVersion: Accessor<number>;\n  /** 受控的激活项名字（undefined 表示非受控） */\n  controlledItem: Accessor<string | undefined>;\n  /** 非受控模式下内部记录的激活项名字 */\n  internalName: Accessor<string | null>;\n  /** 声明式题目定义（用于快捷键与校验元数据） */\n  definitions: Accessor<readonly QuestionnaireItemDefinition[] | undefined>;\n}\n\nexport interface ItemView {\n  /** 按 DOM 顺序排列的全部题目 */\n  ordered: Accessor<QuestionnaireItemHandle[]>;\n  /** 可参与导航的题目（排除 disabled） */\n  enabled: Accessor<QuestionnaireItemHandle[]>;\n  /** 当前激活题目的名字 */\n  activeName: Accessor<string | null>;\n  /** 当前激活题目（不在可用列表时为 null） */\n  activeItem: Accessor<QuestionnaireItemHandle | null>;\n  /** 可用题目数、激活项下标（-1 表示不在列表里） */\n  total: Accessor<number>;\n  index: Accessor<number>;\n  /** 面向用户的进度：从 1 开始，没有激活项时为 0 */\n  current: Accessor<number>;\n  first: Accessor<boolean>;\n  last: Accessor<boolean>;\n  /** 题目定义按名字建索引；未提供定义时为 null */\n  itemDefinitions: Accessor<Map<string, QuestionnaireItemDefinition> | null>;\n}\n\n/**\n * 题目视图：把\"注册表 + DOM 版本 + 当前项\"推导成导航需要的派生状态。\n *\n * 单一职责：只做派生计算（排序、过滤、定位、进度、定义索引），\n * 不改变任何状态——所以它可以在不触发导航的前提下被单独断言。\n */\nexport function createItemView(options: ItemViewOptions): ItemView {\n  /**\n   * 排序键：DOM 顺序优先；两者都还没连进文档（注册早于插入）时返回 0，\n   * 由 sort 的稳定性保持注册顺序——注册顺序就是渲染顺序，因此初始挂载也是对的。\n   * 节点连上文档后 domVersion 会变化，这里再按真实 DOM 顺序收敛。\n   */\n  const ordered = createMemo(() => {\n    options.domVersion();\n    const registered = options.registered();\n    return [...registered].sort((a, b) => {\n      const byDom = compareDocumentOrder(a.element, b.element);\n      if (byDom !== 0) return byDom;\n      return registered.indexOf(a) - registered.indexOf(b);\n    });\n  });\n\n  const enabled = createMemo(() =>\n    ordered().filter((item) => !item.disabled()),\n  );\n\n  const activeName = createMemo(\n    () => options.controlledItem() ?? options.internalName(),\n  );\n\n  const activeItem = createMemo(\n    () => enabled().find((item) => item.name === activeName()) ?? null,\n  );\n\n  const total = createMemo(() => enabled().length);\n\n  const index = createMemo(() =>\n    enabled().findIndex((item) => item.name === activeName()),\n  );\n\n  const current = createMemo(() => (index() < 0 ? 0 : index() + 1));\n\n  const itemDefinitions = createMemo(() => {\n    const list = options.definitions();\n    if (!list) return null;\n    return new Map(list.map((definition) => [definition.name, definition]));\n  });\n\n  return {\n    ordered,\n    enabled,\n    activeName,\n    activeItem,\n    total,\n    index,\n    current,\n    first: createMemo(() => total() > 0 && index() === 0),\n    last: createMemo(() => total() > 0 && index() === total() - 1),\n    itemDefinitions,\n  };\n}\n\n/**\n * 该激活哪个题目：优先受控值与 `defaultItem`，两者都不在可用列表里时退到第一个。\n * 纯函数——列表与候选值都由调用方给出。\n */\nexport function resolveActiveName(options: {\n  enabled: readonly QuestionnaireItemHandle[];\n  controlledItem: string | undefined;\n  defaultItem: string | undefined;\n}): string | null {\n  const { enabled, controlledItem, defaultItem } = options;\n  const candidate = controlledItem ?? defaultItem;\n  if (candidate && enabled.some((entry) => entry.name === candidate)) {\n    return candidate;\n  }\n  return enabled[0]?.name ?? null;\n}\n"],"mappings":";;;AA4CA,SAAgBA,EAAe,GAAoC;CAMjE,IAAMC,IAAUC,QAAiB;EAC/B,EAAQ,WAAW;EACnB,IAAMC,IAAaC,EAAQ,WAAW;EACtC,OAAO,CAAC,GAAGD,CAAU,CAAC,CAAC,MAAM,GAAG,MAAM;GACpC,IAAME,IAAQC,EAAqBC,EAAE,SAASC,EAAE,OAAO;GAEvD,OADIH,MAAU,IACPF,EAAW,QAAQI,CAAC,IAAIJ,EAAW,QAAQK,CAAC,IAD3BH;EAE1B,CAAC;CACH,CAAC,GAEKI,IAAUP,QACdD,EAAQ,CAAC,CAAC,QAAQ,MAAS,CAACS,EAAK,SAAS,CAAC,CAC7C,GAEMC,IAAaT,QACXE,EAAQ,eAAe,KAAKA,EAAQ,aAAa,CACzD,GAEMQ,IAAaV,QACXO,EAAQ,CAAC,CAAC,MAAM,MAASC,EAAK,SAASC,EAAW,CAAC,KAAK,IAChE,GAEME,IAAQX,QAAiBO,EAAQ,CAAC,CAAC,MAAM,GAEzCK,IAAQZ,QACZO,EAAQ,CAAC,CAAC,WAAW,MAASC,EAAK,SAASC,EAAW,CAAC,CAC1D,GAEMI,IAAUb,QAAkBY,EAAM,IAAI,IAAI,IAAIA,EAAM,IAAI,CAAE,GAE1DE,IAAkBd,QAAiB;EACvC,IAAMe,IAAOb,EAAQ,YAAY;EAEjC,OADKa,IACE,IAAI,IAAIA,EAAK,KAAK,MAAe,CAACC,EAAW,MAAMA,CAAU,CAAC,CAAC,IADpD;CAEpB,CAAC;CAED,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAOhB,QAAiBW,EAAM,IAAI,KAAKC,EAAM,MAAM,CAAC;EACpD,MAAMZ,QAAiBW,EAAM,IAAI,KAAKC,EAAM,MAAMD,EAAM,IAAI,CAAC;EAC7D;CACF;AACF;AAMA,SAAgBM,EAAkB,GAIhB;CAChB,IAAM,EAAE,YAAS,mBAAgB,mBAAgBf,GAC3CgB,IAAYC,KAAkBC;CAIpC,OAHIF,KAAaX,EAAQ,MAAM,MAAUc,EAAM,SAASH,CAAS,IACxDA,IAEFX,EAAQ,EAAE,EAAE,QAAQ;AAC7B"}

package/dist/components/questionnaire/questionnaire.keys.d.ts

@@ -0,0 +1,29 @@
+import { QuestionnaireItemHandle } from './questionnaire.context';
+import { QuestionnaireItemStatus, QuestionnaireShortcutMode } from './questionnaire.types';
+/** 键盘派发需要的能力（注入即可脱离 Solid 与 DOM 状态单独测试） */
+export interface QuestionnaireKeyboardContext {
+    /** 当前激活的题目 */
+    item: QuestionnaireItemHandle;
+    /** 当前题目的作答状态（未作答时 ArrowRight 不前进） */
+    status: () => QuestionnaireItemStatus;
+    /** 快捷键模式，null 表示关闭 */
+    shortcuts: QuestionnaireShortcutMode | null;
+    goNext: () => void;
+    goPrevious: () => void;
+    /** 最后一题提交，否则前进 */
+    submitOrNext: () => void;
+}
+/**
+ * 问卷表单的按键映射：一个纯派发器——只把按键翻译成导航动作，
+ * 不持有状态（当前题、状态、快捷键模式都由 `ctx` 提供）。
+ *
+ * 处理顺序（先到先得，命中即 `preventDefault` 并返回）：
+ * 1. 输入法组合中 / 已被他人处理 / 事件目标不是元素 → 直接放行；
+ * 2. Mod+Enter → 提交或前进（长按不重复触发）；
+ * 3. 带 Ctrl/Meta/Alt 的其它组合 → 放行给浏览器；
+ * 4. 上下箭头 → 在当前题目的答案间移动焦点（`moveAnswerFocus` 说了算）；
+ * 5. 左右箭头 → 切上一题 / 下一题（文本输入与原生 radio 上不切题）；
+ * 6. Enter 在已填写的答案控件上 → 提交或前进；
+ * 7. 其余情况 → 按快捷键模式匹配答案（letters/numbers），命中则聚焦并点击。
+ */
+export declare function handleQuestionnaireKeyDown(event: KeyboardEvent, ctx: QuestionnaireKeyboardContext): void;

package/dist/components/questionnaire/questionnaire.keys.js

@@ -0,0 +1,34 @@
+import { isAnswerFilled as e, isNativeRadio as t, isTypingElement as n, normalizeShortcut as r } from "./questionnaire.utils.js";
+//#region src/components/questionnaire/questionnaire.keys.ts
+function i(i, a) {
+	let { item: o } = a;
+	if (i.defaultPrevented || i.isComposing || i.keyCode === 229 || !(i.target instanceof Element)) return;
+	let s = i.target;
+	if (i.key === "Enter" && (i.metaKey || i.ctrlKey) && !i.altKey && !i.shiftKey) {
+		i.preventDefault(), i.repeat || a.submitOrNext();
+		return;
+	}
+	if (i.metaKey || i.ctrlKey || i.altKey) return;
+	if ((i.key === "ArrowUp" || i.key === "ArrowDown") && o.moveAnswerFocus(s, i.key === "ArrowDown" ? "next" : "previous")) {
+		i.preventDefault();
+		return;
+	}
+	if ((i.key === "ArrowLeft" || i.key === "ArrowRight") && !n(s) && !t(s)) {
+		if (i.preventDefault(), i.repeat) return;
+		i.key === "ArrowLeft" ? a.goPrevious() : a.status() !== "unanswered" && a.goNext();
+		return;
+	}
+	if (i.key === "Enter") {
+		let t = o.getAnswerByElement(s);
+		if (!t) return;
+		i.preventDefault(), !i.repeat && e(t) && a.submitOrNext();
+		return;
+	}
+	if (!a.shortcuts || n(s)) return;
+	let c = r(i.key, a.shortcuts), l = c ? o.getAnswerByShortcut(c) : null;
+	l && (i.preventDefault(), !i.repeat && (l.element.focus(), l.type === "choice" && l.element.click()));
+}
+//#endregion
+export { i as handleQuestionnaireKeyDown };
+
+//# sourceMappingURL=questionnaire.keys.js.map

package/dist/components/questionnaire/questionnaire.keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.keys.js","names":["handleQuestionnaireKeyDown","ctx","event","target","item","isTypingElement","isNativeRadio","answer","isAnswerFilled","shortcut","normalizeShortcut"],"sources":["../../../src/components/questionnaire/questionnaire.keys.ts"],"sourcesContent":["import type {\n  QuestionnaireAnswerEntry,\n  QuestionnaireItemHandle,\n} from \"./questionnaire.context\";\nimport type {\n  QuestionnaireItemStatus,\n  QuestionnaireShortcutMode,\n} from \"./questionnaire.types\";\nimport {\n  isAnswerFilled,\n  isNativeRadio,\n  isTypingElement,\n  normalizeShortcut,\n} from \"./questionnaire.utils\";\n\n/** 键盘派发需要的能力（注入即可脱离 Solid 与 DOM 状态单独测试） */\nexport interface QuestionnaireKeyboardContext {\n  /** 当前激活的题目 */\n  item: QuestionnaireItemHandle;\n  /** 当前题目的作答状态（未作答时 ArrowRight 不前进） */\n  status: () => QuestionnaireItemStatus;\n  /** 快捷键模式，null 表示关闭 */\n  shortcuts: QuestionnaireShortcutMode | null;\n  goNext: () => void;\n  goPrevious: () => void;\n  /** 最后一题提交，否则前进 */\n  submitOrNext: () => void;\n}\n\n/**\n * 问卷表单的按键映射：一个纯派发器——只把按键翻译成导航动作，\n * 不持有状态（当前题、状态、快捷键模式都由 `ctx` 提供）。\n *\n * 处理顺序（先到先得，命中即 `preventDefault` 并返回）：\n * 1. 输入法组合中 / 已被他人处理 / 事件目标不是元素 → 直接放行；\n * 2. Mod+Enter → 提交或前进（长按不重复触发）；\n * 3. 带 Ctrl/Meta/Alt 的其它组合 → 放行给浏览器；\n * 4. 上下箭头 → 在当前题目的答案间移动焦点（`moveAnswerFocus` 说了算）；\n * 5. 左右箭头 → 切上一题 / 下一题（文本输入与原生 radio 上不切题）；\n * 6. Enter 在已填写的答案控件上 → 提交或前进；\n * 7. 其余情况 → 按快捷键模式匹配答案（letters/numbers），命中则聚焦并点击。\n */\nexport function handleQuestionnaireKeyDown(\n  event: KeyboardEvent,\n  ctx: QuestionnaireKeyboardContext,\n): void {\n  const { item } = ctx;\n  if (\n    event.defaultPrevented ||\n    event.isComposing ||\n    event.keyCode === 229 ||\n    !(event.target instanceof Element)\n  ) {\n    return;\n  }\n  const target = event.target;\n\n  if (\n    event.key === \"Enter\" &&\n    (event.metaKey || event.ctrlKey) &&\n    !event.altKey &&\n    !event.shiftKey\n  ) {\n    event.preventDefault();\n    if (!event.repeat) ctx.submitOrNext();\n    return;\n  }\n  if (event.metaKey || event.ctrlKey || event.altKey) return;\n\n  if (\n    (event.key === \"ArrowUp\" || event.key === \"ArrowDown\") &&\n    item.moveAnswerFocus(\n      target,\n      event.key === \"ArrowDown\" ? \"next\" : \"previous\",\n    )\n  ) {\n    event.preventDefault();\n    return;\n  }\n\n  if (\n    (event.key === \"ArrowLeft\" || event.key === \"ArrowRight\") &&\n    !isTypingElement(target) &&\n    !isNativeRadio(target)\n  ) {\n    event.preventDefault();\n    if (event.repeat) return;\n    if (event.key === \"ArrowLeft\") ctx.goPrevious();\n    else if (ctx.status() !== \"unanswered\") ctx.goNext();\n    return;\n  }\n\n  if (event.key === \"Enter\") {\n    const answer = item.getAnswerByElement(target);\n    if (!answer) return;\n    event.preventDefault();\n    if (!event.repeat && isAnswerFilled(answer)) ctx.submitOrNext();\n    return;\n  }\n\n  if (!ctx.shortcuts || isTypingElement(target)) return;\n  const shortcut = normalizeShortcut(event.key, ctx.shortcuts);\n  const answer: QuestionnaireAnswerEntry | null = shortcut\n    ? item.getAnswerByShortcut(shortcut)\n    : null;\n  if (!answer) return;\n  event.preventDefault();\n  if (event.repeat) return;\n  answer.element.focus();\n  if (answer.type === \"choice\") {\n    (answer.element as HTMLInputElement).click();\n  }\n}\n"],"mappings":";;AA0CA,SAAgBA,EACd,GACA,GACM;CACN,IAAM,EAAE,YAASC;CACjB,IACEC,EAAM,oBACNA,EAAM,eACNA,EAAM,YAAY,OAClB,EAAEA,EAAM,kBAAkB,UAE1B;CAEF,IAAMC,IAASD,EAAM;CAErB,IACEA,EAAM,QAAQ,YACbA,EAAM,WAAWA,EAAM,YACxB,CAACA,EAAM,UACP,CAACA,EAAM,UACP;EAEA,AADAA,EAAM,eAAe,GAChBA,EAAM,UAAQD,EAAI,aAAa;EACpC;CACF;CACA,IAAIC,EAAM,WAAWA,EAAM,WAAWA,EAAM,QAAQ;CAEpD,KACGA,EAAM,QAAQ,aAAaA,EAAM,QAAQ,gBAC1CE,EAAK,gBACHD,GACAD,EAAM,QAAQ,cAAc,SAAS,UACvC,GACA;EACA,EAAM,eAAe;EACrB;CACF;CAEA,KACGA,EAAM,QAAQ,eAAeA,EAAM,QAAQ,iBAC5C,CAACG,EAAgBF,CAAM,KACvB,CAACG,EAAcH,CAAM,GACrB;EAEA,IADAD,EAAM,eAAe,GACjBA,EAAM,QAAQ;EAClB,AAAIA,EAAM,QAAQ,cAAaD,EAAI,WAAW,IACrCA,EAAI,OAAO,MAAM,gBAAcA,EAAI,OAAO;EACnD;CACF;CAEA,IAAIC,EAAM,QAAQ,SAAS;EACzB,IAAMK,IAASH,EAAK,mBAAmBD,CAAM;EAC7C,IAAI,CAACI,GAAQ;EAEb,AADAL,EAAM,eAAe,GACjB,CAACA,EAAM,UAAUM,EAAeD,CAAM,KAAGN,EAAI,aAAa;EAC9D;CACF;CAEA,IAAI,CAACA,EAAI,aAAaI,EAAgBF,CAAM,GAAG;CAC/C,IAAMM,IAAWC,EAAkBR,EAAM,KAAKD,EAAI,SAAS,GACrDM,IAA0CE,IAC5CL,EAAK,oBAAoBK,CAAQ,IACjC;CACJ,AAAKF,MACLL,EAAM,eAAe,GACjB,GAAM,WACVK,EAAO,QAAQ,MAAM,GACjBA,EAAO,SAAS,YAClBA,EAAQ,QAA6B,MAAM;AAE/C"}

package/dist/components/questionnaire/questionnaire.registry.d.ts

@@ -0,0 +1,21 @@
+import { Accessor } from 'solid-js';
+import { QuestionnaireItemHandle } from './questionnaire.context';
+export interface ItemRegistry {
+    /** 已注册的题目句柄（未排序，顺序为注册顺序） */
+    items: Accessor<QuestionnaireItemHandle[]>;
+    /**
+     * 注册一个题目，返回注销函数。
+     *
+     * 同一个 DOM 元素再次注册时**替换**而不是追加：题目组件在受控 props 变化时
+     * 会用同一个 fieldset 重新注册，若追加就会出现两条指向同一元素的记录，
+     * 于是"上一题/下一题"会停在原地。
+     */
+    register: (handle: QuestionnaireItemHandle) => () => void;
+}
+/**
+ * 题目句柄注册表。
+ *
+ * 单一职责：维护"当前有哪些题目"这一份账目（加入、按元素去重替换、移除）。
+ * 不排序、不判可用性、不读答案——那些是消费方的事。
+ */
+export declare function createItemRegistry(): ItemRegistry;

package/dist/components/questionnaire/questionnaire.registry.js

@@ -0,0 +1,15 @@
+import { createSignal as e } from "solid-js";
+//#region src/components/questionnaire/questionnaire.registry.ts
+function t() {
+	let [t, n] = e([]);
+	return {
+		items: t,
+		register(e) {
+			return n((t) => t.some((t) => t.element === e.element) ? t.map((t) => t.element === e.element ? e : t) : [...t, e]), () => n((t) => t.filter((t) => t !== e));
+		}
+	};
+}
+//#endregion
+export { t as createItemRegistry };
+
+//# sourceMappingURL=questionnaire.registry.js.map

package/dist/components/questionnaire/questionnaire.registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.registry.js","names":["createItemRegistry","items","setItems","createSignal","prev","item","handle"],"sources":["../../../src/components/questionnaire/questionnaire.registry.ts"],"sourcesContent":["import { createSignal, type Accessor } from \"solid-js\";\nimport type { QuestionnaireItemHandle } from \"./questionnaire.context\";\n\nexport interface ItemRegistry {\n  /** 已注册的题目句柄（未排序，顺序为注册顺序） */\n  items: Accessor<QuestionnaireItemHandle[]>;\n  /**\n   * 注册一个题目，返回注销函数。\n   *\n   * 同一个 DOM 元素再次注册时**替换**而不是追加：题目组件在受控 props 变化时\n   * 会用同一个 fieldset 重新注册，若追加就会出现两条指向同一元素的记录，\n   * 于是\"上一题/下一题\"会停在原地。\n   */\n  register: (handle: QuestionnaireItemHandle) => () => void;\n}\n\n/**\n * 题目句柄注册表。\n *\n * 单一职责：维护\"当前有哪些题目\"这一份账目（加入、按元素去重替换、移除）。\n * 不排序、不判可用性、不读答案——那些是消费方的事。\n */\nexport function createItemRegistry(): ItemRegistry {\n  const [items, setItems] = createSignal<QuestionnaireItemHandle[]>([]);\n\n  return {\n    items,\n    register(handle) {\n      setItems((prev) => {\n        const exists = prev.some((item) => item.element === handle.element);\n        return exists\n          ? prev.map((item) =>\n              item.element === handle.element ? handle : item,\n            )\n          : [...prev, handle];\n      });\n      return () => setItems((prev) => prev.filter((item) => item !== handle));\n    },\n  };\n}\n"],"mappings":";;AAsBA,SAAgBA,IAAmC;CACjD,IAAM,CAACC,GAAOC,KAAYC,EAAwC,CAAC,CAAC;CAEpE,OAAO;EACL;EACA,SAAS,GAAQ;GASf,OARAD,GAAU,MACOE,EAAK,MAAM,MAASC,EAAK,YAAYC,EAAO,OACpD,IACHF,EAAK,KAAK,MACRC,EAAK,YAAYC,EAAO,UAAUA,IAASD,CAC7C,IACA,CAAC,GAAGD,GAAME,CAAM,CACrB,SACYJ,GAAU,MAASE,EAAK,QAAQ,MAASC,MAASC,CAAM,CAAC;EACxE;CACF;AACF"}

package/dist/components/questionnaire/questionnaire.shortcuts.d.ts

@@ -0,0 +1,24 @@
+import { QuestionnaireAnswerEntry } from './questionnaire.context';
+import { QuestionnaireItemDefinition, QuestionnaireShortcutMode } from './questionnaire.types';
+/**
+ * 题目的快捷键推导。
+ *
+ * 单一职责：把"定义里的 choices / 已注册的答案 / 快捷键模式"换算成
+ * `值或 id → 字母` 的映射，以及反向查找。全部是纯函数——
+ * 不读信号、不碰 DOM，因此三种来源的组合都能单独断言。
+ *
+ * 两套映射互斥：
+ * - 定义里声明了 choices 时按 **choice.value** 分配字母（与选项顺序一致，
+ *   跳过 disabled，字母用尽即停）；
+ * - 否则按 **answer.id** 给已注册的 choice 类型答案依次分配。
+ */
+/** 声明式选项的映射；没有 shortcuts 模式或定义里没有 choices 时返回 null */
+export declare function buildShortcutByChoiceValue(definition: QuestionnaireItemDefinition | undefined, mode: QuestionnaireShortcutMode | null): Map<string, string> | null;
+/** 已注册答案的映射；已有声明式映射时返回空表（两套不并用） */
+export declare function buildShortcutByAnswerId(answers: readonly QuestionnaireAnswerEntry[], hasChoiceValueMap: boolean, mode: QuestionnaireShortcutMode | null): Map<string, string>;
+/** 按字母反查答案：优先走声明式映射（比对 value），否则走 id 映射 */
+export declare function findAnswerByShortcut(shortcut: string, maps: {
+    byChoiceValue: Map<string, string> | null;
+    byAnswerId: Map<string, string>;
+    answers: readonly QuestionnaireAnswerEntry[];
+}): QuestionnaireAnswerEntry | null;

package/dist/components/questionnaire/questionnaire.shortcuts.js

@@ -0,0 +1,31 @@
+import { shortcutAlphabet as e } from "./questionnaire.utils.js";
+//#region src/components/questionnaire/questionnaire.shortcuts.ts
+function t(t, n) {
+	if (!n || !t?.choices) return null;
+	let r = e(n), i = /* @__PURE__ */ new Map(), a = 0;
+	for (let e of t.choices) {
+		if (e.disabled) continue;
+		let t = r[a];
+		if (!t) break;
+		i.set(e.value, t), a += 1;
+	}
+	return i;
+}
+function n(t, n, r) {
+	if (n) return /* @__PURE__ */ new Map();
+	let i = e(r), a = t.filter((e) => e.type === "choice");
+	return new Map(a.slice(0, i.length).map((e, t) => [e.id, i[t]]));
+}
+function r(e, t) {
+	let { byChoiceValue: n, byAnswerId: r, answers: i } = t;
+	if (n) {
+		let t = [...n.entries()].find(([, t]) => t === e)?.[0];
+		return i.find((e) => e.type === "choice" && e.value === t) ?? null;
+	}
+	let a = [...r.entries()].find(([, t]) => t === e)?.[0];
+	return i.find((e) => e.id === a) ?? null;
+}
+//#endregion
+export { n as buildShortcutByAnswerId, t as buildShortcutByChoiceValue, r as findAnswerByShortcut };
+
+//# sourceMappingURL=questionnaire.shortcuts.js.map

package/dist/components/questionnaire/questionnaire.shortcuts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.shortcuts.js","names":["buildShortcutByChoiceValue","mode","definition","alphabet","shortcutAlphabet","map","cursor","choice","letter","buildShortcutByAnswerId","hasChoiceValueMap","choices","answers","entry","index","findAnswerByShortcut","maps","byChoiceValue","value","shortcut","id","byAnswerId"],"sources":["../../../src/components/questionnaire/questionnaire.shortcuts.ts"],"sourcesContent":["import type { QuestionnaireAnswerEntry } from \"./questionnaire.context\";\nimport type {\n  QuestionnaireItemDefinition,\n  QuestionnaireShortcutMode,\n} from \"./questionnaire.types\";\nimport { shortcutAlphabet } from \"./questionnaire.utils\";\n\n/**\n * 题目的快捷键推导。\n *\n * 单一职责：把\"定义里的 choices / 已注册的答案 / 快捷键模式\"换算成\n * `值或 id → 字母` 的映射，以及反向查找。全部是纯函数——\n * 不读信号、不碰 DOM，因此三种来源的组合都能单独断言。\n *\n * 两套映射互斥：\n * - 定义里声明了 choices 时按 **choice.value** 分配字母（与选项顺序一致，\n *   跳过 disabled，字母用尽即停）；\n * - 否则按 **answer.id** 给已注册的 choice 类型答案依次分配。\n */\n\n/** 声明式选项的映射；没有 shortcuts 模式或定义里没有 choices 时返回 null */\nexport function buildShortcutByChoiceValue(\n  definition: QuestionnaireItemDefinition | undefined,\n  mode: QuestionnaireShortcutMode | null,\n): Map<string, string> | null {\n  if (!mode || !definition?.choices) return null;\n\n  const alphabet = shortcutAlphabet(mode);\n  const map = new Map<string, string>();\n  let cursor = 0;\n  for (const choice of definition.choices) {\n    if (choice.disabled) continue;\n    const letter = alphabet[cursor];\n    if (!letter) break;\n    map.set(choice.value, letter);\n    cursor += 1;\n  }\n  return map;\n}\n\n/** 已注册答案的映射；已有声明式映射时返回空表（两套不并用） */\nexport function buildShortcutByAnswerId(\n  answers: readonly QuestionnaireAnswerEntry[],\n  hasChoiceValueMap: boolean,\n  mode: QuestionnaireShortcutMode | null,\n): Map<string, string> {\n  if (hasChoiceValueMap) return new Map();\n\n  const alphabet = shortcutAlphabet(mode);\n  const choices = answers.filter((entry) => entry.type === \"choice\");\n  return new Map(\n    choices\n      .slice(0, alphabet.length)\n      .map((entry, index) => [entry.id, alphabet[index]!]),\n  );\n}\n\n/** 按字母反查答案：优先走声明式映射（比对 value），否则走 id 映射 */\nexport function findAnswerByShortcut(\n  shortcut: string,\n  maps: {\n    byChoiceValue: Map<string, string> | null;\n    byAnswerId: Map<string, string>;\n    answers: readonly QuestionnaireAnswerEntry[];\n  },\n): QuestionnaireAnswerEntry | null {\n  const { byChoiceValue, byAnswerId, answers } = maps;\n\n  if (byChoiceValue) {\n    const value = [...byChoiceValue.entries()].find(\n      ([, letter]) => letter === shortcut,\n    )?.[0];\n    return (\n      answers.find(\n        (entry) => entry.type === \"choice\" && entry.value === value,\n      ) ?? null\n    );\n  }\n\n  const id = [...byAnswerId.entries()].find(\n    ([, letter]) => letter === shortcut,\n  )?.[0];\n  return answers.find((entry) => entry.id === id) ?? null;\n}\n"],"mappings":";;AAqBA,SAAgBA,EACd,GACA,GAC4B;CAC5B,IAAI,CAACC,KAAQ,CAACC,GAAY,SAAS,OAAO;CAE1C,IAAMC,IAAWC,EAAiBH,CAAI,GAChCI,oBAAM,IAAI,IAAoB,GAChCC,IAAS;CACb,KAAK,IAAMC,KAAUL,EAAW,SAAS;EACvC,IAAIK,EAAO,UAAU;EACrB,IAAMC,IAASL,EAASG;EACxB,IAAI,CAACE,GAAQ;EAEb,AADAH,EAAI,IAAIE,EAAO,OAAOC,CAAM,GAC5B,KAAU;CACZ;CACA,OAAOH;AACT;AAGA,SAAgBI,EACd,GACA,GACA,GACqB;CACrB,IAAIC,GAAmB,uBAAO,IAAI,IAAI;CAEtC,IAAMP,IAAWC,EAAiBH,CAAI,GAChCU,IAAUC,EAAQ,QAAQ,MAAUC,EAAM,SAAS,QAAQ;CACjE,OAAO,IAAI,IACTF,EACG,MAAM,GAAGR,EAAS,MAAM,CAAC,CACzB,KAAK,GAAO,MAAU,CAACU,EAAM,IAAIV,EAASW,EAAO,CAAC,CACvD;AACF;AAGA,SAAgBC,EACd,GACA,GAKiC;CACjC,IAAM,EAAE,kBAAe,eAAY,eAAYC;CAE/C,IAAIC,GAAe;EACjB,IAAMC,IAAQ,CAAC,GAAGD,EAAc,QAAQ,CAAC,CAAC,CAAC,MACxC,GAAGT,OAAYA,MAAWW,CAC7B,CAAC,GAAG;EACJ,OACEP,EAAQ,MACL,MAAUC,EAAM,SAAS,YAAYA,EAAM,UAAUK,CACxD,KAAK;CAET;CAEA,IAAME,IAAK,CAAC,GAAGC,EAAW,QAAQ,CAAC,CAAC,CAAC,MAClC,GAAGb,OAAYA,MAAWW,CAC7B,CAAC,GAAG;CACJ,OAAOP,EAAQ,MAAM,MAAUC,EAAM,OAAOO,CAAE,KAAK;AACrD"}

package/dist/components/questionnaire/questionnaire.utils.d.ts

@@ -20,5 +20,21 @@ export declare function isTextInputEmpty(entry: {
 /** 是否为可输入文本的控件(用于决定方向键是否应当导航而非移动焦点) */
 export declare function isTypingElement(element: EventTarget | null): boolean;
 export declare function isNativeRadio(element: EventTarget | null): boolean;
-/** 按文档顺序比较两个元素 */
+/**
+ * 按文档顺序比较两个元素。
+ *
+ * **只在两个元素都连在文档里时**才比较：`QuestionnaireItem` 是在 ref 里注册的，
+ * 而 Solid 的 ref 在节点插入文档**之前**触发，此刻 fieldset 还是分离节点。
+ * 分离节点的 `compareDocumentPosition` 返回的是「实现相关」的 FOLLOWING/
+ * PRECEDING（jsdom 恒为 FOLLOWING），据此排序会把题目顺序整体颠倒。
+ * 这种情况返回 0（视为等价），由调用方回退到注册顺序。
+ */
 export declare function compareDocumentOrder(a: Element, b: Element): number;
+/**
+ * 答案是否处于禁用态：组件层标记（`disabled` prop）或原生控件自身禁用。
+ * 判定被"状态推导 / 焦点移动 / 校验"共用，因此集中在这里。
+ */
+export declare function isAnswerDisabled(entry: {
+    disabled: boolean;
+    element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+}): boolean;

package/dist/components/questionnaire/questionnaire.utils.js

@@ -28,11 +28,14 @@ function o(e) {
 	return e instanceof HTMLInputElement && e.type === "radio";
 }
 function s(e, t) {
-	if (e === t) return 0;
+	if (e === t || !e.isConnected || !t.isConnected) return 0;
 	let n = e.compareDocumentPosition(t);
 	return n & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : n & Node.DOCUMENT_POSITION_PRECEDING ? 1 : 0;
 }
+function c(e) {
+	return e.disabled || e.element.disabled;
+}
 //#endregion
-export { s as compareDocumentOrder, e as hasText, i as isAnswerFilled, o as isNativeRadio, a as isTypingElement, r as keyShortcutText, n as normalizeShortcut, t as shortcutAlphabet };
+export { s as compareDocumentOrder, e as hasText, c as isAnswerDisabled, i as isAnswerFilled, o as isNativeRadio, a as isTypingElement, r as keyShortcutText, n as normalizeShortcut, t as shortcutAlphabet };
 
 //# sourceMappingURL=questionnaire.utils.js.map

package/dist/components/questionnaire/questionnaire.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"questionnaire.utils.js","names":["hasText","value","item","shortcutAlphabet","mode","index","normalizeShortcut","normalized","key","keyShortcutText","shortcut","enterEnabled","isAnswerFilled","entry","isTypingElement","element","isNativeRadio","compareDocumentOrder","a","b","position"],"sources":["../../../src/components/questionnaire/questionnaire.utils.ts"],"sourcesContent":["import type { QuestionnaireShortcutMode } from \"./questionnaire.types\";\n\n/** 字符串/数组是否含有非空白内容(与上游 ce 一致) */\nexport function hasText(value: unknown): boolean {\n  if (Array.isArray(value)) {\n    return value.some((item) => String(item).trim().length > 0);\n  }\n  return value != null && String(value).trim().length > 0;\n}\n\n/** 按模式生成快捷键字母表:letters = A..Z,numbers = 1..9 */\nexport function shortcutAlphabet(\n  mode: QuestionnaireShortcutMode | null,\n): string[] {\n  if (mode === \"letters\") {\n    return Array.from({ length: 26 }, (_, index) =>\n      String.fromCharCode(65 + index),\n    );\n  }\n  if (mode === \"numbers\") {\n    return Array.from({ length: 9 }, (_, index) => String(index + 1));\n  }\n  return [];\n}\n\n/** 把按下的键规范成快捷键(字母大小写无关),不匹配返回 null */\nexport function normalizeShortcut(\n  key: string,\n  mode: QuestionnaireShortcutMode | null,\n): string | null {\n  const normalized = mode === \"letters\" ? key.toUpperCase() : key;\n  return shortcutAlphabet(mode).includes(normalized) ? normalized : null;\n}\n\n/** 拼 aria-keyshortcuts:有启用状态时额外附上 Enter */\nexport function keyShortcutText(\n  shortcut: string | null,\n  enterEnabled: boolean,\n): string | undefined {\n  return (\n    [shortcut, enterEnabled ? \"Enter\" : null].filter(Boolean).join(\" \") ||\n    undefined\n  );\n}\n\n/** 判断答案控件当前是否有值(choice 看 checked,input 看 name+value) */\nexport function isAnswerFilled(entry: {\n  type: \"choice\" | \"input\";\n  element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;\n}): boolean {\n  if (entry.type === \"choice\") {\n    return (entry.element as HTMLInputElement).checked;\n  }\n  return entry.element.hasAttribute(\"name\") && hasText(entry.element.value);\n}\n\n/** 文本类输入框为空(用于原生校验) */\nexport function isTextInputEmpty(entry: {\n  type: \"choice\" | \"input\";\n  element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;\n}): boolean {\n  return (\n    entry.type === \"input\" &&\n    [\"email\", \"password\", \"search\", \"tel\", \"text\", \"url\"].includes(\n      entry.element.type,\n    ) &&\n    !hasText(entry.element.value)\n  );\n}\n\n/** 是否为可输入文本的控件(用于决定方向键是否应当导航而非移动焦点) */\nexport function isTypingElement(element: EventTarget | null): boolean {\n  if (element instanceof HTMLTextAreaElement) return true;\n  if (element instanceof HTMLSelectElement) return true;\n  if (element instanceof HTMLInputElement) {\n    return ![\"button\", \"checkbox\", \"radio\", \"reset\", \"submit\"].includes(\n      element.type,\n    );\n  }\n  return element instanceof HTMLElement && element.isContentEditable;\n}\n\nexport function isNativeRadio(element: EventTarget | null): boolean {\n  return element instanceof HTMLInputElement && element.type === \"radio\";\n}\n\n/** 按文档顺序比较两个元素 */\nexport function compareDocumentOrder(a: Element, b: Element): number {\n  if (a === b) return 0;\n  const position = a.compareDocumentPosition(b);\n  if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;\n  if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;\n  return 0;\n}\n"],"mappings":";AAGA,SAAgBA,EAAQ,GAAyB;CAI/C,OAHI,MAAM,QAAQC,CAAK,IACdA,EAAM,MAAM,MAAS,OAAOC,CAAI,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAErDD,KAAS,QAAQ,OAAOA,CAAK,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS;AACxD;AAGA,SAAgBE,EACd,GACU;CASV,OARIC,MAAS,YACJ,MAAM,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,MACpC,OAAO,aAAa,KAAKC,CAAK,CAChC,IAEED,MAAS,YACJ,MAAM,KAAK,EAAE,QAAQ,EAAE,IAAI,GAAG,MAAU,OAAOC,IAAQ,CAAC,CAAC,IAE3D,CAAC;AACV;AAGA,SAAgBC,EACd,GACA,GACe;CACf,IAAMC,IAAaH,MAAS,YAAYI,EAAI,YAAY,IAAIA;CAC5D,OAAOL,EAAiBC,CAAI,CAAC,CAAC,SAASG,CAAU,IAAIA,IAAa;AACpE;AAGA,SAAgBE,EACd,GACA,GACoB;CACpB,OACE,CAACC,GAAUC,IAAe,UAAU,IAAI,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG,KAClE,KAAA;AAEJ;AAGA,SAAgBC,EAAe,GAGnB;CAIV,OAHIC,EAAM,SAAS,WACTA,EAAM,QAA6B,UAEtCA,EAAM,QAAQ,aAAa,MAAM,KAAKb,EAAQa,EAAM,QAAQ,KAAK;AAC1E;AAiBA,SAAgBC,EAAgB,GAAsC;CAQpE,OAPIC,aAAmB,uBACnBA,aAAmB,oBAA0B,KAC7CA,aAAmB,mBACd,CAAC;EAAC;EAAU;EAAY;EAAS;EAAS;CAAQ,CAAC,CAAC,SACzDA,EAAQ,IACV,IAEKA,aAAmB,eAAeA,EAAQ;AACnD;AAEA,SAAgBC,EAAc,GAAsC;CAClE,OAAOD,aAAmB,oBAAoBA,EAAQ,SAAS;AACjE;AAGA,SAAgBE,EAAqB,GAAY,GAAoB;CACnE,IAAIC,MAAMC,GAAG,OAAO;CACpB,IAAMC,IAAWF,EAAE,wBAAwBC,CAAC;CAG5C,OAFIC,IAAW,KAAK,8BAAoC,KACpDA,IAAW,KAAK,8BAAoC,IACjD;AACT"}
+{"version":3,"file":"questionnaire.utils.js","names":["hasText","value","item","shortcutAlphabet","mode","index","normalizeShortcut","normalized","key","keyShortcutText","shortcut","enterEnabled","isAnswerFilled","entry","isTypingElement","element","isNativeRadio","compareDocumentOrder","a","b","position","isAnswerDisabled"],"sources":["../../../src/components/questionnaire/questionnaire.utils.ts"],"sourcesContent":["import type { QuestionnaireShortcutMode } from \"./questionnaire.types\";\n\n/** 字符串/数组是否含有非空白内容(与上游 ce 一致) */\nexport function hasText(value: unknown): boolean {\n  if (Array.isArray(value)) {\n    return value.some((item) => String(item).trim().length > 0);\n  }\n  return value != null && String(value).trim().length > 0;\n}\n\n/** 按模式生成快捷键字母表:letters = A..Z,numbers = 1..9 */\nexport function shortcutAlphabet(\n  mode: QuestionnaireShortcutMode | null,\n): string[] {\n  if (mode === \"letters\") {\n    return Array.from({ length: 26 }, (_, index) =>\n      String.fromCharCode(65 + index),\n    );\n  }\n  if (mode === \"numbers\") {\n    return Array.from({ length: 9 }, (_, index) => String(index + 1));\n  }\n  return [];\n}\n\n/** 把按下的键规范成快捷键(字母大小写无关),不匹配返回 null */\nexport function normalizeShortcut(\n  key: string,\n  mode: QuestionnaireShortcutMode | null,\n): string | null {\n  const normalized = mode === \"letters\" ? key.toUpperCase() : key;\n  return shortcutAlphabet(mode).includes(normalized) ? normalized : null;\n}\n\n/** 拼 aria-keyshortcuts:有启用状态时额外附上 Enter */\nexport function keyShortcutText(\n  shortcut: string | null,\n  enterEnabled: boolean,\n): string | undefined {\n  return (\n    [shortcut, enterEnabled ? \"Enter\" : null].filter(Boolean).join(\" \") ||\n    undefined\n  );\n}\n\n/** 判断答案控件当前是否有值(choice 看 checked,input 看 name+value) */\nexport function isAnswerFilled(entry: {\n  type: \"choice\" | \"input\";\n  element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;\n}): boolean {\n  if (entry.type === \"choice\") {\n    return (entry.element as HTMLInputElement).checked;\n  }\n  return entry.element.hasAttribute(\"name\") && hasText(entry.element.value);\n}\n\n/** 文本类输入框为空(用于原生校验) */\nexport function isTextInputEmpty(entry: {\n  type: \"choice\" | \"input\";\n  element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;\n}): boolean {\n  return (\n    entry.type === \"input\" &&\n    [\"email\", \"password\", \"search\", \"tel\", \"text\", \"url\"].includes(\n      entry.element.type,\n    ) &&\n    !hasText(entry.element.value)\n  );\n}\n\n/** 是否为可输入文本的控件(用于决定方向键是否应当导航而非移动焦点) */\nexport function isTypingElement(element: EventTarget | null): boolean {\n  if (element instanceof HTMLTextAreaElement) return true;\n  if (element instanceof HTMLSelectElement) return true;\n  if (element instanceof HTMLInputElement) {\n    return ![\"button\", \"checkbox\", \"radio\", \"reset\", \"submit\"].includes(\n      element.type,\n    );\n  }\n  return element instanceof HTMLElement && element.isContentEditable;\n}\n\nexport function isNativeRadio(element: EventTarget | null): boolean {\n  return element instanceof HTMLInputElement && element.type === \"radio\";\n}\n\n/**\n * 按文档顺序比较两个元素。\n *\n * **只在两个元素都连在文档里时**才比较：`QuestionnaireItem` 是在 ref 里注册的，\n * 而 Solid 的 ref 在节点插入文档**之前**触发，此刻 fieldset 还是分离节点。\n * 分离节点的 `compareDocumentPosition` 返回的是「实现相关」的 FOLLOWING/\n * PRECEDING（jsdom 恒为 FOLLOWING），据此排序会把题目顺序整体颠倒。\n * 这种情况返回 0（视为等价），由调用方回退到注册顺序。\n */\nexport function compareDocumentOrder(a: Element, b: Element): number {\n  if (a === b) return 0;\n  if (!a.isConnected || !b.isConnected) return 0;\n  const position = a.compareDocumentPosition(b);\n  if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;\n  if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;\n  return 0;\n}\n\n/**\n * 答案是否处于禁用态：组件层标记（`disabled` prop）或原生控件自身禁用。\n * 判定被\"状态推导 / 焦点移动 / 校验\"共用，因此集中在这里。\n */\nexport function isAnswerDisabled(entry: {\n  disabled: boolean;\n  element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;\n}): boolean {\n  return entry.disabled || entry.element.disabled;\n}\n"],"mappings":";AAGA,SAAgBA,EAAQ,GAAyB;CAI/C,OAHI,MAAM,QAAQC,CAAK,IACdA,EAAM,MAAM,MAAS,OAAOC,CAAI,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAErDD,KAAS,QAAQ,OAAOA,CAAK,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS;AACxD;AAGA,SAAgBE,EACd,GACU;CASV,OARIC,MAAS,YACJ,MAAM,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,MACpC,OAAO,aAAa,KAAKC,CAAK,CAChC,IAEED,MAAS,YACJ,MAAM,KAAK,EAAE,QAAQ,EAAE,IAAI,GAAG,MAAU,OAAOC,IAAQ,CAAC,CAAC,IAE3D,CAAC;AACV;AAGA,SAAgBC,EACd,GACA,GACe;CACf,IAAMC,IAAaH,MAAS,YAAYI,EAAI,YAAY,IAAIA;CAC5D,OAAOL,EAAiBC,CAAI,CAAC,CAAC,SAASG,CAAU,IAAIA,IAAa;AACpE;AAGA,SAAgBE,EACd,GACA,GACoB;CACpB,OACE,CAACC,GAAUC,IAAe,UAAU,IAAI,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG,KAClE,KAAA;AAEJ;AAGA,SAAgBC,EAAe,GAGnB;CAIV,OAHIC,EAAM,SAAS,WACTA,EAAM,QAA6B,UAEtCA,EAAM,QAAQ,aAAa,MAAM,KAAKb,EAAQa,EAAM,QAAQ,KAAK;AAC1E;AAiBA,SAAgBC,EAAgB,GAAsC;CAQpE,OAPIC,aAAmB,uBACnBA,aAAmB,oBAA0B,KAC7CA,aAAmB,mBACd,CAAC;EAAC;EAAU;EAAY;EAAS;EAAS;CAAQ,CAAC,CAAC,SACzDA,EAAQ,IACV,IAEKA,aAAmB,eAAeA,EAAQ;AACnD;AAEA,SAAgBC,EAAc,GAAsC;CAClE,OAAOD,aAAmB,oBAAoBA,EAAQ,SAAS;AACjE;AAWA,SAAgBE,EAAqB,GAAY,GAAoB;CAEnE,IADIC,MAAMC,KACN,CAACD,EAAE,eAAe,CAACC,EAAE,aAAa,OAAO;CAC7C,IAAMC,IAAWF,EAAE,wBAAwBC,CAAC;CAG5C,OAFIC,IAAW,KAAK,8BAAoC,KACpDA,IAAW,KAAK,8BAAoC,IACjD;AACT;AAMA,SAAgBC,EAAiB,GAGrB;CACV,OAAOR,EAAM,YAAYA,EAAM,QAAQ;AACzC"}

package/dist/components/questionnaire/questionnaire.validation.d.ts

@@ -0,0 +1,43 @@
+import { QuestionnaireAnswerEntry } from './questionnaire.context';
+import { QuestionnaireItemStatus } from './questionnaire.types';
+/**
+ * 题目校验的判定。
+ *
+ * 单一职责：回答"这一题现在算不算无效""它是否满足要求""哪个原生控件先报错"。
+ * 全部是纯函数——焦点与 `reportValidity` 这类副作用留给调用方，
+ * 因此每条分支都能脱离 DOM 单独断言。
+ */
+/**
+ * 是否展示错误态：
+ * - 禁用的题目永远不报错；
+ * - 已跳过的题目不报错；
+ * - 显式传入的 `invalid` 优先（受控）；
+ * - 否则只在**用户交互过**之后才报错，且满足要求时不报错。
+ *
+ * 注：进入这里时 `skippable` 必为 false（上面的条件已排除），
+ * 表达式里的 `skippable` 是迁移前就有的冗余分支，保留以维持原语义。
+ */
+export declare function resolveItemInvalid(input: {
+    disabled: boolean;
+    invalid: boolean;
+    skippable: boolean;
+    touched: boolean;
+    answeredOk: boolean;
+}): boolean;
+/**
+ * 是否满足要求：
+ * - 禁用视为满足；
+ * - 已跳过且非必填视为满足；
+ * - 否则必须已作答且没有外部传入的 invalid。
+ */
+export declare function isItemSatisfied(input: {
+    disabled: boolean;
+    status: QuestionnaireItemStatus;
+    required: boolean;
+    invalid: boolean;
+}): boolean;
+/**
+ * 找出第一个"有值且原生校验不通过"的答案控件。
+ * 只有它参与原生报错——空控件交给自定义校验，避免必填项的浏览器气泡到处弹。
+ */
+export declare function findNativeInvalidAnswer(answers: readonly QuestionnaireAnswerEntry[]): QuestionnaireAnswerEntry | undefined;

package/dist/components/questionnaire/questionnaire.validation.js

@@ -0,0 +1,17 @@
+import { isAnswerFilled as e } from "./questionnaire.utils.js";
+//#region src/components/questionnaire/questionnaire.validation.ts
+function t(e) {
+	let { disabled: t, invalid: n, skippable: r, touched: i, answeredOk: a } = e;
+	return t || r ? !1 : n ? !0 : i && !(r || !n && a);
+}
+function n(e) {
+	let { disabled: t, status: n, required: r, invalid: i } = e;
+	return t || n === "skipped" && !r ? !0 : !i && n === "answered";
+}
+function r(t) {
+	return t.find((t) => e(t) && t.element.willValidate && !t.element.validity.valid);
+}
+//#endregion
+export { r as findNativeInvalidAnswer, n as isItemSatisfied, t as resolveItemInvalid };
+
+//# sourceMappingURL=questionnaire.validation.js.map

package/dist/components/questionnaire/questionnaire.validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.validation.js","names":["resolveItemInvalid","input","disabled","skippable","invalid","touched","answeredOk","isItemSatisfied","status","required","findNativeInvalidAnswer","answers","isAnswerFilled","entry"],"sources":["../../../src/components/questionnaire/questionnaire.validation.ts"],"sourcesContent":["import type { QuestionnaireAnswerEntry } from \"./questionnaire.context\";\nimport type { QuestionnaireItemStatus } from \"./questionnaire.types\";\nimport { isAnswerFilled } from \"./questionnaire.utils\";\n\n/**\n * 题目校验的判定。\n *\n * 单一职责：回答\"这一题现在算不算无效\"\"它是否满足要求\"\"哪个原生控件先报错\"。\n * 全部是纯函数——焦点与 `reportValidity` 这类副作用留给调用方，\n * 因此每条分支都能脱离 DOM 单独断言。\n */\n\n/**\n * 是否展示错误态：\n * - 禁用的题目永远不报错；\n * - 已跳过的题目不报错；\n * - 显式传入的 `invalid` 优先（受控）；\n * - 否则只在**用户交互过**之后才报错，且满足要求时不报错。\n *\n * 注：进入这里时 `skippable` 必为 false（上面的条件已排除），\n * 表达式里的 `skippable` 是迁移前就有的冗余分支，保留以维持原语义。\n */\nexport function resolveItemInvalid(input: {\n  disabled: boolean;\n  invalid: boolean;\n  skippable: boolean;\n  touched: boolean;\n  answeredOk: boolean;\n}): boolean {\n  const { disabled, invalid, skippable, touched, answeredOk } = input;\n  if (disabled || skippable) return false;\n  if (invalid) return true;\n  return touched && !(skippable || (!invalid && answeredOk));\n}\n\n/**\n * 是否满足要求：\n * - 禁用视为满足；\n * - 已跳过且非必填视为满足；\n * - 否则必须已作答且没有外部传入的 invalid。\n */\nexport function isItemSatisfied(input: {\n  disabled: boolean;\n  status: QuestionnaireItemStatus;\n  required: boolean;\n  invalid: boolean;\n}): boolean {\n  const { disabled, status, required, invalid } = input;\n  if (disabled) return true;\n  if (status === \"skipped\" && !required) return true;\n  return !invalid && status === \"answered\";\n}\n\n/**\n * 找出第一个\"有值且原生校验不通过\"的答案控件。\n * 只有它参与原生报错——空控件交给自定义校验，避免必填项的浏览器气泡到处弹。\n */\nexport function findNativeInvalidAnswer(\n  answers: readonly QuestionnaireAnswerEntry[],\n): QuestionnaireAnswerEntry | undefined {\n  return answers.find(\n    (entry) =>\n      isAnswerFilled(entry) &&\n      entry.element.willValidate &&\n      !entry.element.validity.valid,\n  );\n}\n"],"mappings":";;AAsBA,SAAgBA,EAAmB,GAMvB;CACV,IAAM,EAAE,aAAU,YAAS,cAAW,YAAS,kBAAeC;CAG9D,OAFIC,KAAYC,IAAkB,KAC9BC,IAAgB,KACbC,KAAW,EAAEF,KAAc,CAACC,KAAWE;AAChD;AAQA,SAAgBC,EAAgB,GAKpB;CACV,IAAM,EAAE,aAAU,WAAQ,aAAU,eAAYN;CAGhD,OAFIC,KACAM,MAAW,aAAa,CAACC,IAAiB,KACvC,CAACL,KAAWI,MAAW;AAChC;AAMA,SAAgBE,EACd,GACsC;CACtC,OAAOC,EAAQ,MACZ,MACCC,EAAeC,CAAK,KACpBA,EAAM,QAAQ,gBACd,CAACA,EAAM,QAAQ,SAAS,KAC5B;AACF"}

package/dist/components/questionnaire/useQuestionnaireItem.d.ts

@@ -1,13 +1,11 @@
 import { Accessor } from 'solid-js';
 import { QuestionnaireItemContextValue } from './questionnaire.context';
-import { QuestionnaireItemStatus } from './questionnaire.types';
 interface Options {
     name: string;
     required: Accessor<boolean>;
     multiple: Accessor<boolean>;
     disabled: Accessor<boolean>;
     invalid: Accessor<boolean>;
-    onStatusChange?: (status: QuestionnaireItemStatus) => void;
 }
 export interface QuestionnaireItemDomProps {
     "aria-describedby": string | undefined;