@chelone/vue 0.6.0 → 0.9.0

package/dist/components/admin/inputs/in-place-editor.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,182 @@
+import { useCheloneNotifications } from "../../../context.js";
+import { useUpdate } from "../../../data/mutations.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { provideRecordContext, useRecordContextRef } from "../../../record/record-context.js";
+import { useResourceContext } from "../../../resource-context.js";
+import text_field_default from "../fields/text-field.js";
+import { useMenuAccess } from "../layout/use-menu-access.js";
+import in_place_editor_form_default from "./in-place-editor-form.js";
+import text_input_default from "./text-input.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, defineComponent, normalizeClass, openBlock, renderSlot, shallowRef, unref, useSlots, withCtx, withModifiers } from "vue";
+import { nextInPlaceEditorState, planInPlaceSave } from "@chelone/core";
+// src/components/admin/inputs/in-place-editor.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 1,
+	"data-slot": "in-place-editor-saving",
+	"aria-busy": "true"
+};
+var _hoisted_2 = ["aria-label"];
+var in_place_editor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "in-place-editor",
+	props: {
+		source: { default: void 0 },
+		mutationMode: { default: void 0 },
+		meta: { default: void 0 },
+		cancelOnBlur: {
+			type: Boolean,
+			default: true
+		},
+		showButtons: {
+			type: Boolean,
+			default: false
+		},
+		notifyOnSuccess: {
+			type: Boolean,
+			default: false
+		},
+		resource: { default: void 0 },
+		class: { default: void 0 }
+	},
+	emits: ["success", "error"],
+	setup(__props, { emit: __emit }) {
+		/**
+		* `<InPlaceEditor>` — shows a record value and turns it into an input on
+		* click. The Vue twin of `@chelone/react`'s `inputs/in-place-editor.tsx`. The
+		* change goes out with `useUpdate`, and the new value shows, busy, until the
+		* update answers. The state steps and the save plan come from core
+		* (`nextInPlaceEditorState`, `planInPlaceSave`); the editing state is
+		* `in-place-editor-form.vue`, mounted only while editing.
+		*
+		* Needs a record, from `<Show>`, a `<DataTable>` row or a record context, and
+		* `edit` access to the resource: without it the value shows and cannot be
+		* clicked. A click or Enter on the value starts editing, `Enter` in the input
+		* saves, `Escape` cancels, and a focus move out of the editor cancels unless
+		* `cancelOnBlur` is false.
+		*
+		* The default slot replaces the shown value, `<TextField :source>` by default.
+		* The `#editor` slot replaces the input, `<TextInput :source :label="false"
+		* autofocus>` by default. Emits `success` with the saved record and `error`
+		* with the failure, in place of React's `onSuccess` and `onError`.
+		*
+		* @example
+		* <Show>
+		*   <InPlaceEditor source="title" />
+		* </Show>
+		*/
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		if (props.source === void 0 && (!slots.default || !slots.editor)) {
+			const missing = [
+				props.source === void 0 && "`source`",
+				!slots.default && "`default` slot",
+				!slots.editor && "`editor` slot"
+			].filter((name) => name !== false);
+			throw new Error(`<InPlaceEditor> needs a \`source\`, or both the default slot and the \`#editor\` slot: ${missing.join(", ")} missing`);
+		}
+		const record = useRecordContextRef();
+		const resource = useResourceContext({ resource: props.resource });
+		const translate = useTranslate();
+		const notifications = useCheloneNotifications();
+		const state = shallowRef({ status: "reading" });
+		const dispatch = (event) => {
+			state.value = nextInPlaceEditorState(state.value, event);
+		};
+		const { canAccess, isPending: isAccessPending } = useMenuAccess(computed(() => ({
+			action: "edit",
+			resource: resource ?? "",
+			record: record.value
+		})));
+		const mutationMode = props.mutationMode;
+		const { mutate } = useUpdate(resource ?? "", { mutationMode });
+		provideRecordContext(computed(() => {
+			const current = state.value;
+			if (current.status !== "saving") return record.value;
+			return current.preview;
+		}));
+		function save(before, dirty) {
+			if (state.value.status !== "editing") return;
+			const plan = planInPlaceSave(before, dirty);
+			if (!plan) {
+				dispatch({ type: "cancel" });
+				return;
+			}
+			dispatch({
+				type: "save",
+				preview: plan.preview
+			});
+			mutate({
+				id: plan.id,
+				data: plan.data,
+				previousData: plan.previousData,
+				meta: props.meta
+			}, {
+				onSuccess: (saved) => {
+					dispatch({ type: "settled" });
+					if (props.notifyOnSuccess && mutationMode !== "undoable") notifications?.notify("chelone.notification.updated", {
+						type: "info",
+						messageArgs: { smart_count: 1 }
+					});
+					emit("success", saved);
+				},
+				onError: (error) => {
+					dispatch({ type: "settled" });
+					if (mutationMode !== "undoable") notifications?.notify("chelone.notification.http_error", { type: "error" });
+					emit("error", error);
+				}
+			});
+		}
+		const readOnly = computed(() => !record.value || !resource || isAccessPending.value || !canAccess.value);
+		function onReadingKeydown(event) {
+			if (event.target !== event.currentTarget) return;
+			if (event.key !== "Enter" && event.key !== " ") return;
+			event.preventDefault();
+			event.stopPropagation();
+			dispatch({ type: "edit" });
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-slot": "in-place-editor",
+				class: normalizeClass(props.class)
+			}, [state.value.status === "editing" && unref(record) ? (openBlock(), createBlock(in_place_editor_form_default, {
+				key: 0,
+				record: unref(record),
+				"cancel-on-blur": __props.cancelOnBlur,
+				"show-buttons": __props.showButtons,
+				onSave: save,
+				onCancel: _cache[0] || (_cache[0] = ($event) => dispatch({ type: "cancel" }))
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "editor", {}, () => [__props.source !== void 0 ? (openBlock(), createBlock(text_input_default, {
+					key: 0,
+					source: __props.source,
+					label: false,
+					autofocus: ""
+				}, null, 8, ["source"])) : createCommentVNode("", true)])]),
+				_: 3
+			}, 8, [
+				"record",
+				"cancel-on-blur",
+				"show-buttons"
+			])) : state.value.status === "saving" ? (openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "default", {}, () => [__props.source !== void 0 ? (openBlock(), createBlock(text_field_default, {
+				key: 0,
+				source: __props.source
+			}, null, 8, ["source"])) : createCommentVNode("", true)])])) : readOnly.value ? renderSlot(_ctx.$slots, "default", {}, () => [__props.source !== void 0 ? (openBlock(), createBlock(text_field_default, {
+				key: 0,
+				source: __props.source
+			}, null, 8, ["source"])) : createCommentVNode("", true)], void 0, 2) : (openBlock(), createElementBlock("div", {
+				key: 3,
+				role: "button",
+				tabindex: "0",
+				"data-slot": "in-place-editor-reading",
+				class: "cursor-pointer",
+				"aria-label": unref(translate)("ra.action.edit", { _: "Edit" }),
+				onClick: _cache[1] || (_cache[1] = withModifiers(($event) => dispatch({ type: "edit" }), ["stop"])),
+				onKeydown: onReadingKeydown
+			}, [renderSlot(_ctx.$slots, "default", {}, () => [__props.source !== void 0 ? (openBlock(), createBlock(text_field_default, {
+				key: 0,
+				source: __props.source
+			}, null, 8, ["source"])) : createCommentVNode("", true)])], 40, _hoisted_2))], 2);
+		};
+	}
+});
+export { in_place_editor_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/label-text.js

@@ -1,7 +1,14 @@
+// src/components/admin/inputs/label-text.ts
+/**
+* `humanizeSource` — the minimal label fallback the V1 inputs/columns use when
+* no explicit `label` is given: turn a field source (`author_id`, `is_published`,
+* `author.name`) into a Title-Cased human string. A trimmed stand-in for
+* `@chelone/react`'s `<FieldLabelText>` + i18n `useTranslateLabel` chain (the
+* full resource-scoped translation lookup is a later wave); it keeps the vertical
+* readable without pulling the whole label i18n surface.
+*/
+/** `"author_id"` → `"Author"`, `"is_published"` → `"Is Published"`, `"a.b"` → `"B"`. */
 function humanizeSource(source) {
-  const last = source.split(".").pop() ?? source;
-  return last.replace(/_id$/, "").split(/[_\s]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+	return (source.split(".").pop() ?? source).replace(/_id$/, "").split(/[_\s]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
-export {
-  humanizeSource
-};
+export { humanizeSource };

package/dist/components/admin/inputs/loading-input.js

@@ -0,0 +1,4 @@
+import loading_input_vue_vue_type_script_setup_true_lang_default from "./loading-input.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/loading-input.vue
+var loading_input_default = loading_input_vue_vue_type_script_setup_true_lang_default;
+export { loading_input_default as default };

package/dist/components/admin/inputs/loading-input.vue.d.ts

@@ -8,8 +8,9 @@ export interface LoadingInputProps {
     fullWidth?: boolean;
     class?: string;
 }
-declare const _default: import("vue").DefineComponent<LoadingInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LoadingInputProps> & Readonly<{}>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<LoadingInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LoadingInputProps> & Readonly<{}>, {
     size: "default" | "sm";
     timeout: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/components/admin/inputs/loading-input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,63 @@
+import { cn } from "../../../lib/utils.js";
+import input_default from "../../ui/input.js";
+import spinner_default from "../feedback/spinner.js";
+import { useTimeout } from "../feedback/use-timeout.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, toDisplayString, unref, useId } from "vue";
+// src/components/admin/inputs/loading-input.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["for"];
+var _hoisted_2 = { class: "relative" };
+var _hoisted_3 = { class: "pointer-events-none absolute inset-y-0 right-3 flex w-5 items-center justify-center" };
+var _hoisted_4 = {
+	key: 1,
+	class: "text-xs text-muted-foreground"
+};
+var loading_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "loading-input",
+	props: {
+		label: {},
+		helperText: {},
+		timeout: { default: 1e3 },
+		size: { default: "default" },
+		fullWidth: { type: Boolean },
+		class: {}
+	},
+	setup(__props) {
+		/**
+		* `<LoadingInput>` — holds an input's place while its data loads: a disabled,
+		* read-only input with a label, the Vue twin of `@chelone/react`'s
+		* `inputs/loading-input.tsx`. A spinner appears inside the input's right edge
+		* once `timeout` ms have passed, so a fast load never flashes it.
+		*/
+		const props = __props;
+		const id = useId();
+		const showSpinner = useTimeout(props.timeout);
+		const classes = computed(() => cn("flex flex-col gap-1", props.fullWidth && "w-full", props.class));
+		const inputClasses = computed(() => cn("pr-10", props.size === "sm" && "h-8"));
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("fieldset", {
+				"data-slot": "loading-input",
+				class: normalizeClass(classes.value)
+			}, [
+				__props.label ? (openBlock(), createElementBlock("label", {
+					key: 0,
+					for: unref(id),
+					class: "text-sm font-medium"
+				}, toDisplayString(__props.label), 9, _hoisted_1)) : createCommentVNode("", true),
+				createElementVNode("div", _hoisted_2, [createVNode(input_default, {
+					id: unref(id),
+					"model-value": "",
+					disabled: "",
+					readonly: "",
+					"aria-busy": "true",
+					class: normalizeClass(inputClasses.value)
+				}, null, 8, ["id", "class"]), createElementVNode("span", _hoisted_3, [unref(showSpinner) ? (openBlock(), createBlock(spinner_default, {
+					key: 0,
+					size: "small",
+					class: "size-5"
+				})) : createCommentVNode("", true)])]),
+				__props.helperText ? (openBlock(), createElementBlock("p", _hoisted_4, toDisplayString(__props.helperText), 1)) : createCommentVNode("", true)
+			], 2);
+		};
+	}
+});
+export { loading_input_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/nullable-boolean-input.js

@@ -0,0 +1,4 @@
+import nullable_boolean_input_vue_vue_type_script_setup_true_lang_default from "./nullable-boolean-input.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/nullable-boolean-input.vue
+var nullable_boolean_input_default = nullable_boolean_input_vue_vue_type_script_setup_true_lang_default;
+export { nullable_boolean_input_default as default };

package/dist/components/admin/inputs/nullable-boolean-input.vue.d.ts

@@ -19,11 +19,16 @@ export interface NullableBooleanInputProps {
     trueLabel?: string;
     falseLabel?: string;
     validate?: Validator | readonly Validator[];
+    /** Read transform (`true`, `false` or `null` as stored → the select's `"true"`, `"false"` or `""`). */
+    format?: (value: boolean | null) => string;
+    /** Write transform (the select's `"true"`, `"false"` or `""` → stored value). */
+    parse?: (value: string) => boolean | null;
     disabled?: boolean;
     helperText?: string;
     class?: string;
 }
-declare const _default: import("vue").DefineComponent<NullableBooleanInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NullableBooleanInputProps> & Readonly<{}>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<NullableBooleanInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NullableBooleanInputProps> & Readonly<{}>, {
     label: string | false;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/components/admin/inputs/nullable-boolean-input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,117 @@
+import { useInput } from "../../../form/use-input.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { cn } from "../../../lib/utils.js";
+import { Field, FieldError, FieldLabel } from "../../ui/field.js";
+import native_select_default from "../../ui/native-select.js";
+import validation_error_default from "../common/validation-error.js";
+import { humanizeSource } from "./label-text.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createTextVNode, createVNode, defineComponent, normalizeClass, openBlock, toDisplayString, unref, withCtx } from "vue";
+import { toNullableBooleanValue } from "@chelone/core";
+// src/components/admin/inputs/nullable-boolean-input.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { key: 0 };
+var nullable_boolean_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "nullable-boolean-input",
+	props: {
+		source: {},
+		label: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		nullLabel: {},
+		trueLabel: {},
+		falseLabel: {},
+		validate: {},
+		format: {},
+		parse: {},
+		disabled: { type: Boolean },
+		helperText: {},
+		class: {}
+	},
+	setup(__props) {
+		/**
+		* `<NullableBooleanInput>` — a tri-state select for a `boolean | null` field,
+		* the Vue analog of `@chelone/react`'s `inputs/nullable-boolean-input.tsx`.
+		* Renders three options (default labels "", "No", "Yes") over the `q`-less
+		* `NativeSelect`. Binds via `useInput` with the twin's `format`/`parse`:
+		* `boolean → "true"|"false"|""` on read and back to `true|false|null` on write.
+		*
+		* Idiom note: Radix's Select (React) rejects `""` as an item value, so the twin
+		* routed `null` through a `"__null__"` sentinel. The Vue slice uses a NATIVE
+		* `<select>`, which accepts `""` directly — so the empty option IS the null
+		* value, no sentinel round-trip.
+		*/
+		const props = __props;
+		const getStringFromBoolean = (value) => {
+			if (value === true) return "true";
+			if (value === false) return "false";
+			return "";
+		};
+		const getBooleanFromString = (value) => {
+			if (value === "true") return true;
+			if (value === "false") return false;
+			return null;
+		};
+		const translate = useTranslate();
+		const { id, value, setValue, blur, error, touched, isRequired } = useInput({
+			source: props.source,
+			validate: props.validate
+		});
+		const selectValue = computed(() => (props.format ?? getStringFromBoolean)(toNullableBooleanValue(value.value)));
+		const invalid = computed(() => touched.value && error.value != null);
+		const labelText = computed(() => props.label === false || props.label === "" ? null : props.label ?? humanizeSource(props.source));
+		const options = computed(() => [
+			{
+				value: "",
+				label: props.nullLabel ? translate(props.nullLabel, { _: props.nullLabel }) : translate("ra.boolean.null", { _: "" })
+			},
+			{
+				value: "false",
+				label: props.falseLabel ? translate(props.falseLabel, { _: props.falseLabel }) : translate("ra.boolean.false", { _: "No" })
+			},
+			{
+				value: "true",
+				label: props.trueLabel ? translate(props.trueLabel, { _: props.trueLabel }) : translate("ra.boolean.true", { _: "Yes" })
+			}
+		]);
+		function onChange(next) {
+			setValue((props.parse ?? getBooleanFromString)(next));
+			blur();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Field), {
+				class: normalizeClass(unref(cn)("w-full min-w-20", props.class)),
+				"data-invalid": invalid.value
+			}, {
+				default: withCtx(() => [
+					labelText.value != null ? (openBlock(), createBlock(unref(FieldLabel), {
+						key: 0,
+						"html-for": unref(id)
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(labelText.value), 1), unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_1, " *")) : createCommentVNode("", true)]),
+						_: 1
+					}, 8, ["html-for"])) : createCommentVNode("", true),
+					createVNode(native_select_default, {
+						id: unref(id),
+						"model-value": selectValue.value,
+						options: options.value,
+						disabled: __props.disabled,
+						"aria-invalid": invalid.value,
+						"onUpdate:modelValue": onChange
+					}, null, 8, [
+						"id",
+						"model-value",
+						"options",
+						"disabled",
+						"aria-invalid"
+					]),
+					invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+						default: withCtx(() => [createVNode(validation_error_default, { error: unref(error) }, null, 8, ["error"])]),
+						_: 1
+					})) : createCommentVNode("", true)
+				]),
+				_: 1
+			}, 8, ["class", "data-invalid"]);
+		};
+	}
+});
+export { nullable_boolean_input_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/number-input.js

@@ -0,0 +1,4 @@
+import number_input_vue_vue_type_script_setup_true_lang_default from "./number-input.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/number-input.vue
+var number_input_default = number_input_vue_vue_type_script_setup_true_lang_default;
+export { number_input_default as default };

package/dist/components/admin/inputs/number-input.vue.d.ts

@@ -1,19 +1,34 @@
-/**
- * `<NumberInput>` — numeric input, the Vue analog of `@chelone/react`'s
- * `inputs/number-input.tsx`. Keeps a LOCAL string buffer so a user can type an
- * incomplete number (`-`, `0.`) before it is parsed, and writes `null` (not `0`)
- * on empty so required validation still triggers. Binds through `useInput`.
- */
-import type { SourceProp, Validator } from "@chelone/core";
+import type { LooseRecord, SourceProp } from "@chelone/core";
+import type { SourceInputProps } from "./source-input-props.js";
 /** Props for {@link NumberInput}. */
-export interface NumberInputProps {
-    source: SourceProp;
-    label?: string | false;
-    defaultValue?: unknown;
-    validate?: Validator | readonly Validator[];
+export interface NumberInputProps<RecordType = LooseRecord, TPath extends SourceProp<RecordType> = SourceProp<RecordType>> extends SourceInputProps<RecordType, TPath> {
+    /** Text the input shows for the stored number (`null` when empty). */
+    format?: (value: number | null) => string;
+    /** The number to store for the text the user typed (`null` when empty or unparseable). */
+    parse?: (value: string) => number | null;
+    /** Lowest value the native input accepts. */
+    min?: number;
+    /** Highest value the native input accepts. */
+    max?: number;
+    /** How far the native input's spinner steps. */
+    step?: number;
     class?: string;
 }
-declare const _default: import("vue").DefineComponent<NumberInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NumberInputProps> & Readonly<{}>, {
-    label: string | false;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: <RecordType = LooseRecord, TPath extends SourceProp<RecordType> = SourceProp<RecordType>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<NumberInputProps<RecordType, TPath>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/admin/inputs/number-input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,106 @@
+import { useInput } from "../../../form/use-input.js";
+import { Field, FieldError, FieldLabel } from "../../ui/field.js";
+import input_default from "../../ui/input.js";
+import validation_error_default from "../common/validation-error.js";
+import { humanizeSource } from "./label-text.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createTextVNode, createVNode, defineComponent, normalizeClass, openBlock, ref, toDisplayString, unref, watch, withCtx } from "vue";
+import { textOf, toNumberValue } from "@chelone/core";
+// src/components/admin/inputs/number-input.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { key: 0 };
+var number_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "number-input",
+	props: {
+		format: {},
+		parse: {},
+		min: {},
+		max: {},
+		step: {},
+		class: {},
+		source: {},
+		label: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		defaultValue: {},
+		validate: {}
+	},
+	setup(__props) {
+		/**
+		* `<NumberInput>` — numeric input, the Vue analog of `@chelone/react`'s
+		* `inputs/number-input.tsx`. Keeps a LOCAL string buffer so a user can type an
+		* incomplete number (`-`, `0.`) before it is parsed, and writes `null` (not `0`)
+		* on empty so required validation still triggers. Binds through `useInput`.
+		*/
+		const props = __props;
+		const defaultFormat = (value) => textOf(value);
+		/** Parse the raw string to a number, or `null` on empty/unparseable. */
+		const convertStringToNumber = (value) => {
+			if (value === "") return null;
+			const float = typeof value === "number" ? value : Number.parseFloat(value);
+			return Number.isNaN(float) ? null : float;
+		};
+		const { id, value, setValue, blur, error, touched, isRequired } = useInput({
+			source: props.source,
+			defaultValue: props.defaultValue,
+			validate: props.validate
+		});
+		const display = computed(() => (props.format ?? defaultFormat)(toNumberValue(value.value)));
+		const buffer = ref(display.value);
+		const focused = ref(false);
+		watch(display, (next) => {
+			if (!focused.value) buffer.value = next;
+		});
+		const invalid = computed(() => touched.value && error.value != null);
+		const labelText = computed(() => props.label === false ? null : props.label ?? humanizeSource(props.source));
+		function onInput(raw) {
+			buffer.value = raw;
+			setValue((props.parse ?? convertStringToNumber)(raw));
+		}
+		function onBlur() {
+			focused.value = false;
+			blur();
+			buffer.value = display.value;
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Field), {
+				class: normalizeClass(props.class),
+				"data-invalid": invalid.value
+			}, {
+				default: withCtx(() => [
+					labelText.value != null ? (openBlock(), createBlock(unref(FieldLabel), {
+						key: 0,
+						"html-for": unref(id)
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(labelText.value), 1), unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_1, " *")) : createCommentVNode("", true)]),
+						_: 1
+					}, 8, ["html-for"])) : createCommentVNode("", true),
+					createVNode(input_default, {
+						id: unref(id),
+						type: "number",
+						min: __props.min,
+						max: __props.max,
+						step: __props.step,
+						"model-value": buffer.value,
+						"aria-invalid": invalid.value,
+						onFocus: _cache[0] || (_cache[0] = ($event) => focused.value = true),
+						"onUpdate:modelValue": onInput,
+						onBlur
+					}, null, 8, [
+						"id",
+						"min",
+						"max",
+						"step",
+						"model-value",
+						"aria-invalid"
+					]),
+					invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+						default: withCtx(() => [createVNode(validation_error_default, { error: unref(error) }, null, 8, ["error"])]),
+						_: 1
+					})) : createCommentVNode("", true)
+				]),
+				_: 1
+			}, 8, ["class", "data-invalid"]);
+		};
+	}
+});
+export { number_input_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/password-input.js

@@ -0,0 +1,4 @@
+import password_input_vue_vue_type_script_setup_true_lang_default from "./password-input.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/password-input.vue
+var password_input_default = password_input_vue_vue_type_script_setup_true_lang_default;
+export { password_input_default as default };

package/dist/components/admin/inputs/password-input.vue.d.ts

@@ -13,7 +13,7 @@ export interface PasswordInputProps {
     source: SourceProp;
     label?: string | false;
     initiallyVisible?: boolean;
-    defaultValue?: unknown;
+    defaultValue?: string;
     validate?: Validator | readonly Validator[];
     helperText?: string;
     placeholder?: string;
@@ -24,7 +24,8 @@ export interface PasswordInputProps {
     inputClass?: string;
     class?: string;
 }
-declare const _default: import("vue").DefineComponent<PasswordInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PasswordInputProps> & Readonly<{}>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<PasswordInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PasswordInputProps> & Readonly<{}>, {
     label: string | false;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;