@chelone/vue 0.6.0 → 0.9.0

package/dist/components/admin/inputs/reference-array-input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,64 @@
+import { provideChoicesContext } from "../../../choices/choices-context.js";
+import { useReferenceInput } from "../../../choices/use-reference-input.js";
+import { useCheloneFormContext, useWrappedSource } from "../../../form/form-context.js";
+import { subscribeStore, useSubscribable } from "../../../form/subscribe-ref.js";
+import { provideResourceContext } from "../../../resource-context.js";
+import autocomplete_array_input_default from "./autocomplete-array-input.js";
+import { createVNode, defineComponent, renderSlot, watch } from "vue";
+// src/components/admin/inputs/reference-array-input.vue?vue&type=script&setup=true&lang.ts
+var reference_array_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "reference-array-input",
+	props: {
+		source: {},
+		reference: {},
+		lookupKey: {},
+		filter: {},
+		sort: {},
+		page: {},
+		perPage: {},
+		debounceMs: {}
+	},
+	setup(__props) {
+		/**
+		* `<ReferenceArrayInput>` — edits a to-many foreign-key relationship with
+		* autocompletion, the Vue analog of `@chelone/react`'s
+		* `inputs/reference-array-input.tsx`. It fetches records from a reference
+		* resource via {@link useReferenceInput} (the shared 4R choices controller) and
+		* provides them — plus the reference resource context — to a child multi-select
+		* input (default `<AutocompleteArrayInput>`, overridable via the default slot,
+		* e.g. `<DatagridInput>`).
+		*
+		* The child consumes the choices via the ambient {@link provideChoicesContext}
+		* and writes an id ARRAY back to the form (its own `useInput`); server-side
+		* filtering flows through the context's `setFilters`. This wrapper syncs the
+		* current FK-array value INTO the controller (`setValue`) so it resolves the
+		* SELECTED records — the Vue analog of the React twin's `useWatch` + `useEffect`,
+		* here a `useSubscribable` over `form.ambient.store` driving a `watch`.
+		*/
+		const props = __props;
+		provideResourceContext(props.reference);
+		const choicesContext = useReferenceInput({
+			reference: props.reference,
+			source: props.source,
+			lookupKey: props.lookupKey,
+			filter: props.filter,
+			sort: props.sort,
+			page: props.page,
+			perPage: props.perPage,
+			debounceMs: props.debounceMs
+		});
+		provideChoicesContext(choicesContext);
+		const { form } = useCheloneFormContext();
+		const source = useWrappedSource(props.source);
+		const { store } = form.ambient;
+		const fieldValue = useSubscribable({
+			getSnapshot: () => form.ambient.getFieldValue(source),
+			subscribe: (listener) => subscribeStore(store, listener)
+		});
+		watch(fieldValue, (value) => choicesContext.setValue(value ?? []), { immediate: true });
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {}, () => [createVNode(autocomplete_array_input_default)]);
+		};
+	}
+});
+export { reference_array_input_vue_vue_type_script_setup_true_lang_default as default };

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

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

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

@@ -7,7 +7,7 @@
  * native `<select>` (the reka-ui combobox autocomplete is a later wave — spec
  * Risk 1). Choice labels use the reference's record representation.
  */
-import type { SourceProp, Validator } from "@chelone/core";
+import { type SourceProp, type Validator } from "@chelone/core";
 /** Props for {@link ReferenceInput}. */
 export interface ReferenceInputProps {
     source: SourceProp;
@@ -17,7 +17,8 @@ export interface ReferenceInputProps {
     validate?: Validator | readonly Validator[];
     class?: string;
 }
-declare const _default: import("vue").DefineComponent<ReferenceInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ReferenceInputProps> & Readonly<{}>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<ReferenceInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ReferenceInputProps> & Readonly<{}>, {
     label: string | false;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

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

@@ -0,0 +1,92 @@
+import { useGetList } from "../../../data/queries.js";
+import { useInput } from "../../../form/use-input.js";
+import { useGetRecordRepresentation } from "../../../label/use-get-record-representation.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 { DEFAULT_REFERENCE_PER_PAGE } from "@chelone/core";
+// src/components/admin/inputs/reference-input.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { key: 0 };
+var reference_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "reference-input",
+	props: {
+		source: {},
+		reference: {},
+		label: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		perPage: {},
+		validate: {},
+		class: {}
+	},
+	setup(__props) {
+		/**
+		* `<ReferenceInput>` — edits a to-one foreign key, the Vue analog of
+		* `@chelone/react`'s `inputs/reference-input.tsx`. The React twin drives a full
+		* `useReferenceInput` choices controller + `<AutocompleteInput>`; the V1 Vue
+		* slice ports the ONE reference path minimally: fetch the reference resource's
+		* choices with `useGetList` (vue-query) and bind the FK via `useInput` over a
+		* native `<select>` (the reka-ui combobox autocomplete is a later wave — spec
+		* Risk 1). Choice labels use the reference's record representation.
+		*/
+		const props = __props;
+		const { id, value, setValue, error, touched, isRequired } = useInput({
+			source: props.source,
+			validate: props.validate
+		});
+		const query = useGetList(props.reference, () => ({ pagination: {
+			page: 1,
+			perPage: props.perPage ?? DEFAULT_REFERENCE_PER_PAGE
+		} }));
+		const getRepresentation = useGetRecordRepresentation(props.reference);
+		const choices = computed(() => {
+			return (query.data.value?.data ?? []).map((record) => ({
+				value: record.id,
+				label: getRepresentation(record)
+			}));
+		});
+		const invalid = computed(() => touched.value && error.value != null);
+		const labelText = computed(() => props.label === false ? null : props.label ?? humanizeSource(props.source));
+		function onSelect(raw) {
+			const match = choices.value.find((choice) => String(choice.value) === raw);
+			setValue(match ? match.value : raw);
+		}
+		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(native_select_default, {
+						id: unref(id),
+						"model-value": unref(value),
+						options: choices.value,
+						"aria-invalid": invalid.value,
+						"onUpdate:modelValue": onSelect
+					}, null, 8, [
+						"id",
+						"model-value",
+						"options",
+						"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 { reference_input_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/resettable-text-input.js

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

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

@@ -1,15 +1,17 @@
 /**
  * `<ResettableTextInput>` — a text input with a clear (×) button that resets the
  * field value, the Vue analog of `@chelone/react`'s
- * `inputs/resettable-text-input.tsx`. Wraps `<TextInput>` and hangs a ghost
- * button off the right edge; it appears only when the field has a value (unless
- * `clearAlwaysVisible`). Clicking it writes `""` (an empty string, not `null` —
- * consistent with the coercion fix) so the control stays a controlled string.
+ * `inputs/resettable-text-input.tsx`. Wraps `<TextInput>` and overlays a ghost
+ * button on the control through its `controlSuffix` slot, so the button is centred
+ * on the control with or without a label, helper text or an error. It appears only
+ * when the field has a value (unless `clearAlwaysVisible`). Clicking it writes `""`
+ * (an empty string, not `null` — consistent with the coercion fix) so the control
+ * stays a controlled string.
  *
  * Rebridge note: the React twin read the live value via the `useWatch` RHF shim
- * and cleared via `form.setFieldValue`. Here we OBSERVE the ambient form store
- * (a read-only `useSubscribable` over `form.store` — no second field
- * registration) and clear via the same `form.setFieldValue(wrappedSource, "")`.
+ * and cleared via `form.ambient.setFieldValue`. Here we OBSERVE the ambient form store
+ * (a read-only `useSubscribable` over `form.ambient.store` — no second field
+ * registration) and clear via the same `form.ambient.setFieldValue(wrappedSource, "")`.
  */
 import type { Validator } from "@chelone/core";
 import type { SourceProp } from "@chelone/core";
@@ -19,7 +21,7 @@ export interface ResettableTextInputProps {
     label?: string | false;
     resettable?: boolean;
     clearAlwaysVisible?: boolean;
-    defaultValue?: unknown;
+    defaultValue?: string;
     validate?: Validator | readonly Validator[];
     helperText?: string;
     placeholder?: string;
@@ -28,9 +30,10 @@ export interface ResettableTextInputProps {
     inputClass?: string;
     class?: string;
 }
-declare const _default: import("vue").DefineComponent<ResettableTextInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResettableTextInputProps> & Readonly<{}>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<ResettableTextInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResettableTextInputProps> & Readonly<{}>, {
     label: string | false;
     resettable: boolean;
     clearAlwaysVisible: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/components/admin/inputs/resettable-text-input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,127 @@
+import { useCheloneFormContext, useWrappedSource } from "../../../form/form-context.js";
+import { subscribeStore, useSubscribable } from "../../../form/subscribe-ref.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { cn } from "../../../lib/utils.js";
+import button_default from "../../ui/button.js";
+import text_input_default from "./text-input.js";
+import { computed, createBlock, createElementVNode, createSlots, createVNode, defineComponent, normalizeClass, openBlock, unref, withCtx } from "vue";
+// src/components/admin/inputs/resettable-text-input.vue?vue&type=script&setup=true&lang.ts
+var resettable_text_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "resettable-text-input",
+	props: {
+		source: {},
+		label: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		resettable: {
+			type: Boolean,
+			default: true
+		},
+		clearAlwaysVisible: {
+			type: Boolean,
+			default: false
+		},
+		defaultValue: {},
+		validate: {},
+		helperText: {},
+		placeholder: {},
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		inputClass: {},
+		class: {}
+	},
+	setup(__props) {
+		/**
+		* `<ResettableTextInput>` — a text input with a clear (×) button that resets the
+		* field value, the Vue analog of `@chelone/react`'s
+		* `inputs/resettable-text-input.tsx`. Wraps `<TextInput>` and overlays a ghost
+		* button on the control through its `controlSuffix` slot, so the button is centred
+		* on the control with or without a label, helper text or an error. It appears only
+		* when the field has a value (unless `clearAlwaysVisible`). Clicking it writes `""`
+		* (an empty string, not `null` — consistent with the coercion fix) so the control
+		* stays a controlled string.
+		*
+		* Rebridge note: the React twin read the live value via the `useWatch` RHF shim
+		* and cleared via `form.ambient.setFieldValue`. Here we OBSERVE the ambient form store
+		* (a read-only `useSubscribable` over `form.ambient.store` — no second field
+		* registration) and clear via the same `form.ambient.setFieldValue(wrappedSource, "")`.
+		*/
+		const props = __props;
+		const translate = useTranslate();
+		const { form } = useCheloneFormContext();
+		const wrappedSource = useWrappedSource(props.source);
+		const formState = useSubscribable({
+			getSnapshot: () => form.ambient.store.state,
+			subscribe: (cb) => subscribeStore(form.ambient.store, cb)
+		});
+		const hasValue = computed(() => {
+			formState.value;
+			const v = form.ambient.getFieldValue(wrappedSource);
+			return v != null && v !== "";
+		});
+		const showClearButton = computed(() => props.resettable && (props.clearAlwaysVisible || hasValue.value));
+		const clearLabel = computed(() => translate("ra.action.clear_input_value", { _: "Clear value" }));
+		function handleClear() {
+			form.ambient.setFieldValue(wrappedSource, "");
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(text_input_default, {
+				source: __props.source,
+				label: __props.label,
+				"default-value": __props.defaultValue,
+				validate: __props.validate,
+				"helper-text": __props.helperText,
+				placeholder: __props.placeholder,
+				disabled: __props.disabled,
+				readonly: __props.readonly,
+				class: normalizeClass(props.class),
+				"input-class": unref(cn)(__props.resettable ? "pr-9" : void 0, __props.inputClass)
+			}, createSlots({ _: 2 }, [showClearButton.value ? {
+				name: "controlSuffix",
+				fn: withCtx(() => [createVNode(button_default, {
+					"data-slot": "reset",
+					type: "button",
+					variant: "ghost",
+					size: "icon",
+					class: "absolute right-1 top-1/2 size-7 -translate-y-1/2 text-muted-foreground",
+					disabled: __props.disabled || __props.readonly || !hasValue.value,
+					"aria-label": clearLabel.value,
+					title: clearLabel.value,
+					tabindex: -1,
+					onClick: handleClear
+				}, {
+					default: withCtx(() => [..._cache[0] || (_cache[0] = [createElementVNode("svg", {
+						xmlns: "http://www.w3.org/2000/svg",
+						class: "size-4",
+						viewBox: "0 0 24 24",
+						fill: "none",
+						stroke: "currentColor",
+						"stroke-width": "2",
+						"stroke-linecap": "round",
+						"stroke-linejoin": "round",
+						"aria-hidden": "true"
+					}, [createElementVNode("path", { d: "M18 6 6 18" }), createElementVNode("path", { d: "m6 6 12 12" })], -1)])]),
+					_: 1
+				}, 8, [
+					"disabled",
+					"aria-label",
+					"title"
+				])]),
+				key: "0"
+			} : void 0]), 1032, [
+				"source",
+				"label",
+				"default-value",
+				"validate",
+				"helper-text",
+				"placeholder",
+				"disabled",
+				"readonly",
+				"class",
+				"input-class"
+			]);
+		};
+	}
+});
+export { resettable_text_input_vue_vue_type_script_setup_true_lang_default as default };

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

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

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

@@ -2,7 +2,7 @@
  * `<SearchInput>` — an unlabelled text input with a search icon, the Vue analog
  * of `@chelone/react`'s `inputs/search-input.tsx`. Designed for filter bars, it
  * defaults to the `q` full-text source. Reads the live value off the ambient
- * form store and clears via `form.setFieldValue`. It throws if given a `label`
+ * form store and clears via `form.ambient.setFieldValue`. It throws if given a `label`
  * (use `<TextInput>` when a label is needed) — mirroring the React twin.
  */
 import type { SourceProp, Validator } from "@chelone/core";
@@ -11,14 +11,15 @@ export interface SearchInputProps {
     source?: SourceProp;
     label?: string | false;
     disableClearable?: boolean;
-    defaultValue?: unknown;
+    defaultValue?: string;
     validate?: Validator | readonly Validator[];
     placeholder?: string;
     inputClass?: string;
     class?: string;
 }
-declare const _default: import("vue").DefineComponent<SearchInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SearchInputProps> & Readonly<{}>, {
-    source: SourceProp;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<SearchInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SearchInputProps> & Readonly<{}>, {
+    source: string;
     disableClearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

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

@@ -0,0 +1,113 @@
+import { useCheloneFormContext, useWrappedSource } from "../../../form/form-context.js";
+import { subscribeStore, useSubscribable } from "../../../form/subscribe-ref.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { cn } from "../../../lib/utils.js";
+import button_default from "../../ui/button.js";
+import text_input_default from "./text-input.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, unref, withCtx } from "vue";
+// src/components/admin/inputs/search-input.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "relative mt-auto flex grow" };
+var search_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "search-input",
+	props: {
+		source: { default: "q" },
+		label: { type: [String, Boolean] },
+		disableClearable: {
+			type: Boolean,
+			default: false
+		},
+		defaultValue: {},
+		validate: {},
+		placeholder: {},
+		inputClass: {},
+		class: {}
+	},
+	setup(__props) {
+		/**
+		* `<SearchInput>` — an unlabelled text input with a search icon, the Vue analog
+		* of `@chelone/react`'s `inputs/search-input.tsx`. Designed for filter bars, it
+		* defaults to the `q` full-text source. Reads the live value off the ambient
+		* form store and clears via `form.ambient.setFieldValue`. It throws if given a `label`
+		* (use `<TextInput>` when a label is needed) — mirroring the React twin.
+		*/
+		const props = __props;
+		if (props.label) throw new Error("<SearchInput> isn't designed to be used with a label prop. Use <TextInput> if you need a label.");
+		const translate = useTranslate();
+		const { form } = useCheloneFormContext();
+		const wrappedSource = useWrappedSource(props.source);
+		const formState = useSubscribable({
+			getSnapshot: () => form.ambient.store.state,
+			subscribe: (cb) => subscribeStore(form.ambient.store, cb)
+		});
+		const hasValue = computed(() => {
+			formState.value;
+			const v = form.ambient.getFieldValue(wrappedSource);
+			return v != null && v !== "";
+		});
+		const showClearButton = computed(() => !props.disableClearable && hasValue.value);
+		const searchPlaceholder = computed(() => props.placeholder ?? translate("ra.action.search", { _: "Search" }));
+		const clearLabel = computed(() => translate("ra.action.clear_search", { _: "Clear search" }));
+		function handleClear() {
+			form.ambient.setFieldValue(wrappedSource, "");
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				createVNode(text_input_default, {
+					source: __props.source,
+					label: false,
+					"default-value": __props.defaultValue,
+					validate: __props.validate,
+					placeholder: searchPlaceholder.value,
+					class: normalizeClass(unref(cn)("grow", props.class)),
+					"input-class": unref(cn)(showClearButton.value ? "pr-16" : "pr-8", __props.inputClass)
+				}, null, 8, [
+					"source",
+					"default-value",
+					"validate",
+					"placeholder",
+					"class",
+					"input-class"
+				]),
+				_cache[1] || (_cache[1] = createElementVNode("svg", {
+					xmlns: "http://www.w3.org/2000/svg",
+					class: "-translate-y-1/2 pointer-events-none absolute top-1/2 right-3 size-4 text-muted-foreground",
+					viewBox: "0 0 24 24",
+					fill: "none",
+					stroke: "currentColor",
+					"stroke-width": "2",
+					"stroke-linecap": "round",
+					"stroke-linejoin": "round",
+					"aria-hidden": "true"
+				}, [createElementVNode("circle", {
+					cx: "11",
+					cy: "11",
+					r: "8"
+				}), createElementVNode("path", { d: "m21 21-4.3-4.3" })], -1)),
+				showClearButton.value ? (openBlock(), createBlock(button_default, {
+					key: 0,
+					"data-slot": "clear-search",
+					type: "button",
+					variant: "ghost",
+					size: "sm",
+					class: normalizeClass("-translate-y-1/2 absolute top-1/2 right-8 size-6 rounded-full p-0 text-muted-foreground"),
+					"aria-label": clearLabel.value,
+					onClick: handleClear
+				}, {
+					default: withCtx(() => [..._cache[0] || (_cache[0] = [createElementVNode("svg", {
+						xmlns: "http://www.w3.org/2000/svg",
+						class: "size-3",
+						viewBox: "0 0 24 24",
+						fill: "none",
+						stroke: "currentColor",
+						"stroke-width": "2",
+						"stroke-linecap": "round",
+						"stroke-linejoin": "round",
+						"aria-hidden": "true"
+					}, [createElementVNode("path", { d: "M18 6 6 18" }), createElementVNode("path", { d: "m6 6 12 12" })], -1)])]),
+					_: 1
+				}, 8, ["aria-label"])) : createCommentVNode("", true)
+			]);
+		};
+	}
+});
+export { search_input_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/select-array-input.js

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

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

@@ -1,20 +1,26 @@
+import type { LooseRecord, SourceProp } from "@chelone/core";
 import type { ChoiceRecord } from "../../../choices/use-choices.js";
 import type { ChoiceInputBaseProps } from "./choice-input-props.js";
 /** Props for {@link SelectArrayInput}. */
-export interface SelectArrayInputProps<TChoice extends ChoiceRecord = ChoiceRecord> extends ChoiceInputBaseProps<TChoice> {
+export interface SelectArrayInputProps<TRecord = LooseRecord, TPath extends SourceProp<TRecord> = SourceProp<TRecord>, TChoice extends ChoiceRecord = ChoiceRecord> extends ChoiceInputBaseProps<TRecord, TPath, TChoice> {
     /** Placeholder shown in the trigger when nothing is selected. */
     placeholder?: string;
 }
-declare const _default: <TChoice extends ChoiceRecord = ChoiceRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & SelectArrayInputProps<TChoice> & Partial<{}>> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <TChoice extends ChoiceRecord = ChoiceRecord>(__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<SelectArrayInputProps<LooseRecord, string, TChoice>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
     attrs: any;
     slots: {};
     emit: {};
 }>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-export default _default;
-type __VLS_PrettifyLocal<T> = {
+type __VLS_PrettifyLocal<T> = (T extends any ? {
     [K in keyof T]: T[K];
-} & {};
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};