@linxin666/dsh-pet 0.1.1 → 0.1.2

package/lib/state-DMgOYVFT.js

@@ -0,0 +1,198 @@
+//#region src/affinity.ts
+const AFFINITY_MAX = 100;
+/** Affinity ranks by points; the pet visibly grows with its rank. */
+const AFFINITY_RANKS = [
+	{
+		min: 0,
+		name: "幼鲸",
+		emoji: "🐣"
+	},
+	{
+		min: 25,
+		name: "伙伴",
+		emoji: "🐬"
+	},
+	{
+		min: 50,
+		name: "挚友",
+		emoji: "🐳"
+	},
+	{
+		min: 80,
+		name: "深海羁绊",
+		emoji: "💙"
+	}
+];
+const defaultAffinityConfig = {
+	turnReward: 1,
+	petReward: 1,
+	petCooldownMs: 1e4,
+	feedReward: 5,
+	feedCooldownMs: 3e4
+};
+function emptyAffinity() {
+	return {
+		points: 0,
+		lastPetAt: 0,
+		lastFeedAt: 0,
+		pets: 0,
+		feeds: 0,
+		turns: 0
+	};
+}
+/** Rank for a point total. */
+function rankOf(points) {
+	let rank = AFFINITY_RANKS[0];
+	for (const candidate of AFFINITY_RANKS) if (points >= candidate.min) rank = candidate;
+	return rank;
+}
+function clamp(points) {
+	return Math.min(100, Math.max(0, points));
+}
+/**
+* Apply one interaction to a copy of the state (immutable style: returns a
+* new object; the caller replaces the persisted state). Cooldowns only
+* apply once the pet has been interacted with at least once (last*At === 0
+* means "never", so the first pet/feed always lands).
+*/
+function applyInteraction(state, kind, nowMs, config = defaultAffinityConfig) {
+	const next = { ...state };
+	if (kind === "pet") {
+		if (state.lastPetAt !== 0 && nowMs - state.lastPetAt < config.petCooldownMs) return {
+			affinity: state,
+			delta: 0,
+			reaction: "摸过头啦，让鲸鱼娘歇口气～",
+			accepted: false
+		};
+		next.lastPetAt = nowMs;
+		next.pets += 1;
+		next.points = clamp(state.points + config.petReward);
+		return {
+			affinity: next,
+			delta: config.petReward,
+			reaction: "咕噜咕噜～被摸摸好舒服！",
+			accepted: true
+		};
+	}
+	if (kind === "feed") {
+		if (state.lastFeedAt !== 0 && nowMs - state.lastFeedAt < config.feedCooldownMs) return {
+			affinity: state,
+			delta: 0,
+			reaction: "吃饱啦，晚点再喂～",
+			accepted: false
+		};
+		next.lastFeedAt = nowMs;
+		next.feeds += 1;
+		next.points = clamp(state.points + config.feedReward);
+		return {
+			affinity: next,
+			delta: config.feedReward,
+			reaction: "呜哇！小鱼干好好吃！",
+			accepted: true
+		};
+	}
+	return {
+		affinity: state,
+		delta: 0,
+		reaction: "",
+		accepted: false
+	};
+}
+/** Reward one completed turn (called by the host on `done`). */
+function applyTurnReward(state, config = defaultAffinityConfig) {
+	const next = { ...state };
+	next.turns += 1;
+	next.points = clamp(state.points + config.turnReward);
+	return next;
+}
+//#endregion
+//#region src/state.ts
+const defaultPetStateConfig = { celebrateMs: 2400 };
+/**
+* Map one activity phase onto the animation contract.
+* - thinking / tool → `running` (focused work), with `running-right` as the
+*   side-alternating variant the client may use for tool activity.
+* - waiting → `waiting` (expectant pose, needs user input).
+* - done → `jumping` (celebration), then back to `idle` after the window.
+* - idle → `idle` (calm breathing loop).
+* `failed` has no DSH phase source yet; the machine keeps the mapping table
+* so a future error event can light it up.
+*/
+function animationForPhase(phase) {
+	switch (phase) {
+		case "thinking": return "running";
+		case "tool": return "running-right";
+		case "waiting": return "waiting";
+		case "done": return "jumping";
+		case "idle": return "idle";
+	}
+}
+/** The spritesheet row index for one animation track. */
+function rowOf(animation) {
+	return {
+		"idle": 0,
+		"running-right": 1,
+		"running-left": 2,
+		"waving": 3,
+		"jumping": 4,
+		"failed": 5,
+		"waiting": 6,
+		"running": 7,
+		"review": 8
+	}[animation];
+}
+/**
+* PetStateMachine — one instance per host process. Holds only the latest
+* input snapshot and the celebration timing; no storage, no side effects.
+*/
+var PetStateMachine = class {
+	config;
+	now;
+	phase = "idle";
+	line;
+	phrase;
+	sessionActive = false;
+	doneAt;
+	constructor(config = defaultPetStateConfig, now = Date.now) {
+		this.config = config;
+		this.now = now;
+	}
+	/** Consume one `activity/status` session event. */
+	onActivityStatus(input) {
+		this.phase = input.phase;
+		this.line = input.line;
+		this.phrase = input.phrase;
+		if (input.phase === "done") this.doneAt = this.now();
+	}
+	/** A session became the active one (or a fresh session started). */
+	onSessionActive() {
+		this.sessionActive = true;
+	}
+	/** The active session was disposed (or none left). */
+	onSessionDisposed() {
+		this.sessionActive = false;
+		this.phase = "idle";
+		this.line = void 0;
+		this.phrase = void 0;
+		this.doneAt = void 0;
+	}
+	/** Render the current animation decision. */
+	render() {
+		const nowMs = this.now();
+		let animation = animationForPhase(this.phase);
+		if (this.phase === "done" && this.doneAt !== void 0) {
+			if (nowMs - this.doneAt < this.config.celebrateMs) animation = "jumping";
+			else animation = "idle";
+		}
+		const bubble = this.phrase ?? this.line;
+		return {
+			animation,
+			...bubble === void 0 ? {} : { bubble },
+			animationStartedAt: nowMs,
+			phase: this.phase,
+			sessionActive: this.sessionActive
+		};
+	}
+};
+//#endregion
+export { AFFINITY_MAX as a, applyTurnReward as c, rankOf as d, rowOf as i, defaultAffinityConfig as l, animationForPhase as n, AFFINITY_RANKS as o, defaultPetStateConfig as r, applyInteraction as s, PetStateMachine as t, emptyAffinity as u };

package/lib/state-IyVnKymD.js

@@ -0,0 +1,198 @@
+//#region src/affinity.ts
+const AFFINITY_MAX = 100;
+/** Affinity ranks by points; the pet visibly grows with its rank.
+*  Marker glyphs are plain ASCII (the repo bans all emoji characters);
+*  they read as a growing star trail alongside the rank name. */
+const AFFINITY_RANKS = [
+	{
+		min: 0,
+		name: "幼鲸",
+		emoji: "*"
+	},
+	{
+		min: 25,
+		name: "伙伴",
+		emoji: "**"
+	},
+	{
+		min: 50,
+		name: "挚友",
+		emoji: "***"
+	},
+	{
+		min: 80,
+		name: "深海羁绊",
+		emoji: "****"
+	}
+];
+const defaultAffinityConfig = {
+	turnReward: 1,
+	petReward: 1,
+	petCooldownMs: 1e4,
+	feedReward: 5,
+	feedCooldownMs: 3e4
+};
+function emptyAffinity() {
+	return {
+		points: 0,
+		lastPetAt: 0,
+		lastFeedAt: 0,
+		pets: 0,
+		feeds: 0,
+		turns: 0
+	};
+}
+/** Rank for a point total. */
+function rankOf(points) {
+	let rank = AFFINITY_RANKS[0];
+	for (const candidate of AFFINITY_RANKS) if (points >= candidate.min) rank = candidate;
+	return rank;
+}
+function clamp(points) {
+	return Math.min(100, Math.max(0, points));
+}
+/**
+* Apply one interaction to a copy of the state (immutable style: returns a
+* new object; the caller replaces the persisted state). Cooldowns only
+* apply once the pet has been interacted with at least once (last*At === 0
+* means "never", so the first pet/feed always lands).
+*/
+function applyInteraction(state, kind, nowMs, config = defaultAffinityConfig) {
+	const next = { ...state };
+	if (kind === "pet") {
+		if (state.lastPetAt !== 0 && nowMs - state.lastPetAt < config.petCooldownMs) return {
+			affinity: state,
+			delta: 0,
+			reaction: "摸过头啦，让鲸鱼娘歇口气～",
+			accepted: false
+		};
+		next.lastPetAt = nowMs;
+		next.pets += 1;
+		next.points = clamp(state.points + config.petReward);
+		return {
+			affinity: next,
+			delta: config.petReward,
+			reaction: "咕噜咕噜～被摸摸好舒服！",
+			accepted: true
+		};
+	}
+	if (kind === "feed") {
+		if (state.lastFeedAt !== 0 && nowMs - state.lastFeedAt < config.feedCooldownMs) return {
+			affinity: state,
+			delta: 0,
+			reaction: "吃饱啦，晚点再喂～",
+			accepted: false
+		};
+		next.lastFeedAt = nowMs;
+		next.feeds += 1;
+		next.points = clamp(state.points + config.feedReward);
+		return {
+			affinity: next,
+			delta: config.feedReward,
+			reaction: "呜哇！小鱼干好好吃！",
+			accepted: true
+		};
+	}
+	return {
+		affinity: state,
+		delta: 0,
+		reaction: "",
+		accepted: false
+	};
+}
+/** Reward one completed turn (called by the host on `done`). */
+function applyTurnReward(state, config = defaultAffinityConfig) {
+	const next = { ...state };
+	next.turns += 1;
+	next.points = clamp(state.points + config.turnReward);
+	return next;
+}
+//#endregion
+//#region src/state.ts
+const defaultPetStateConfig = { celebrateMs: 2400 };
+/**
+* Map one activity phase onto the animation contract.
+* - thinking / tool → `running` (focused work), with `running-right` as the
+*   side-alternating variant the client may use for tool activity.
+* - waiting → `waiting` (expectant pose, needs user input).
+* - done → `jumping` (celebration), then back to `idle` after the window.
+* - idle → `idle` (calm breathing loop).
+* `failed` has no DSH phase source yet; the machine keeps the mapping table
+* so a future error event can light it up.
+*/
+function animationForPhase(phase) {
+	switch (phase) {
+		case "thinking": return "running";
+		case "tool": return "running-right";
+		case "waiting": return "waiting";
+		case "done": return "jumping";
+		case "idle": return "idle";
+	}
+}
+/** The spritesheet row index for one animation track. */
+function rowOf(animation) {
+	return {
+		"idle": 0,
+		"running-right": 1,
+		"running-left": 2,
+		"waving": 3,
+		"jumping": 4,
+		"failed": 5,
+		"waiting": 6,
+		"running": 7,
+		"review": 8
+	}[animation];
+}
+/**
+* PetStateMachine — one instance per host process. Holds only the latest
+* input snapshot and the celebration timing; no storage, no side effects.
+*/
+var PetStateMachine = class {
+	config;
+	now;
+	phase = "idle";
+	line;
+	phrase;
+	sessionActive = false;
+	doneAt;
+	constructor(config = defaultPetStateConfig, now = Date.now) {
+		this.config = config;
+		this.now = now;
+	}
+	/** Consume one `activity/status` session event. */
+	onActivityStatus(input) {
+		this.phase = input.phase;
+		this.line = input.line;
+		this.phrase = input.phrase;
+		if (input.phase === "done") this.doneAt = this.now();
+	}
+	/** A session became the active one (or a fresh session started). */
+	onSessionActive() {
+		this.sessionActive = true;
+	}
+	/** The active session was disposed (or none left). */
+	onSessionDisposed() {
+		this.sessionActive = false;
+		this.phase = "idle";
+		this.line = void 0;
+		this.phrase = void 0;
+		this.doneAt = void 0;
+	}
+	/** Render the current animation decision. */
+	render() {
+		const nowMs = this.now();
+		let animation = animationForPhase(this.phase);
+		if (this.phase === "done" && this.doneAt !== void 0) if (nowMs - this.doneAt < this.config.celebrateMs) animation = "jumping";
+		else animation = "idle";
+		const bubble = this.phrase ?? this.line;
+		return {
+			animation,
+			...bubble === void 0 ? {} : { bubble },
+			animationStartedAt: nowMs,
+			phase: this.phase,
+			sessionActive: this.sessionActive
+		};
+	}
+};
+//#endregion
+export { AFFINITY_MAX as a, applyTurnReward as c, rankOf as d, rowOf as i, defaultAffinityConfig as l, animationForPhase as n, AFFINITY_RANKS as o, defaultPetStateConfig as r, applyInteraction as s, PetStateMachine as t, emptyAffinity as u };

package/lib/types/affinity.js

@@ -0,0 +1,84 @@
+/**
+ * Affinity score — pure, clock-injected. The pet grows closer the more you
+ * work together and care for it: every completed turn earns a small reward,
+ * petting earns a tiny one (cooldown-gated), feeding earns the most.
+ * Persistence lives in the service; this module only computes transitions.
+ * @module @linxin666/dsh-pet/affinity
+ */
+export const AFFINITY_MAX = 100;
+/** Affinity ranks by points; the pet visibly grows with its rank.
+ *  Marker glyphs are plain ASCII (the repo bans all emoji characters);
+ *  they read as a growing star trail alongside the rank name. */
+export const AFFINITY_RANKS = [
+    { min: 0, name: '幼鲸', emoji: '*' },
+    { min: 25, name: '伙伴', emoji: '**' },
+    { min: 50, name: '挚友', emoji: '***' },
+    { min: 80, name: '深海羁绊', emoji: '****' },
+];
+export const defaultAffinityConfig = {
+    turnReward: 1,
+    petReward: 1,
+    petCooldownMs: 10_000,
+    feedReward: 5,
+    feedCooldownMs: 30_000,
+};
+export function emptyAffinity() {
+    return { points: 0, lastPetAt: 0, lastFeedAt: 0, pets: 0, feeds: 0, turns: 0 };
+}
+/** Rank for a point total. */
+export function rankOf(points) {
+    let rank = AFFINITY_RANKS[0];
+    for (const candidate of AFFINITY_RANKS) {
+        if (points >= candidate.min)
+            rank = candidate;
+    }
+    return rank;
+}
+function clamp(points) {
+    return Math.min(AFFINITY_MAX, Math.max(0, points));
+}
+/**
+ * Apply one interaction to a copy of the state (immutable style: returns a
+ * new object; the caller replaces the persisted state). Cooldowns only
+ * apply once the pet has been interacted with at least once (last*At === 0
+ * means "never", so the first pet/feed always lands).
+ */
+export function applyInteraction(state, kind, nowMs, config = defaultAffinityConfig) {
+    const next = { ...state };
+    if (kind === 'pet') {
+        if (state.lastPetAt !== 0 && nowMs - state.lastPetAt < config.petCooldownMs) {
+            return { affinity: state, delta: 0, reaction: '摸过头啦，让鲸鱼娘歇口气～', accepted: false };
+        }
+        next.lastPetAt = nowMs;
+        next.pets += 1;
+        next.points = clamp(state.points + config.petReward);
+        return {
+            affinity: next,
+            delta: config.petReward,
+            reaction: '咕噜咕噜～被摸摸好舒服！',
+            accepted: true,
+        };
+    }
+    if (kind === 'feed') {
+        if (state.lastFeedAt !== 0 && nowMs - state.lastFeedAt < config.feedCooldownMs) {
+            return { affinity: state, delta: 0, reaction: '吃饱啦，晚点再喂～', accepted: false };
+        }
+        next.lastFeedAt = nowMs;
+        next.feeds += 1;
+        next.points = clamp(state.points + config.feedReward);
+        return {
+            affinity: next,
+            delta: config.feedReward,
+            reaction: '呜哇！小鱼干好好吃！',
+            accepted: true,
+        };
+    }
+    return { affinity: state, delta: 0, reaction: '', accepted: false };
+}
+/** Reward one completed turn (called by the host on `done`). */
+export function applyTurnReward(state, config = defaultAffinityConfig) {
+    const next = { ...state };
+    next.turns += 1;
+    next.points = clamp(state.points + config.turnReward);
+    return next;
+}

package/lib/types/client/PetDockEntry.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Dock anchor inside `conversation.input.selector.context`: the input
+ * selector row mounts in EVERY conversation phase (no-session cold start,
+ * the blank-session hero, and the active seat), so the floating pet stays on
+ * screen on the new-conversation screen too. While visible it mounts the
+ * floating WhalePet (portal); while hidden it renders the summon button.
+ * @module @linxin666/dsh-pet/client/PetDockEntry
+ */
+import { useEffect, useSyncExternalStore } from 'react';
+import { WhalePet } from "./WhalePet.js";
+import styles from './pet.module.css';
+const DEFAULT_DISPLAY = { visible: true, size: 160, right: 24, bottom: 20 };
+/**
+ * Dock entry: while the pet is visible, mount the floating WhalePet (it
+ * portals itself onto document.body); while hidden, render the summon
+ * button so the pet can always come back. The store is the plugin-owned
+ * single instance — the slot system provides none because the pet is
+ * host-global, not session-scoped.
+ */
+export function PetDockEntry(props) {
+    const { store, ensure } = props;
+    const ui = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    const snapshot = ui.snapshot;
+    const feedback = ui.feedback;
+    const visible = snapshot?.display.visible ?? true;
+    useEffect(() => {
+        ensure();
+    }, [ensure]);
+    if (visible) {
+        return (_jsx("span", { "data-pet-dock": true, "data-testid": "pet-dock", children: _jsx(WhalePet, { snapshot: snapshot, display: snapshot?.display ?? DEFAULT_DISPLAY, feedback: feedback, onPet: props.pet, onFeed: props.feed, onHide: props.hide, onDragEnd: props.dragEnd, onRename: props.rename, onFeedbackDone: props.feedbackDone, t: props.t }) }));
+    }
+    return (_jsx("button", { type: "button", className: styles.summon, onClick: props.summon, "data-testid": "pet-summon", children: props.t('pet.summon', { name: snapshot?.name ?? '鲸鱼娘' }) }));
+}

package/lib/types/client/PetSettingsCard.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PluginSettingsCard, ValueField, BooleanField } from "./PluginSettingsCard.js";
+import { CardForm, booleanField, numberField, textField } from "./settings-form.js";
+/** Bridges the `pet` scope onto the card's staged form. */
+export class PetSettingsCardController {
+    form;
+    store;
+    /** @param scope - the bound settings scope for the `pet` namespace. */
+    constructor(scope) {
+        this.form = new CardForm(scope, [
+            booleanField('enabled'),
+            booleanField('visible'),
+            numberField('size'),
+            numberField('right'),
+            numberField('bottom'),
+            textField('name'),
+        ]);
+        this.store = this.form.bind(() => this.projection());
+    }
+    projection() {
+        return {
+            ...this.form.shell(),
+            enabled: this.form.field('enabled'),
+            visible: this.form.field('visible'),
+            size: this.form.field('size'),
+            right: this.form.field('right'),
+            bottom: this.form.field('bottom'),
+            name: this.form.field('name'),
+        };
+    }
+    /**
+     * Build the face the card's slot registration injects.
+     * @returns the card's snapshot and its form actions.
+     */
+    inject() {
+        return { hooks: { petSettingsCard: this.store }, ...this.form.actions() };
+    }
+}
+/**
+ * Render the pet settings card.
+ * @param props - locale copy, the card snapshot, and its form actions.
+ * @returns the card.
+ */
+export function PetSettingsCard(props) {
+    const { t } = props;
+    const state = props.usePetSettingsCard(snapshot => snapshot);
+    const disabled = !state.writable;
+    const fieldProps = {
+        overriddenLabel: t('settings.overridden'),
+        resetLabel: t('settings.reset'),
+        invalidLabel: t('settings.invalidNumber'),
+        disabled,
+    };
+    return (_jsxs(PluginSettingsCard, { t: t, titleKey: "settings.title", descriptionKey: "settings.description", state: state, onSave: props.save, onDiscard: props.discard, children: [_jsx(BooleanField, { id: "settings-pet-enabled", label: t('settings.enabled'), hint: t('settings.enabledHint'), inheritLabel: t('settings.inherit'), onLabel: t('settings.on'), offLabel: t('settings.off'), ...fieldProps, ...state.enabled, onEdit: (text) => { props.edit('enabled', text); }, onReset: () => { props.resetField('enabled'); } }), _jsx(BooleanField, { id: "settings-pet-visible", label: t('settings.visible'), hint: t('settings.visibleHint'), inheritLabel: t('settings.inherit'), onLabel: t('settings.on'), offLabel: t('settings.off'), ...fieldProps, ...state.visible, onEdit: (text) => { props.edit('visible', text); }, onReset: () => { props.resetField('visible'); } }), _jsx(ValueField, { id: "settings-pet-size", label: t('settings.size'), hint: t('settings.sizeHint'), numeric: true, ...fieldProps, ...state.size, onEdit: (text) => { props.edit('size', text); }, onReset: () => { props.resetField('size'); } }), _jsx(ValueField, { id: "settings-pet-right", label: t('settings.right'), hint: t('settings.rightHint'), numeric: true, ...fieldProps, ...state.right, onEdit: (text) => { props.edit('right', text); }, onReset: () => { props.resetField('right'); } }), _jsx(ValueField, { id: "settings-pet-bottom", label: t('settings.bottom'), hint: t('settings.bottomHint'), numeric: true, ...fieldProps, ...state.bottom, onEdit: (text) => { props.edit('bottom', text); }, onReset: () => { props.resetField('bottom'); } }), _jsx(ValueField, { id: "settings-pet-name", label: t('settings.name'), hint: t('settings.nameHint'), ...fieldProps, ...state.name, onEdit: (text) => { props.edit('name', text); }, onReset: () => { props.resetField('name'); } })] }));
+}

package/lib/types/client/PluginSettingsCard.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Shared chrome for the plugin settings card: a disclosure header naming the
+ * plugin and what its settings govern, the controls inside, and the save that
+ * writes them. Renders nothing while the namespace is unavailable — a
+ * deployment that does not compose the owning plugin should show no trace of
+ * it. Mirrors the official ui-plugin-config PluginCard in a self-contained
+ * slice (this package must not depend on a sibling UI package).
+ */
+import { useState } from 'react';
+import css from './settings-card.module.css';
+/**
+ * Render one plugin settings card.
+ * @param props - the plugin's copy keys, its form state, and its controls.
+ * @returns the card, or nothing when the namespace is unavailable.
+ */
+export function PluginSettingsCard(props) {
+    const [open, setOpen] = useState(false);
+    const { state } = props;
+    if (!state.available)
+        return null;
+    const title = props.t(props.titleKey);
+    const blocked = !state.dirty || state.invalid || state.saving;
+    return (_jsxs("li", { className: css.card, children: [_jsxs("button", { type: "button", className: css.header, "aria-expanded": open, "aria-label": `${props.t(open ? 'settings.collapse' : 'settings.expand')}: ${title}`, onClick: () => { setOpen(!open); }, children: [_jsxs("span", { className: css.headText, children: [_jsx("span", { className: css.name, children: title }), _jsx("span", { className: css.description, children: props.t(props.descriptionKey) })] }), state.dirty ? _jsx("span", { className: css.pending, children: props.t('settings.unsaved') }) : null, _jsx("span", { className: open ? css.chevronOpen : css.chevron, children: "\u25BE" })] }), open
+                ? (_jsxs("div", { className: css.body, children: [!state.writable ? _jsx("p", { className: css.readOnly, role: "status", children: props.t('settings.readOnly') }) : null, props.children, _jsxs("div", { className: css.footer, children: [state.failed ? _jsx("p", { className: css.failed, role: "status", children: props.t('settings.saveFailed') }) : null, _jsx("button", { type: "button", className: css.discard, disabled: !state.dirty || state.saving, onClick: props.onDiscard, children: props.t('settings.discard') }), _jsx("button", { type: "button", className: css.save, disabled: blocked, onClick: props.onSave, children: props.t(!state.saving ? 'settings.save' : 'settings.saving') })] })] }))
+                : null] }));
+}
+/** A staged value field. `numeric` only hints the keypad: which drafts a field accepts is decided by its spec. */
+export function ValueField(props) {
+    return (_jsxs("div", { className: css.field, children: [_jsxs("div", { className: css.head, children: [_jsx("label", { className: css.label, htmlFor: props.id, children: props.label }), props.overridden
+                        ? (_jsxs("span", { className: css.badges, children: [_jsx("span", { className: css.badge, children: props.overriddenLabel }), _jsx("button", { type: "button", className: css.reset, disabled: props.disabled, onClick: props.onReset, children: props.resetLabel })] }))
+                        : null] }), _jsx("input", { id: props.id, className: props.invalid ? css.inputInvalid : css.input, type: "text", ...props.numeric === true ? { inputMode: 'numeric' } : {}, ...props.invalid ? { 'aria-invalid': true } : {}, value: props.text, placeholder: props.placeholder ?? '', disabled: props.disabled, onChange: (event) => { props.onEdit(event.target.value); } }), _jsx("p", { className: props.invalid ? css.invalid : css.hint, children: props.invalid ? props.invalidLabel : props.hint })] }));
+}
+/** A staged boolean field: 继承 / 开 / 关. */
+export function BooleanField(props) {
+    return (_jsxs("div", { className: css.field, children: [_jsxs("div", { className: css.head, children: [_jsx("label", { className: css.label, htmlFor: props.id, children: props.label }), props.overridden
+                        ? (_jsxs("span", { className: css.badges, children: [_jsx("span", { className: css.badge, children: props.overriddenLabel }), _jsx("button", { type: "button", className: css.reset, disabled: props.disabled, onClick: props.onReset, children: props.resetLabel })] }))
+                        : null] }), _jsxs("select", { id: props.id, className: css.select, value: props.text, disabled: props.disabled, onChange: (event) => { props.onEdit(event.target.value); }, children: [_jsx("option", { value: "", children: props.inheritLabel }), _jsx("option", { value: "true", children: props.onLabel }), _jsx("option", { value: "false", children: props.offLabel })] }), _jsx("p", { className: css.hint, children: props.hint })] }));
+}