@czxingyu/xycomponents 0.1.0

package/dist/result/result.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,231 @@
+import { resolveSemanticClassNames as e, resolveSemanticStyles as t } from "../core/shared/index.js";
+import { useXyLocale as n } from "../core/locale/index.js";
+import { XyIcon as r } from "../icon/index.js";
+import i from "../popover/popover-value.js";
+import a from "./assets/result-403.js";
+import o from "./assets/result-404.js";
+import s from "./assets/result-500.js";
+import c from "./assets/result-error.js";
+import l from "./assets/result-info.js";
+import ee from "./assets/result-success.js";
+import u from "./assets/result-warning.js";
+import { computed as d, createBlock as f, createCommentVNode as p, createElementBlock as m, createElementVNode as h, createVNode as g, defineComponent as _, normalizeClass as v, normalizeStyle as y, openBlock as b, renderSlot as x, resolveDynamicComponent as S, unref as C, useId as w, useSlots as T, withCtx as E } from "vue";
+//#region components/result/result.vue?vue&type=script&setup=true&lang.ts
+var D = ["aria-describedby", "aria-labelledby"], O = ["aria-hidden"], k = ["src", "alt"], A = /*@__PURE__*/ _({
+	name: "XyResult",
+	__name: "result",
+	props: {
+		classNames: {
+			type: [
+				Function,
+				null,
+				Array
+			],
+			required: !1,
+			skipCheck: !0,
+			default: void 0
+		},
+		styles: {
+			type: [
+				Function,
+				null,
+				Array
+			],
+			required: !1,
+			skipCheck: !0,
+			default: void 0
+		},
+		extra: {
+			type: [
+				String,
+				Object,
+				Number,
+				Boolean,
+				null,
+				Array
+			],
+			required: !1,
+			default: void 0
+		},
+		icon: {
+			type: Boolean,
+			required: !1,
+			skipCheck: !0,
+			default: !0
+		},
+		image: {
+			type: [
+				String,
+				Object,
+				Boolean
+			],
+			required: !1,
+			default: void 0
+		},
+		imageAlt: {
+			type: String,
+			required: !1,
+			default: ""
+		},
+		imageStyle: {
+			type: Object,
+			required: !1,
+			default: void 0
+		},
+		layout: {
+			type: String,
+			required: !1,
+			default: "center"
+		},
+		size: {
+			type: String,
+			required: !1,
+			default: "md"
+		},
+		status: {
+			type: String,
+			required: !1,
+			default: "info"
+		},
+		subTitle: {
+			type: [
+				String,
+				Object,
+				Number,
+				Boolean,
+				null,
+				Array
+			],
+			required: !1,
+			default: void 0
+		},
+		title: {
+			type: [
+				String,
+				Object,
+				Number,
+				Boolean,
+				null,
+				Array
+			],
+			required: !1,
+			default: void 0
+		},
+		titleLevel: {
+			type: Number,
+			required: !1,
+			default: 2
+		}
+	},
+	setup(_) {
+		let A = _, j = T(), M = n(), N = `${w()}-title`, P = `${w()}-subtitle`, F = {
+			403: a,
+			404: o,
+			500: s,
+			error: c,
+			info: l,
+			success: ee,
+			warning: u
+		}, I = d(() => `h${A.titleLevel}`), L = d(() => A.title ?? M.value.result.titles[A.status]), R = d(() => A.subTitle), z = d(() => A.image === void 0 ? A.status : A.image), B = d(() => {
+			if (z.value !== !1) return F[z.value] ?? z.value;
+		}), V = d(() => {
+			if (A.icon !== !1) {
+				if (typeof A.icon == "string") return A.icon;
+				switch (A.status) {
+					case "success": return "check-circle-filled";
+					case "warning": return "exclamation-circle-filled";
+					case "error":
+					case "500": return "close-circle-filled";
+					case "403": return "lock-filled";
+					case "404": return "file-search-outlined";
+					default: return "info-circle-filled";
+				}
+			}
+		}), H = d(() => {
+			switch (A.status) {
+				case "success": return "var(--xy-color-success)";
+				case "warning":
+				case "403": return "var(--xy-color-warning)";
+				case "error":
+				case "500": return "var(--xy-color-danger)";
+				default: return "var(--xy-color-primary)";
+			}
+		}), U = d(() => !!j.title || $(L.value)), W = d(() => !!j.subTitle || $(R.value)), G = d(() => !!j.image || !!B.value), K = d(() => !G.value && (!!j.icon || A.icon !== !1 && !!V.value)), q = d(() => G.value ? "image" : K.value ? "icon" : "none"), J = d(() => !!j.extra || !!j.default || $(A.extra)), Y = d(() => ({
+			hasExtra: J.value,
+			hasSubTitle: W.value,
+			hasTitle: U.value,
+			layout: A.layout,
+			size: A.size,
+			status: A.status,
+			visual: q.value
+		})), X = d(() => e(A.classNames, Y.value)), Z = d(() => t(A.styles, Y.value)), Q = d(() => ({
+			"--xy-result-accent": H.value,
+			...Z.value.root
+		}));
+		function $(e) {
+			return e != null && e !== !1 && e !== "";
+		}
+		return (e, t) => (b(), m("section", {
+			class: v(["xy-result", [
+				`xy-result--${_.status}`,
+				`xy-result--${_.size}`,
+				`xy-result--layout-${_.layout}`,
+				`xy-result--visual-${q.value}`,
+				{
+					"xy-result--has-extra": J.value,
+					"xy-result--has-subtitle": W.value,
+					"xy-result--has-title": U.value
+				},
+				X.value.root
+			]]),
+			style: y(Q.value),
+			"aria-describedby": W.value ? P : void 0,
+			"aria-labelledby": U.value ? N : void 0
+		}, [
+			q.value === "none" ? p("", !0) : (b(), m("div", {
+				key: 0,
+				class: v(["xy-result__visual", X.value.visual]),
+				style: y(Z.value.visual),
+				"aria-hidden": _.imageAlt ? void 0 : "true"
+			}, [x(e.$slots, "image", {}, () => [B.value ? (b(), m("img", {
+				key: 0,
+				class: v(["xy-result__image", X.value.image]),
+				src: B.value,
+				alt: _.imageAlt,
+				style: y([_.imageStyle, Z.value.image])
+			}, null, 14, k)) : (b(), m("span", {
+				key: 1,
+				class: v(["xy-result__icon", X.value.icon]),
+				style: y(Z.value.icon),
+				"aria-hidden": "true"
+			}, [x(e.$slots, "icon", {}, () => [V.value ? (b(), f(C(r), {
+				key: 0,
+				name: V.value
+			}, null, 8, ["name"])) : p("", !0)], !0)], 6))], !0)], 14, O)),
+			h("div", {
+				class: v(["xy-result__content", X.value.content]),
+				style: y(Z.value.content)
+			}, [U.value ? (b(), f(S(I.value), {
+				key: 0,
+				id: N,
+				class: v(["xy-result__title", X.value.title]),
+				style: y(Z.value.title)
+			}, {
+				default: E(() => [x(e.$slots, "title", {}, () => [g(C(i), { value: L.value }, null, 8, ["value"])], !0)]),
+				_: 3
+			}, 8, ["class", "style"])) : p("", !0), W.value ? (b(), m("p", {
+				key: 1,
+				id: P,
+				class: v(["xy-result__subtitle", X.value.subTitle]),
+				style: y(Z.value.subTitle)
+			}, [x(e.$slots, "subTitle", {}, () => [g(C(i), { value: R.value }, null, 8, ["value"])], !0)], 6)) : p("", !0)], 6),
+			J.value ? (b(), m("div", {
+				key: 1,
+				class: v(["xy-result__extra", X.value.extra]),
+				style: y(Z.value.extra)
+			}, [x(e.$slots, "extra", {}, () => [x(e.$slots, "default", {}, () => [g(C(i), { value: _.extra }, null, 8, ["value"])], !0)], !0)], 6)) : p("", !0)
+		], 14, D));
+	}
+});
+//#endregion
+export { A as default };

package/dist/result/types.d.ts

@@ -0,0 +1,45 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import type { XySemanticClassNames, XySemanticStyles } from "../core";
+import type { XyIconName } from "../icon";
+export type XyResultStatus = "403" | "404" | "500" | "error" | "info" | "success" | "warning";
+export type XyResultSize = "lg" | "md" | "sm";
+export type XyResultLayout = "center" | "left";
+export type XyResultImagePreset = XyResultStatus;
+export type XyResultImage = XyResultImagePreset | (string & {}) | false;
+export type XyResultTitleLevel = 1 | 2 | 3 | 4 | 5;
+export type XyResultVisualType = "icon" | "image" | "none";
+export type XyResultSemanticDom = "content" | "extra" | "icon" | "image" | "root" | "subTitle" | "title" | "visual";
+export interface XyResultSemanticProps {
+    hasExtra: boolean;
+    hasSubTitle: boolean;
+    hasTitle: boolean;
+    layout: XyResultLayout;
+    size: XyResultSize;
+    status: XyResultStatus;
+    visual: XyResultVisualType;
+}
+export type XyResultClassNames = XySemanticClassNames<XyResultSemanticDom, XyResultSemanticProps>;
+export type XyResultStyles = XySemanticStyles<XyResultSemanticDom, XyResultSemanticProps>;
+export interface XyResultProps {
+    classNames?: XyResultClassNames;
+    extra?: string | VNodeChild;
+    icon?: boolean | XyIconName;
+    image?: XyResultImage;
+    imageAlt?: string;
+    imageStyle?: CSSProperties;
+    layout?: XyResultLayout;
+    size?: XyResultSize;
+    status?: XyResultStatus;
+    styles?: XyResultStyles;
+    subTitle?: string | VNodeChild;
+    title?: string | VNodeChild;
+    titleLevel?: XyResultTitleLevel;
+}
+export interface XyResultSlots {
+    default?: () => VNodeChild;
+    extra?: () => VNodeChild;
+    icon?: () => VNodeChild;
+    image?: () => VNodeChild;
+    subTitle?: () => VNodeChild;
+    title?: () => VNodeChild;
+}

package/dist/search/index.d.ts

@@ -0,0 +1,5 @@
+import { type SFCWithInstall } from "../shared/install";
+import Search from "./search.vue";
+export declare const XySearch: SFCWithInstall<typeof Search>;
+export default XySearch;
+export * from "./types";

package/dist/search/index.js

@@ -0,0 +1,6 @@
+import { withInstall as e } from "../shared/install.js";
+import t from "./search.js";
+//#region components/search/index.ts
+var n = e(t);
+//#endregion
+export { n as XySearch, n as default };

package/dist/search/search.js

@@ -0,0 +1,7 @@
+import e from "../_virtual/_plugin-vue_export-helper.js";
+import t from "./search.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                       */
+//#region components/search/search.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-1cc3d0cd"]]);
+//#endregion
+export { n as default };

package/dist/search/search.vue.d.ts

@@ -0,0 +1,49 @@
+import type { XySearchExpose, XySearchInfo, XySearchProps } from "./types";
+interface XySearchDefineProps extends XySearchProps {
+    classNames?: XySearchProps["classNames"];
+    styles?: XySearchProps["styles"];
+}
+declare var __VLS_1: {}, __VLS_23: {};
+type __VLS_Slots = {} & {
+    searchIcon?: (props: typeof __VLS_1) => any;
+} & {
+    enterButton?: (props: typeof __VLS_23) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<XySearchDefineProps, XySearchExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (value: string, event: Event, info: XySearchInfo) => any;
+    input: (value: string, event: Event) => any;
+    clear: (event: MouseEvent) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: string, event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    pressEnter: (event: KeyboardEvent) => any;
+    "update:modelValue": (args_0: string) => any;
+}, string, import("vue").PublicProps, Readonly<XySearchDefineProps> & Readonly<{
+    onSearch?: ((value: string, event: Event, info: XySearchInfo) => any) | undefined;
+    onInput?: ((value: string, event: Event) => any) | undefined;
+    onClear?: ((event: MouseEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: string, event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    variant: import("../core").XyControlVariant;
+    loading: boolean;
+    autocomplete: string;
+    autofocus: boolean;
+    modelValue: string;
+    placeholder: string;
+    clearable: boolean;
+    enterButton: import("./types").XySearchEnterButton;
+    searchIcon: import("../index.ts").XyIconName;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/search/search.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,300 @@
+import { nextId as e, resolveSemanticClassNames as t, resolveSemanticStyles as n } from "../core/shared/index.js";
+import { useXyFormControl as r } from "../core/control/index.js";
+import { useXyLocale as i } from "../core/locale/index.js";
+import a from "../icon/icon.js";
+import { computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, createVNode as d, defineComponent as f, getCurrentInstance as p, mergeProps as m, normalizeClass as h, normalizeStyle as g, openBlock as _, ref as v, renderSlot as y, toDisplayString as b, unref as x, useAttrs as S, withKeys as C } from "vue";
+//#region components/search/search.vue?vue&type=script&setup=true&lang.ts
+var ee = ["id"], te = [
+	"id",
+	"aria-describedby",
+	"aria-invalid",
+	"aria-labelledby",
+	"autocomplete",
+	"autofocus",
+	"disabled",
+	"maxlength",
+	"minlength",
+	"name",
+	"placeholder",
+	"readonly",
+	"tabindex",
+	"value"
+], ne = ["aria-label"], w = ["aria-label", "disabled"], T = ["disabled"], E = /*@__PURE__*/ f({
+	inheritAttrs: !1,
+	name: "XySearch",
+	__name: "search",
+	props: {
+		classNames: {
+			type: null,
+			required: !1
+		},
+		styles: {
+			type: null,
+			required: !1
+		},
+		allowClear: {
+			type: Boolean,
+			required: !1
+		},
+		autocomplete: {
+			type: String,
+			required: !1,
+			default: "off"
+		},
+		autofocus: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		clearable: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		enterButton: {
+			type: [Boolean, String],
+			required: !1,
+			default: !1
+		},
+		id: {
+			type: String,
+			required: !1
+		},
+		label: {
+			type: String,
+			required: !1
+		},
+		loading: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		maxlength: {
+			type: Number,
+			required: !1
+		},
+		minlength: {
+			type: Number,
+			required: !1
+		},
+		modelValue: {
+			type: String,
+			required: !1,
+			default: ""
+		},
+		name: {
+			type: String,
+			required: !1
+		},
+		placeholder: {
+			type: String,
+			required: !1,
+			default: ""
+		},
+		readonly: {
+			type: Boolean,
+			required: !1
+		},
+		searchIcon: {
+			type: null,
+			required: !1,
+			default: "search-outlined"
+		},
+		size: {
+			type: String,
+			required: !1
+		},
+		status: {
+			type: String,
+			required: !1
+		},
+		tabindex: {
+			type: Number,
+			required: !1
+		},
+		variant: {
+			type: String,
+			required: !1,
+			default: "outlined"
+		}
+	},
+	emits: [
+		"blur",
+		"change",
+		"clear",
+		"focus",
+		"input",
+		"pressEnter",
+		"search",
+		"update:modelValue"
+	],
+	setup(f, { expose: E, emit: D }) {
+		let O = f, k = D, A = S(), j = p(), M = r(() => O), N = i(), P = v(), F = v(!1), I = e("xy-search-label"), L = 0, R = o(() => {
+			let { class: e, style: t, ...n } = A;
+			return n;
+		}), z = o(() => M.disabled.value), B = o(() => M.readonly.value), V = o(() => ie("allowClear", "allow-clear") ? O.allowClear : O.clearable), H = o(() => !!O.modelValue), U = o(() => O.enterButton !== !1), W = o(() => O.label ?? N.value.search.label), G = o(() => typeof O.enterButton == "string" ? O.enterButton : N.value.search.enterButton), K = o(() => !z.value && !B.value && !O.loading), q = o(() => V.value && H.value && !z.value && !B.value), J = o(() => {
+			if (!(R.value["aria-label"] || R.value["aria-labelledby"])) return W.value ? I : void 0;
+		}), Y = o(() => ({
+			allowClear: V.value,
+			disabled: z.value,
+			hasButton: U.value,
+			hasValue: H.value,
+			loading: O.loading,
+			readonly: B.value,
+			size: M.size.value,
+			status: M.status.value,
+			variant: O.variant
+		})), X = o(() => t(O.classNames, Y.value)), Z = o(() => n(O.styles, Y.value)), re = o(() => [
+			"xy-search",
+			`xy-search--${M.size.value}`,
+			`xy-search--${O.variant}`,
+			M.status.value ? `xy-search--${M.status.value}` : "",
+			X.value.root,
+			A.class,
+			{
+				"xy-search--clearable": q.value,
+				"xy-search--disabled": z.value,
+				"xy-search--focused": F.value,
+				"xy-search--has-button": U.value,
+				"xy-search--loading": O.loading,
+				"xy-search--readonly": B.value
+			}
+		]);
+		function ie(...e) {
+			let t = j?.vnode.props ?? {};
+			return e.some((e) => Object.prototype.hasOwnProperty.call(t, e));
+		}
+		function ae(e, t) {
+			k("update:modelValue", e), k("input", e, t), M.notifyChange(e);
+		}
+		function oe(e) {
+			ae(e.target.value, e);
+		}
+		function se(e) {
+			k("change", e.target.value, e);
+		}
+		function Q(e, t = "input") {
+			t === "input" && !K.value || k("search", O.modelValue, e, { source: t });
+		}
+		function ce(e) {
+			Date.now() - L < 50 || Q(e);
+		}
+		function le(e) {
+			L = Date.now(), k("pressEnter", e), Q(e);
+		}
+		function $(e) {
+			F.value = !0, k("focus", e);
+		}
+		function ue(e) {
+			F.value = !1, k("blur", e), M.notifyBlur(e);
+		}
+		function de(e) {
+			z.value || B.value || (k("update:modelValue", ""), k("input", "", e), k("change", "", e), k("clear", e), k("search", "", e, { source: "clear" }), M.notifyChange(""), P.value?.focus());
+		}
+		return E({
+			blur: () => P.value?.blur(),
+			focus: (e) => P.value?.focus(e),
+			get input() {
+				return P.value;
+			},
+			select: () => P.value?.select()
+		}), (e, t) => (_(), l("span", {
+			class: h(re.value),
+			style: g([Z.value.root, x(A).style])
+		}, [
+			W.value ? (_(), l("span", {
+				key: 0,
+				id: x(I),
+				class: h(["xy-search__label", X.value.label]),
+				style: g(Z.value.label)
+			}, b(W.value), 15, ee)) : c("", !0),
+			u("span", {
+				class: h(["xy-search__wrapper", X.value.wrapper]),
+				style: g(Z.value.wrapper)
+			}, [
+				u("span", {
+					class: h(["xy-search__prefix-icon", X.value.icon]),
+					style: g(Z.value.icon),
+					"aria-hidden": "true"
+				}, [y(e.$slots, "searchIcon", {}, () => [d(a, {
+					name: f.searchIcon,
+					size: 14
+				}, null, 8, ["name"])], !0)], 6),
+				u("input", m(R.value, {
+					id: x(M).id.value,
+					ref_key: "inputRef",
+					ref: P,
+					class: ["xy-search__input", X.value.input],
+					"aria-describedby": x(M).describedBy.value,
+					"aria-invalid": x(M).status.value === "error" || void 0,
+					"aria-labelledby": J.value,
+					autocomplete: f.autocomplete,
+					autofocus: f.autofocus,
+					disabled: z.value,
+					maxlength: f.maxlength,
+					minlength: f.minlength,
+					name: f.name,
+					placeholder: f.placeholder,
+					readonly: B.value,
+					style: Z.value.input,
+					tabindex: f.tabindex,
+					type: "search",
+					value: f.modelValue,
+					onBlur: ue,
+					onChange: se,
+					onFocus: $,
+					onInput: oe,
+					onKeydown: C(le, ["enter"]),
+					onSearch: ce
+				}), null, 16, te),
+				q.value ? (_(), l("button", {
+					key: 0,
+					class: h(["xy-search__clear", X.value.clear]),
+					type: "button",
+					"aria-label": x(N).search.clearAriaLabel(W.value),
+					style: g(Z.value.clear),
+					onClick: de
+				}, [d(a, {
+					name: "close-circle-filled",
+					size: 14,
+					"aria-hidden": "true"
+				})], 14, ne)) : c("", !0),
+				U.value ? c("", !0) : (_(), l("button", {
+					key: 1,
+					class: h(["xy-search__icon-button", X.value.button]),
+					type: "button",
+					"aria-label": x(N).search.submitAriaLabel(W.value),
+					disabled: !K.value,
+					style: g(Z.value.button),
+					onClick: t[0] ||= (e) => Q(e)
+				}, [d(a, {
+					name: f.loading ? "loading-outlined" : f.searchIcon,
+					size: 14,
+					spin: f.loading,
+					"aria-hidden": "true"
+				}, null, 8, ["name", "spin"])], 14, w))
+			], 6),
+			U.value ? (_(), l("button", {
+				key: 1,
+				class: h(["xy-search__button", X.value.button]),
+				type: "button",
+				disabled: !K.value,
+				style: g(Z.value.button),
+				onClick: t[1] ||= (e) => Q(e)
+			}, [f.loading ? (_(), s(a, {
+				key: 0,
+				name: "loading-outlined",
+				size: 14,
+				spin: "",
+				"aria-hidden": "true"
+			})) : c("", !0), y(e.$slots, "enterButton", {}, () => [u("span", null, b(G.value), 1)], !0)], 14, T)) : c("", !0)
+		], 6));
+	}
+});
+//#endregion
+export { E as default };

package/dist/search/types.d.ts

@@ -0,0 +1,51 @@
+import type { XyControlStatus, XyControlVariant, XySemanticClassNames, XySemanticStyles, XySize } from "../core";
+import type { XyIconName } from "../icon";
+export type XySearchEnterButton = boolean | string;
+export type XySearchSource = "clear" | "input";
+export type XySearchSemanticDom = "button" | "clear" | "icon" | "input" | "label" | "root" | "wrapper";
+export interface XySearchSemanticProps {
+    allowClear: boolean;
+    disabled: boolean;
+    hasButton: boolean;
+    hasValue: boolean;
+    loading: boolean;
+    readonly: boolean;
+    size: XySize;
+    status?: XyControlStatus;
+    variant: XyControlVariant;
+}
+export interface XySearchProps {
+    allowClear?: boolean;
+    autocomplete?: string;
+    autofocus?: boolean;
+    classNames?: XySearchClassNames;
+    clearable?: boolean;
+    disabled?: boolean;
+    enterButton?: XySearchEnterButton;
+    id?: string;
+    label?: string;
+    loading?: boolean;
+    maxlength?: number;
+    minlength?: number;
+    modelValue?: string;
+    name?: string;
+    placeholder?: string;
+    readonly?: boolean;
+    searchIcon?: XyIconName;
+    size?: XySize;
+    status?: XyControlStatus;
+    styles?: XySearchStyles;
+    tabindex?: number;
+    variant?: XyControlVariant;
+}
+export interface XySearchExpose {
+    blur: () => void;
+    focus: (options?: FocusOptions) => void;
+    input: HTMLInputElement | undefined;
+    select: () => void;
+}
+export interface XySearchInfo {
+    source: XySearchSource;
+}
+export type XySearchClassNames = XySemanticClassNames<XySearchSemanticDom, XySearchSemanticProps>;
+export type XySearchStyles = XySemanticStyles<XySearchSemanticDom, XySearchSemanticProps>;