sard 1.0.0 → 1.0.2

package/components/floating-panel/floating-panel.d.ts

@@ -0,0 +1,23 @@
+import { type FloatingPanelProps, type FloatingPanelSlots, type FloatingPanelExpose } from './common';
+type __VLS_Slots = FloatingPanelSlots;
+declare const __VLS_base: import("vue").DefineComponent<FloatingPanelProps, FloatingPanelExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:height": (value: number) => any;
+    "height-change": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<FloatingPanelProps> & Readonly<{
+    "onUpdate:height"?: ((value: number) => any) | undefined;
+    "onHeight-change"?: ((value: number) => any) | undefined;
+}>, {
+    height: number;
+    duration: number;
+    anchors: number[];
+    contentDraggable: boolean;
+    safeAreaInsetBottom: boolean;
+}, {}, {}, {}, 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/components/floating-panel/floating-panel.js

@@ -0,0 +1,155 @@
+import { createBem } from "../../utils/bem.js";
+import { usePointerDown } from "../../use/usePointerDown.js";
+import { useInitialVelocity } from "../../use/useInitialVelocity.js";
+import { defaultFloatingPanelProps } from "./common.js";
+import { computed, createElementBlock, createElementVNode, defineComponent, mergeDefaults, normalizeClass, normalizeStyle, openBlock, ref, renderSlot, unref, useTemplateRef, watch } from "vue";
+//#region packages/sard/components/floating-panel/floating-panel.vue
+const MIN_DELTA = 3;
+var floating_panel_default = /*@__PURE__*/ defineComponent({
+	__name: "floating-panel",
+	props: /*@__PURE__*/ mergeDefaults({
+		height: {
+			type: Number,
+			required: false
+		},
+		anchors: {
+			type: Array,
+			required: false
+		},
+		duration: {
+			type: Number,
+			required: false
+		},
+		contentDraggable: {
+			type: Boolean,
+			required: false
+		},
+		safeAreaInsetBottom: {
+			type: Boolean,
+			required: false
+		}
+	}, defaultFloatingPanelProps),
+	emits: ["update:height", "height-change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("floating-panel");
+		const mergedAnchors = computed(() => {
+			return props.anchors || [100, ~~(window.innerHeight * .6)];
+		});
+		let startY = 0;
+		let prevY = 0;
+		const offsetY = ref(0);
+		const isDown = ref(false);
+		let target = "scroll";
+		watch(mergedAnchors, () => {
+			offsetY.value = mergedAnchors.value[0];
+		}, { immediate: true });
+		watch(() => props.height, () => {
+			if (props.height) offsetY.value = props.height;
+		}, { immediate: true });
+		const triggerChange = (value, touchEnd) => {
+			if (offsetY.value !== value) {
+				offsetY.value = value;
+				emit("update:height", offsetY.value);
+				if (touchEnd) emit("height-change", offsetY.value);
+			}
+		};
+		let targetLocked = false;
+		let isAtTop = false;
+		let isAtBottom = false;
+		let canScroll = false;
+		const onScroll = () => {
+			const { scrollTop, scrollHeight, clientHeight } = scrollRef.value;
+			isAtTop = scrollTop <= 0;
+			isAtBottom = scrollTop + clientHeight >= scrollHeight - 1;
+		};
+		const scrollRef = useTemplateRef("scroll");
+		const initVelocity = useInitialVelocity();
+		const onTouchStart = (event) => {
+			isDown.value = true;
+			const { clientX, clientY } = event.touches[0];
+			prevY = startY = clientY;
+			canScroll = offsetY.value > mergedAnchors.value[0];
+			initVelocity.start(clientX, clientY);
+		};
+		const onTouchMove = (event) => {
+			const targetEl = event.target;
+			const isAtScroll = targetEl === scrollRef.value || scrollRef.value.contains(targetEl);
+			if (isAtScroll && !props.contentDraggable) return;
+			const { clientX, clientY } = event.touches[0];
+			const moveY = clientY;
+			const startDeltaY = moveY - startY;
+			if (Math.abs(startDeltaY) < MIN_DELTA) return;
+			if (!targetLocked) {
+				if (!canScroll || !isAtScroll || startDeltaY > 0 && isAtTop || startDeltaY < 0 && isAtBottom) target = "panel";
+				else target = "scroll";
+				targetLocked = true;
+			}
+			if (target === "panel") {
+				let deltaY = prevY - moveY;
+				prevY = moveY;
+				event.preventDefault();
+				const anchors = mergedAnchors.value;
+				if (offsetY.value > anchors[anchors.length - 1] || offsetY.value < anchors[0]) deltaY /= 4;
+				triggerChange(offsetY.value + deltaY);
+				initVelocity.move(clientX, clientY);
+			}
+		};
+		function getCorrectOffset(direction) {
+			const anchors = mergedAnchors.value;
+			const min = anchors[0];
+			const max = anchors[anchors.length - 1];
+			const current = offsetY.value;
+			if (current <= min) return min;
+			else if (current >= max) return max;
+			for (let i = 1; i < anchors.length; i++) {
+				const below = anchors[i - 1];
+				const above = anchors[i];
+				if (current >= below && current <= above) if (direction) return direction === "up" ? above : below;
+				else return above - current < current - below ? above : below;
+			}
+			return 0;
+		}
+		const onTouchEnd = () => {
+			if (target === "panel") {
+				const velocity = initVelocity.end();
+				let value = 0;
+				if (Math.abs(velocity.y) > .5) value = getCorrectOffset(velocity.y > 0 ? "down" : "up");
+				else value = getCorrectOffset();
+				triggerChange(value, true);
+			}
+			targetLocked = false;
+			isDown.value = false;
+		};
+		const onPointerDown = usePointerDown(onTouchStart, onTouchMove, onTouchEnd);
+		const floatingPanelClass = computed(() => {
+			return [bem.b(), bem.m("safe", props.safeAreaInsetBottom)];
+		});
+		const floatingPanelStyle = computed(() => {
+			return {
+				transform: `translate3d(0, calc(100% - ${offsetY.value}px), 0)`,
+				height: `${mergedAnchors.value[mergedAnchors.value.length - 1]}px`,
+				transition: isDown.value ? "none" : `transform ${props.duration}ms cubic-bezier(0.18, 0.89, 0.32, 1.28)`
+			};
+		});
+		__expose({});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				class: normalizeClass(floatingPanelClass.value),
+				style: normalizeStyle(floatingPanelStyle.value),
+				onTouchstart: onTouchStart,
+				onTouchmove: onTouchMove,
+				onTouchend: onTouchEnd,
+				onTouchcancel: onTouchEnd,
+				onPointerdown: _cache[0] || (_cache[0] = (...args) => unref(onPointerDown) && unref(onPointerDown)(...args))
+			}, [createElementVNode("div", { class: normalizeClass(unref(bem).e("header")) }, [createElementVNode("div", { class: normalizeClass(unref(bem).e("header-bar")) }, null, 2)], 2), createElementVNode("div", {
+				ref: "scroll",
+				class: normalizeClass(unref(bem).e("body")),
+				onScroll
+			}, [renderSlot(_ctx.$slots, "default")], 34)], 38);
+		};
+	}
+});
+//#endregion
+export { floating_panel_default as default };

package/components/floating-panel/index.css

@@ -0,0 +1 @@
+:root{--s-floating-panel-z-index:var(--s-z-index-secondary);--s-floating-panel-bg:var(--s-bg-color-elevated);--s-floating-panel-radius:var(--s-border-radius-xl);--s-floating-panel-header-height:var(--s-size-2xl);--s-floating-panel-bar-width:var(--s-size-lg);--s-floating-panel-bar-height:3px;--s-floating-panel-bar-color:var(--s-fill-color-secondary)}.s-floating-panel{position:fixed;left:0;bottom:0;z-index:var(--s-floating-panel-z-index);display:flex;flex-direction:column;width:100vw;border-top-left-radius:var(--s-floating-panel-radius);border-top-right-radius:var(--s-floating-panel-radius);background:var(--s-floating-panel-bg);will-change:transform;touch-action:none;transition-property:transform}.s-floating-panel::after{position:absolute;bottom:-100vh;width:100vw;height:100vh;content:"";background-color:inherit}.s-floating-panel--safe{padding-bottom:var(--s-safe-bottom)}.s-floating-panel__header{flex:none;display:flex;justify-content:center;align-items:center;height:var(--s-floating-panel-header-height);-webkit-user-select:none;user-select:none;cursor:grab}.s-floating-panel__header-bar{width:var(--s-floating-panel-bar-width);height:var(--s-floating-panel-bar-height);background:var(--s-floating-panel-bar-color);border-radius:var(--s-border-radius-full)}.s-floating-panel__body{min-height:0;flex:1;overflow-y:auto;overflow-x:hidden}

package/components/floating-panel/index.d.ts

@@ -0,0 +1,5 @@
+import { type EnhancedComponent } from '../../utils';
+import _FloatingPanel from './floating-panel.vue';
+export declare const FloatingPanel: EnhancedComponent<typeof _FloatingPanel>;
+export default FloatingPanel;
+export type { FloatingPanelProps, FloatingPanelSlots, FloatingPanelEmits, FloatingPanelExpose, } from './common';

package/components/floating-panel/index.js

@@ -0,0 +1,6 @@
+import { enhanceComponent } from "../../utils/component.js";
+import floating_panel_default from "./floating-panel.js";
+//#region packages/sard/components/floating-panel/index.ts
+const FloatingPanel = enhanceComponent(floating_panel_default);
+//#endregion
+export { FloatingPanel, FloatingPanel as default };

package/components/form/Validator.d.ts

@@ -0,0 +1,95 @@
+export interface ValidateMessages {
+    default?: string;
+    required?: string;
+    enum?: string;
+    whitespace?: string;
+    date?: {
+        format?: string;
+        parse?: string;
+        invalid?: string;
+    };
+    types?: {
+        string?: string;
+        function?: string;
+        array?: string;
+        object?: string;
+        number?: string;
+        date?: string;
+        boolean?: string;
+        integer?: string;
+        float?: string;
+        regexp?: string;
+        email?: string;
+        url?: string;
+        hex?: string;
+    };
+    string?: {
+        len?: string;
+        min?: string;
+        max?: string;
+        range?: string;
+    };
+    number?: {
+        len?: string;
+        min?: string;
+        max?: string;
+        range?: string;
+    };
+    array?: {
+        len?: string;
+        min?: string;
+        max?: string;
+        range?: string;
+    };
+    pattern?: {
+        mismatch?: string;
+    };
+}
+export interface Rule {
+    validator?: (value: any, rule: Rule) => Promise<any> | boolean | string | undefined;
+    pattern?: RegExp;
+    message?: string | (() => string);
+    trigger?: string | string[];
+    transform?: (value: any) => any;
+    type?: keyof typeof typeStrategies;
+    enum?: (string | number)[];
+    len?: number;
+    max?: number;
+    min?: number;
+    required?: boolean;
+    whitespace?: boolean;
+}
+export interface ValidateOptions {
+    validateFirst?: boolean;
+    value?: any;
+    name?: string | number | (string | number)[];
+    label?: string;
+    trigger?: string | string[];
+}
+export type VdaliteFailResult = string[];
+declare const typeStrategies: {
+    string(value: any, rule: Rule): string | boolean;
+    number(value: any, rule: Rule): string | boolean;
+    integer(value: any, rule: Rule): string | boolean;
+    float(value: any, rule: Rule): string | boolean;
+    boolean(value: any): value is boolean;
+    function(value: any): value is (...args: any[]) => any;
+    regexp(value: any): boolean;
+    array(value: any, rule: Rule): string | boolean;
+    object(value: any): any;
+    enum(value: any, rule: Rule): true | "enum";
+    date(value: any): value is Date;
+    url(value: any): boolean;
+    hex(value: any): boolean;
+    email(value: any): boolean;
+};
+export declare class Validator {
+    protected validateMessages: ValidateMessages | undefined;
+    setValidateMessages(validateMessages: ValidateMessages): void;
+    getValidTriggerRules(rules: Rule[], trigger?: string | string[]): Rule[];
+    validate(rules: Rule[], options?: ValidateOptions): Promise<void>;
+    protected validateRule(value: any, rule: Rule): Promise<void>;
+    protected validateInternal(type: keyof typeof typeStrategies, value: any, rule: Rule): Promise<void>;
+    protected replaceSymbol(string: string | Error, rule: Rule, options?: ValidateOptions): string;
+}
+export {};

package/components/form/Validator.js

@@ -0,0 +1,185 @@
+import { isBoolean, isFunction, isNumber, isString } from "../../utils/is.js";
+import { isEmptyValue } from "../../utils/utils.js";
+import { chainGet } from "../../utils/object.js";
+import { toArray } from "../../utils/array.js";
+import getUrlRegexp_default from "./getUrlRegexp.js";
+//#region packages/sard/components/form/Validator.ts
+function getMessage(message) {
+	return isFunction(message) ? message() : message;
+}
+function handleRange(len, type, rule) {
+	if (isNumber(rule.len)) return len !== rule.len ? `${type}.len` : true;
+	else if (isNumber(rule.min) && isNumber(rule.max)) return len < rule.min || len > rule.max ? `${type}.range` : true;
+	else if (isNumber(rule.min)) return len < rule.min ? `${type}.min` : true;
+	else if (isNumber(rule.max)) return len > rule.max ? `${type}.max` : true;
+	else return true;
+}
+const typeStrategies = {
+	string(value, rule) {
+		if (isString(value)) return handleRange(value.length, "string", rule);
+		else return false;
+	},
+	number(value, rule) {
+		if (isNumber(value)) return handleRange(value, "number", rule);
+		else return false;
+	},
+	integer(value, rule) {
+		if (Number.isInteger(value)) return handleRange(value, "number", rule);
+		else return false;
+	},
+	float(value, rule) {
+		if (Number.isFinite(value) && value % 1 !== 0) return handleRange(value, "number", rule);
+		else return false;
+	},
+	boolean(value) {
+		return isBoolean(value);
+	},
+	function(value) {
+		return isFunction(value);
+	},
+	regexp(value) {
+		if (isString(value)) try {
+			new RegExp(value);
+			return true;
+		} catch {
+			return false;
+		}
+		else return value instanceof RegExp;
+	},
+	array(value, rule) {
+		if (Array.isArray(value)) return handleRange(value.length, "number", rule);
+		else return false;
+	},
+	object(value) {
+		return value && typeof value === "object" && !Array.isArray(value);
+	},
+	enum(value, rule) {
+		return rule.enum?.includes(value) ? true : "enum";
+	},
+	date(value) {
+		return value instanceof Date;
+	},
+	url(value) {
+		return isString(value) && getUrlRegexp_default().test(value);
+	},
+	hex(value) {
+		return isString(value) && /^#(?:[0-9A-F]{6}|[0-9A-F]{3})$/i.test(value);
+	},
+	email(value) {
+		return isString(value) && /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(value);
+	}
+};
+var Validator = class {
+	validateMessages = void 0;
+	setValidateMessages(validateMessages) {
+		this.validateMessages = validateMessages;
+	}
+	getValidTriggerRules(rules, trigger) {
+		let validRules = rules;
+		if (trigger) {
+			const validTrigger = toArray(trigger);
+			validRules = rules.filter(Boolean).filter((rule) => {
+				let { trigger: ruleTrigger } = rule;
+				if (!ruleTrigger) return true;
+				ruleTrigger = toArray(ruleTrigger);
+				return validTrigger.some((name) => ruleTrigger.includes(name));
+			});
+		}
+		return validRules;
+	}
+	validate(rules, options = {}) {
+		const { validateFirst, value } = options;
+		return new Promise((resolve, reject) => {
+			if (validateFirst) Promise.all(rules.map((rule) => {
+				return this.validateRule(value, rule);
+			})).then(() => {
+				resolve();
+			}).catch(({ error, rule }) => {
+				reject([this.replaceSymbol(error, rule, options)]);
+			});
+			else Promise.allSettled(rules.map((rule) => {
+				return this.validateRule(value, rule);
+			})).then((values) => {
+				const rejected = values.filter(({ status }) => {
+					return status === "rejected";
+				});
+				if (rejected.length === 0) resolve();
+				else reject(rejected.map((result) => {
+					const { error, rule } = result.reason;
+					return this.replaceSymbol(error, rule, options);
+				}));
+			});
+		});
+	}
+	validateRule(value, rule) {
+		if (rule.transform) value = rule.transform(value);
+		return new Promise((resolve, reject) => {
+			const handleReject = (error) => {
+				reject({
+					error,
+					rule
+				});
+			};
+			if (isEmptyValue(value, rule.whitespace) && !rule.validator) {
+				if (rule.required) handleReject(getMessage(rule.message) || chainGet(this.validateMessages, "required"));
+				else resolve();
+				return;
+			}
+			if (rule.validator) {
+				const result = rule.validator(value, rule);
+				if (result instanceof Promise) result.then(() => {
+					resolve();
+				}).catch((error) => {
+					handleReject(error);
+				});
+				else if (result === true) resolve();
+				else if (isString(result)) handleReject(result);
+				else handleReject(getMessage(rule.message));
+				return;
+			}
+			if (rule.pattern instanceof RegExp) {
+				if (rule.pattern.test(String(value))) resolve();
+				else handleReject(getMessage(rule.message) || chainGet(this.validateMessages, "pattern.mismatch"));
+				return;
+			}
+			let ruleType = rule.type;
+			if (!ruleType && (isNumber(rule.min) || isNumber(rule.max) || isNumber(rule.len))) ruleType = "string";
+			if (ruleType && Object.keys(typeStrategies).includes(ruleType)) {
+				this.validateInternal(ruleType, value, rule).then(() => {
+					resolve();
+				}).catch((err) => {
+					handleReject(getMessage(rule.message) || err);
+				});
+				return;
+			}
+			resolve();
+		});
+	}
+	validateInternal(type, value, rule) {
+		return new Promise((resolve, reject) => {
+			const result = typeStrategies[type]?.(value, rule);
+			if (result === true) resolve();
+			else reject(chainGet(this.validateMessages, isString(result) ? result : `types.${type}`));
+		});
+	}
+	replaceSymbol(string, rule, options = {}) {
+		if (string instanceof Error) string = string.message;
+		if (!isString(string)) string = String(string);
+		const label = isString(options.label) ? options.label : String(options.name);
+		const matches = {
+			"{min}": rule.min,
+			"{max}": rule.max,
+			"{len}": rule.len,
+			"{enum}": rule.enum,
+			"{label}": label,
+			"{value}": options.value,
+			"{type}": rule.type,
+			"{pattern}": rule.pattern?.toString()
+		};
+		return string.replace(/\{(?:min|max|len|enum|label|value|type|pattern)\}/g, (m) => {
+			return matches[m] ?? "";
+		});
+	}
+};
+//#endregion
+export { Validator };

package/components/form/common.d.ts

@@ -0,0 +1,114 @@
+import { type InjectionKey, type Ref } from 'vue';
+import { type Validator, type Rule } from './Validator';
+import { type DefaultProps } from '../config';
+export interface FormRules {
+    [key: PropertyKey]: Rule | Rule[] | FormRules;
+}
+export type FieldName = string | number | (string | number)[];
+export type ValidateState = '' | 'success' | 'error' | 'validating';
+export type TriggerType = 'change' | 'blur' | ('change' | 'blur')[];
+export interface FieldValidateError {
+    name: FieldName;
+    value: any;
+    message: string;
+}
+export interface FormProps {
+    model?: Record<string, any>;
+    rules?: FormRules;
+    validateTrigger?: TriggerType;
+    validateOnRuleChange?: boolean;
+    direction?: 'horizontal' | 'vertical';
+    labelWidth?: string;
+    labelAlign?: 'start' | 'center' | 'end';
+    labelValign?: 'start' | 'center' | 'end';
+    starPosition?: 'start' | 'end';
+    contentPosition?: 'start' | 'end';
+    hideStar?: boolean;
+    showError?: boolean;
+    scrollToFirstError?: boolean;
+    scrollIntoViewOptions?: ScrollIntoViewOptions;
+    disabled?: boolean;
+    readonly?: boolean;
+    card?: boolean;
+}
+export declare const defaultFormProps: DefaultProps<FormProps>;
+export interface FormSlots {
+    default?(props: Record<string, never>): any;
+}
+export interface FormExpose {
+    validate: (nameList?: FieldName[]) => Promise<void>;
+    reset: (nameList?: FieldName[]) => Promise<void>;
+    clearValidate: (nameList?: FieldName[]) => void;
+    scrollToField: (name: FieldName) => void;
+}
+export interface FormItemProps {
+    direction?: 'horizontal' | 'vertical';
+    labelWidth?: string;
+    labelAlign?: 'start' | 'center' | 'end';
+    labelValign?: 'start' | 'center' | 'end';
+    starPosition?: 'start' | 'end';
+    label?: string;
+    hideStar?: boolean;
+    contentPosition?: 'start' | 'end';
+    required?: boolean | undefined;
+    name?: FieldName;
+    rules?: Rule | Rule[];
+    validateTrigger?: TriggerType;
+    error?: string;
+    showError?: boolean;
+    inlaid?: boolean;
+}
+export declare const defaultFormItemProps: DefaultProps<FormItemProps>;
+export interface FormItemSlots {
+    default?(props: Record<string, never>): any;
+    label?(props: Record<string, never>): any;
+    validate?(props: {
+        state: ValidateState;
+    }): any;
+    error?(props: {
+        message: string;
+        showError: boolean;
+    }): any;
+}
+export interface FormItemExpose {
+    validate: (trigger?: string | string[]) => Promise<void>;
+    reset: () => Promise<void>;
+    clearValidate: () => void;
+    scrollToField: () => void;
+    validateMessage: Ref<string>;
+    validateState: Ref<ValidateState>;
+}
+export interface FormContext {
+    model: FormProps['model'];
+    rules: FormProps['rules'];
+    validateTrigger: FormProps['validateTrigger'];
+    direction: FormProps['direction'];
+    labelWidth: FormProps['labelWidth'];
+    labelAlign: FormProps['labelAlign'];
+    labelValign: FormProps['labelValign'];
+    starPosition: FormProps['starPosition'];
+    contentPosition: FormProps['contentPosition'];
+    hideStar: FormProps['hideStar'];
+    showError: FormProps['showError'];
+    scrollIntoViewOptions: FormProps['scrollIntoViewOptions'];
+    disabled: FormProps['disabled'];
+    readonly: FormProps['readonly'];
+    addField: (context: FormItemContext) => void;
+    removeField: (context: FormItemContext) => void;
+    validator: Validator;
+}
+export interface FormItemContext {
+    name: FormItemProps['name'];
+    validateMessage: string;
+    validateState: ValidateState;
+    validate: (trigger?: string | string[]) => Promise<void>;
+    reset: () => Promise<void>;
+    clearValidate: () => void;
+    scrollToField: () => void;
+    onBlur: () => void;
+    onChange: () => void;
+}
+export declare const formContextKey: InjectionKey<FormContext>;
+export declare const formItemContextKey: InjectionKey<FormItemContext>;
+export declare function useFormContext(): FormContext | null;
+export declare function useFormItemContext(): FormItemContext | null;

package/components/form/common.js

@@ -0,0 +1,28 @@
+import { inject } from "vue";
+//#region packages/sard/components/form/common.ts
+const defaultFormProps = {
+	validateTrigger: "change",
+	validateOnRuleChange: true,
+	direction: "horizontal",
+	labelAlign: "start",
+	labelValign: "center",
+	starPosition: "start",
+	contentPosition: "start",
+	showError: true,
+	hideStar: false
+};
+const defaultFormItemProps = {
+	showError: void 0,
+	hideStar: void 0,
+	required: void 0
+};
+const formContextKey = Symbol("formContext");
+const formItemContextKey = Symbol("formItemContext");
+function useFormContext() {
+	return inject(formContextKey, null);
+}
+function useFormItemContext() {
+	return inject(formItemContextKey, null);
+}
+//#endregion
+export { defaultFormItemProps, defaultFormProps, formContextKey, formItemContextKey, useFormContext, useFormItemContext };

package/components/form/form-item.d.ts

@@ -0,0 +1,27 @@
+import { type FormItemProps, type FormItemSlots, type FormItemExpose } from './common';
+type __VLS_Slots = FormItemSlots;
+declare const __VLS_base: import("vue").DefineComponent<FormItemProps, FormItemExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormItemProps> & Readonly<{}>, {
+    label: string;
+    name: import("./common").FieldName;
+    error: string;
+    direction: "horizontal" | "vertical";
+    required: boolean;
+    rules: import("./Validator").Rule | import("./Validator").Rule[];
+    validateTrigger: import("./common").TriggerType;
+    labelWidth: string;
+    labelAlign: "start" | "center" | "end";
+    labelValign: "start" | "center" | "end";
+    starPosition: "start" | "end";
+    contentPosition: "start" | "end";
+    hideStar: boolean;
+    showError: boolean;
+    inlaid: boolean;
+}, {}, {}, {}, 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;
+    };
+};