@neut/ui 0.0.16 → 0.0.18

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

@@ -0,0 +1,65 @@
+import { Accessor } from 'solid-js';
+import { QuestionnaireItemDefinition, QuestionnaireItemStatus, QuestionnaireRootState, QuestionnaireShortcutMode } from './questionnaire.types';
+export interface QuestionnaireAnswerEntry {
+    id: string;
+    element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+    type: "choice" | "input";
+    value?: string;
+    disabled: boolean;
+    ownDisabled?: boolean;
+}
+export interface QuestionnaireItemHandle {
+    name: string;
+    element: HTMLElement;
+    disabled: Accessor<boolean>;
+    required: Accessor<boolean>;
+    status: Accessor<QuestionnaireItemStatus>;
+    validate: () => boolean;
+    focus: () => void;
+    focusInvalid: () => void;
+    skip: () => void;
+    reset: () => void;
+    getAnswerByElement: (element: Element) => QuestionnaireAnswerEntry | null;
+    getAnswerByShortcut: (shortcut: string) => QuestionnaireAnswerEntry | null;
+    moveAnswerFocus: (target: Element, direction: "next" | "previous") => boolean;
+}
+export interface QuestionnaireRootContextValue {
+    state: Accessor<QuestionnaireRootState>;
+    activeItemName: Accessor<string | null>;
+    activeItemRequired: Accessor<boolean | null>;
+    activeItemStatus: Accessor<QuestionnaireItemStatus | null>;
+    shortcuts: Accessor<QuestionnaireShortcutMode | null>;
+    nativeValidation: Accessor<boolean>;
+    itemDefinitions: Accessor<Map<string, QuestionnaireItemDefinition> | null>;
+    registerItem: (item: QuestionnaireItemHandle) => () => void;
+    goNext: () => void;
+    goPrevious: () => void;
+    skipCurrent: () => void;
+    requestSubmit: () => void;
+}
+export interface QuestionnaireItemContextValue {
+    name: string;
+    active: Accessor<boolean>;
+    disabled: Accessor<boolean>;
+    invalid: Accessor<boolean>;
+    multiple: Accessor<boolean>;
+    required: Accessor<boolean>;
+    status: Accessor<QuestionnaireItemStatus>;
+    hasInputAnswer: Accessor<boolean>;
+    selectedAnswerIds: Accessor<string[]>;
+    resetVersion: Accessor<number>;
+    shortcutByAnswerId: Accessor<Map<string, string>>;
+    shortcutByChoiceValue: Accessor<Map<string, string> | null>;
+    shortcuts: Accessor<QuestionnaireShortcutMode | null>;
+    registerAnswerControl: (entry: QuestionnaireAnswerEntry) => () => void;
+    registerAnswerSelection: (id: string, initialSelected: boolean) => () => void;
+    registerDescription: (id: string) => () => void;
+    registerError: (id: string) => () => void;
+    setAnswerDefault: (id: string, selected: boolean) => void;
+    setAnswerSelectionFromInteraction: (id: string, selected: boolean) => void;
+    syncControlledAnswerSelection: (id: string, selected: boolean) => void;
+}
+export declare const QuestionnaireRootContext: import('solid-js').Context<QuestionnaireRootContextValue | undefined>;
+export declare function useQuestionnaireRootContext(component: string): QuestionnaireRootContextValue;
+export declare const QuestionnaireItemContext: import('solid-js').Context<QuestionnaireItemContextValue | undefined>;
+export declare function useQuestionnaireItemContext(component: string): QuestionnaireItemContextValue;

package/dist/components/questionnaire/questionnaire.context.js

@@ -0,0 +1,18 @@
+import { createContext as e, useContext as t } from "solid-js";
+//#region src/components/questionnaire/questionnaire.context.ts
+var n = e();
+function r(e) {
+	let r = t(n);
+	if (!r) throw Error(`<${e}> 必须渲染在 <Questionnaire> 内部`);
+	return r;
+}
+var i = e();
+function a(e) {
+	let n = t(i);
+	if (!n) throw Error(`<${e}> 必须渲染在 <QuestionnaireItem> 内部`);
+	return n;
+}
+//#endregion
+export { i as QuestionnaireItemContext, n as QuestionnaireRootContext, a as useQuestionnaireItemContext, r as useQuestionnaireRootContext };
+
+//# sourceMappingURL=questionnaire.context.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.context.js","names":["QuestionnaireRootContext","createContext","useQuestionnaireRootContext","ctx","useContext","component","QuestionnaireItemContext","useQuestionnaireItemContext"],"sources":["../../../src/components/questionnaire/questionnaire.context.ts"],"sourcesContent":["import { createContext, useContext, type Accessor } from \"solid-js\";\nimport type {\n  QuestionnaireItemDefinition,\n  QuestionnaireItemStatus,\n  QuestionnaireRootState,\n  QuestionnaireShortcutMode,\n} from \"./questionnaire.types\";\n\nexport interface QuestionnaireAnswerEntry {\n  id: string;\n  element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;\n  type: \"choice\" | \"input\";\n  value?: string;\n  disabled: boolean;\n  ownDisabled?: boolean;\n}\n\nexport interface QuestionnaireItemHandle {\n  name: string;\n  element: HTMLElement;\n  disabled: Accessor<boolean>;\n  required: Accessor<boolean>;\n  status: Accessor<QuestionnaireItemStatus>;\n  validate: () => boolean;\n  focus: () => void;\n  focusInvalid: () => void;\n  skip: () => void;\n  reset: () => void;\n  getAnswerByElement: (element: Element) => QuestionnaireAnswerEntry | null;\n  getAnswerByShortcut: (shortcut: string) => QuestionnaireAnswerEntry | null;\n  moveAnswerFocus: (target: Element, direction: \"next\" | \"previous\") => boolean;\n}\n\nexport interface QuestionnaireRootContextValue {\n  state: Accessor<QuestionnaireRootState>;\n  activeItemName: Accessor<string | null>;\n  activeItemRequired: Accessor<boolean | null>;\n  activeItemStatus: Accessor<QuestionnaireItemStatus | null>;\n  shortcuts: Accessor<QuestionnaireShortcutMode | null>;\n  nativeValidation: Accessor<boolean>;\n  itemDefinitions: Accessor<Map<string, QuestionnaireItemDefinition> | null>;\n  registerItem: (item: QuestionnaireItemHandle) => () => void;\n  goNext: () => void;\n  goPrevious: () => void;\n  skipCurrent: () => void;\n  requestSubmit: () => void;\n}\n\nexport interface QuestionnaireItemContextValue {\n  name: string;\n  active: Accessor<boolean>;\n  disabled: Accessor<boolean>;\n  invalid: Accessor<boolean>;\n  multiple: Accessor<boolean>;\n  required: Accessor<boolean>;\n  status: Accessor<QuestionnaireItemStatus>;\n  hasInputAnswer: Accessor<boolean>;\n  selectedAnswerIds: Accessor<string[]>;\n  resetVersion: Accessor<number>;\n  shortcutByAnswerId: Accessor<Map<string, string>>;\n  shortcutByChoiceValue: Accessor<Map<string, string> | null>;\n  shortcuts: Accessor<QuestionnaireShortcutMode | null>;\n  registerAnswerControl: (entry: QuestionnaireAnswerEntry) => () => void;\n  registerAnswerSelection: (id: string, initialSelected: boolean) => () => void;\n  registerDescription: (id: string) => () => void;\n  registerError: (id: string) => () => void;\n  setAnswerDefault: (id: string, selected: boolean) => void;\n  setAnswerSelectionFromInteraction: (id: string, selected: boolean) => void;\n  syncControlledAnswerSelection: (id: string, selected: boolean) => void;\n}\n\nexport const QuestionnaireRootContext =\n  createContext<QuestionnaireRootContextValue>();\n\nexport function useQuestionnaireRootContext(\n  component: string,\n): QuestionnaireRootContextValue {\n  const ctx = useContext(QuestionnaireRootContext);\n  if (!ctx) {\n    throw new Error(`<${component}> 必须渲染在 <Questionnaire> 内部`);\n  }\n  return ctx;\n}\n\nexport const QuestionnaireItemContext =\n  createContext<QuestionnaireItemContextValue>();\n\nexport function useQuestionnaireItemContext(\n  component: string,\n): QuestionnaireItemContextValue {\n  const ctx = useContext(QuestionnaireItemContext);\n  if (!ctx) {\n    throw new Error(`<${component}> 必须渲染在 <QuestionnaireItem> 内部`);\n  }\n  return ctx;\n}\n"],"mappings":";;AAuEA,IAAaA,IACXC,EAA6C;AAE/C,SAAgBC,EACd,GAC+B;CAC/B,IAAMC,IAAMC,EAAWJ,CAAwB;CAC/C,IAAI,CAACG,GACH,MAAU,MAAM,IAAIE,EAAU,2BAA2B;CAE3D,OAAOF;AACT;AAEA,IAAaG,IACXL,EAA6C;AAE/C,SAAgBM,EACd,GAC+B;CAC/B,IAAMJ,IAAMC,EAAWE,CAAwB;CAC/C,IAAI,CAACH,GACH,MAAU,MAAM,IAAIE,EAAU,+BAA+B;CAE/D,OAAOF;AACT"}

package/dist/components/questionnaire/questionnaire.dom-watch.d.ts

@@ -0,0 +1,9 @@
+import { Accessor } from 'solid-js';
+/**
+ * 监视表单子树里的 DOM 增删，返回一个"每次变化都会自增"的版本号。
+ *
+ * 单一职责：把结构变化变成一条可被 memo 依赖的响应式边——注册表本身是普通数组，
+ * 子节点被移动位置时注册顺序不变，只有 DOM 顺序变了，排序 memo 需要这条边才会重算。
+ * 环境不支持 `MutationObserver`（SSR）时不做任何事，版本号恒为 0。
+ */
+export declare function createDomVersionWatcher(root: Accessor<Element | undefined>): Accessor<number>;

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

@@ -0,0 +1,18 @@
+import { createEffect as e, createSignal as t, onCleanup as n } from "solid-js";
+//#region src/components/questionnaire/questionnaire.dom-watch.ts
+function r(r) {
+	let [i, a] = t(0);
+	return e(() => {
+		let e = r();
+		if (!e || typeof MutationObserver > "u") return;
+		let t = new MutationObserver(() => a((e) => e + 1));
+		t.observe(e, {
+			childList: !0,
+			subtree: !0
+		}), a((e) => e + 1), n(() => t.disconnect());
+	}), i;
+}
+//#endregion
+export { r as createDomVersionWatcher };
+
+//# sourceMappingURL=questionnaire.dom-watch.js.map

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.types.d.ts

@@ -0,0 +1,82 @@
+import { JSX, ParentProps, ValidComponent } from 'solid-js';
+import { ButtonProps } from '../button';
+import { BaseProps, PolymorphicProps } from '../../types';
+export type QuestionnaireItemStatus = "unanswered" | "answered" | "skipped";
+export type QuestionnaireShortcutMode = "letters" | "numbers";
+export interface QuestionnaireChoiceDefinition {
+    disabled?: boolean;
+    value: string;
+}
+export interface QuestionnaireItemDefinition {
+    choices?: readonly QuestionnaireChoiceDefinition[];
+    disabled?: boolean;
+    name: string;
+    required?: boolean;
+}
+export interface QuestionnaireRootState {
+    current: number;
+    first: boolean;
+    last: boolean;
+    total: number;
+}
+interface BaseQuestionnaireProps extends BaseProps, ParentProps {
+    /** 初始激活项 */
+    defaultItem?: string;
+    /** 受控激活项;不传则由内部导航 */
+    item?: string;
+    /** 题目定义:提供后用于按定义顺序分配快捷键、校验名/required 一致性 */
+    items?: readonly QuestionnaireItemDefinition[];
+    onItemChange?: (item: string) => void;
+    /** 答案快捷键模式 */
+    shortcuts?: QuestionnaireShortcutMode;
+    /** 默认 true,关闭浏览器原生校验并走组件校验 */
+    noValidate?: boolean;
+    onReset?: (event: Event) => void;
+    onSubmit?: (event: SubmitEvent) => void;
+}
+export type QuestionnaireProps = PolymorphicProps<"form", BaseQuestionnaireProps, false>;
+export type QuestionnaireProgressProps = PolymorphicProps<"div", BaseProps & {
+    children?: JSX.Element | ((state: QuestionnaireRootState) => JSX.Element);
+}, false>;
+export type QuestionnaireItemProps = PolymorphicProps<"fieldset", BaseProps & {
+    name: string;
+    required?: boolean;
+    multiple?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    onStatusChange?: (status: QuestionnaireItemStatus) => void;
+    "aria-labelledby"?: string;
+}, false>;
+export type QuestionnaireTitleProps<T extends ValidComponent = "legend"> = PolymorphicProps<T, BaseProps & {
+    id?: string;
+    children?: JSX.Element;
+}>;
+export type QuestionnaireDescriptionProps<T extends ValidComponent = "p"> = PolymorphicProps<T, BaseProps & {
+    id?: string;
+    children?: JSX.Element;
+}>;
+export type QuestionnaireChoicesProps = PolymorphicProps<"div", BaseProps, false>;
+export type QuestionnaireChoiceProps = PolymorphicProps<"label", BaseProps & {
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    onChange?: (event: Event) => void;
+}, false>;
+export type QuestionnaireInputType = "date" | "datetime-local" | "email" | "month" | "number" | "password" | "search" | "tel" | "text" | "time" | "url" | "week";
+export type QuestionnaireInputProps = PolymorphicProps<"input", BaseProps & {
+    type?: QuestionnaireInputType;
+    defaultValue?: string;
+    value?: string;
+    disabled?: boolean;
+    onChange?: (event: Event) => void;
+}, false>;
+export type QuestionnaireErrorProps<T extends ValidComponent = "p"> = PolymorphicProps<T, BaseProps & {
+    id?: string;
+    children?: JSX.Element;
+}>;
+export type QuestionnaireNavigationProps = PolymorphicProps<"button", BaseProps & {
+    variant?: ButtonProps<"button">["variant"];
+    size?: ButtonProps<"button">["size"];
+}, false>;
+export {};

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

@@ -0,0 +1,40 @@
+import { QuestionnaireShortcutMode } from './questionnaire.types';
+/** 字符串/数组是否含有非空白内容(与上游 ce 一致) */
+export declare function hasText(value: unknown): boolean;
+/** 按模式生成快捷键字母表:letters = A..Z,numbers = 1..9 */
+export declare function shortcutAlphabet(mode: QuestionnaireShortcutMode | null): string[];
+/** 把按下的键规范成快捷键(字母大小写无关),不匹配返回 null */
+export declare function normalizeShortcut(key: string, mode: QuestionnaireShortcutMode | null): string | null;
+/** 拼 aria-keyshortcuts:有启用状态时额外附上 Enter */
+export declare function keyShortcutText(shortcut: string | null, enterEnabled: boolean): string | undefined;
+/** 判断答案控件当前是否有值(choice 看 checked,input 看 name+value) */
+export declare function isAnswerFilled(entry: {
+    type: "choice" | "input";
+    element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+}): boolean;
+/** 文本类输入框为空(用于原生校验) */
+export declare function isTextInputEmpty(entry: {
+    type: "choice" | "input";
+    element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+}): boolean;
+/** 是否为可输入文本的控件(用于决定方向键是否应当导航而非移动焦点) */
+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;