antdv-next 0.0.111 → 1.0.0-alpha.2

package/dist/float-button/style/group.js

@@ -0,0 +1,74 @@
+import { resetComponent } from "../../style/index.js";
+import { genCssVar } from "../../theme/util/genStyleUtils.js";
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/float-button/style/group.ts
+const genGroupStyle = (token) => {
+	const { componentCls, antCls, floatButtonSize, padding } = token;
+	const groupCls = `${componentCls}-group`;
+	const listCls = `${groupCls}-list`;
+	const getCssVar = genCssVar(antCls, "float-btn");
+	return { [groupCls]: [
+		{
+			[getCssVar("list-transform-start")]: `translate(0,${unit(floatButtonSize)})`,
+			[getCssVar("list-trigger-offset")]: `calc(${unit(floatButtonSize)} + ${unit(padding)})`
+		},
+		{
+			...resetComponent(token),
+			"position": "fixed",
+			"zIndex": token.zIndexPopupBase,
+			"insetInlineEnd": token.floatButtonInsetInlineEnd,
+			"bottom": token.floatButtonInsetBlockEnd,
+			"gap": padding,
+			"&-rtl": { direction: "rtl" },
+			[`&${componentCls}-pure`]: {
+				position: "relative",
+				inset: "auto"
+			},
+			[componentCls]: {
+				position: "relative",
+				inset: "auto"
+			}
+		},
+		{
+			[`&:not(${groupCls}-individual) ${listCls}`]: { boxShadow: token.boxShadowSecondary },
+			[`&${groupCls}-individual ${listCls}`]: { gap: padding },
+			[`&-menu-mode ${listCls}`]: { position: "absolute" },
+			[listCls]: {
+				"borderRadius": token.borderRadiusLG,
+				"&-motion": {
+					"transition": `all ${token.motionDurationSlow}`,
+					"&-enter, &-appear": {
+						"opacity": 0,
+						"transform": getCssVar("list-transform-start", true),
+						"&-active": {
+							opacity: 1,
+							transform: `translate(0, 0)`
+						}
+					},
+					"&-leave": { "&-active": {
+						opacity: 0,
+						transform: getCssVar("list-transform-start", true)
+					} }
+				}
+			},
+			"&-top": { [listCls]: { bottom: getCssVar("list-trigger-offset", true) } },
+			"&-bottom": { [listCls]: {
+				[getCssVar("list-transform-start")]: `translate(0, calc(${unit(floatButtonSize)} * -1))`,
+				top: getCssVar("list-trigger-offset", true)
+			} },
+			"&-left": { [listCls]: {
+				[getCssVar("list-transform-start")]: `translate(${unit(floatButtonSize)}, 0)`,
+				right: getCssVar("list-trigger-offset", true)
+			} },
+			"&-right": { [listCls]: {
+				[getCssVar("list-transform-start")]: `translate(calc(${unit(floatButtonSize)} * -1), 0)`,
+				left: getCssVar("list-trigger-offset", true)
+			} }
+		}
+	] };
+};
+var group_default = genGroupStyle;
+
+//#endregion
+export { group_default as default };

package/dist/float-button/style/index.d.ts

@@ -0,0 +1,8 @@
+import "../../theme/internal.js";
+import "vue";
+
+//#region src/float-button/style/index.d.ts
+/** Component only token. Which will handle additional calculation of alias token */
+type ComponentToken = object;
+//#endregion
+export { ComponentToken };

package/dist/float-button/style/index.js

@@ -0,0 +1,26 @@
+import { genStyleHooks } from "../../theme/util/genStyleUtils.js";
+import { mergeToken } from "../../theme/internal.js";
+import { initFadeMotion } from "../../style/motion/fade.js";
+import "../../style/motion/index.js";
+import button_default from "./button.js";
+import group_default from "./group.js";
+
+//#region src/float-button/style/index.ts
+const prepareComponentToken = () => ({});
+var style_default = genStyleHooks("FloatButton", (token) => {
+	const { controlHeightLG, marginXXL, marginLG, fontSizeIcon, calc } = token;
+	const floatButtonToken = mergeToken(token, {
+		floatButtonIconSize: calc(fontSizeIcon).mul(1.5).equal(),
+		floatButtonSize: controlHeightLG,
+		floatButtonInsetBlockEnd: marginXXL,
+		floatButtonInsetInlineEnd: marginLG
+	});
+	return [
+		button_default(floatButtonToken),
+		group_default(floatButtonToken),
+		initFadeMotion(token)
+	];
+}, prepareComponentToken, { order: -998 });
+
+//#endregion
+export { style_default as default };

package/dist/form/ErrorList.js

@@ -0,0 +1,127 @@
+import { getAttrStyleAndClass } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { getSlotPropsFnRun } from "../_util/tools.js";
+import useCSSVarCls_default from "../config-provider/hooks/useCSSVarCls.js";
+import motion_default from "../_util/motion.js";
+import isNonNullable_default from "../_util/isNonNullable.js";
+import { useFormItemPrefixContext } from "./context.js";
+import style_default from "./style/index.js";
+import { Transition, TransitionGroup, computed, createVNode, defineComponent, isVNode, vShow, withDirectives } from "vue";
+import { clsx } from "@v-c/util";
+import { getTransitionGroupProps, getTransitionProps } from "@v-c/util/dist/utils/transition";
+
+//#region src/form/ErrorList.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const EMPTY_LIST = [];
+function toErrorEntity(error, prefix, errorStatus, index = 0) {
+	return {
+		key: typeof error === "string" ? error : `${prefix}-${index}`,
+		error,
+		errorStatus
+	};
+}
+const ErrorList = /* @__PURE__ */ defineComponent((props, { attrs }) => {
+	const formItemPrefixContext = useFormItemPrefixContext();
+	const prefixCls = computed(() => formItemPrefixContext.value?.prefixCls ?? "");
+	const baseClassName = computed(() => `${prefixCls.value}-item-explain`);
+	const rootCls = useCSSVarCls_default(prefixCls);
+	const [hashId, cssVarCls] = style_default(prefixCls, rootCls);
+	return () => {
+		let _slot;
+		const { fieldId, errors, warnings, helpStatus } = props;
+		const help = getSlotPropsFnRun({}, props, "help");
+		const debounceErrors = errors || EMPTY_LIST;
+		const debouncedWarnings = warnings || EMPTY_LIST;
+		const fullKeyListFn = () => {
+			if (isNonNullable_default(help)) return [toErrorEntity(help, "help", helpStatus)];
+			return [...debounceErrors.map((error, index) => toErrorEntity(error, "error", "error", index)), ...debouncedWarnings.map((warning, index) => toErrorEntity(warning, "warning", "warning", index))];
+		};
+		const fullKeyList = fullKeyListFn();
+		const filledKeyFullKeyListFn = () => {
+			const keysCount = {};
+			fullKeyList.forEach(({ key }) => {
+				keysCount[key] = (keysCount[key] || 0) + 1;
+			});
+			return fullKeyList.map((entity, index) => ({
+				...entity,
+				key: keysCount[entity.key] > 1 ? `${entity.key}-fallback-${index}` : entity.key
+			}));
+		};
+		const filledKeyFullKeyList = filledKeyFullKeyListFn();
+		const helpProps = {};
+		if (fieldId) helpProps.id = `${fieldId}_help`;
+		const { className: rootClassName } = getAttrStyleAndClass(attrs);
+		const collapseMotion = motion_default(prefixCls.value);
+		const transitionPropsName = `${prefixCls.value}-show-help`;
+		const transitionProps = {
+			name: transitionPropsName,
+			...getTransitionProps(transitionPropsName),
+			appear: true,
+			css: true,
+			onAfterEnter: () => {
+				props.onVisibleChanged?.(true);
+			},
+			onAfterLeave: () => {
+				props.onVisibleChanged?.(false);
+			}
+		};
+		const transitionGroupPropsName = `${prefixCls.value}-show-help-item`;
+		const transitionGroupProps = {
+			tag: "div",
+			class: clsx(baseClassName.value, cssVarCls.value, rootCls.value, rootClassName, hashId.value),
+			...getTransitionGroupProps(transitionGroupPropsName),
+			...collapseMotion,
+			name: `${prefixCls.value}-show-help-item`
+		};
+		return createVNode(Transition, transitionProps, { default: () => [withDirectives(createVNode(TransitionGroup, transitionGroupProps, _isSlot(_slot = filledKeyFullKeyList.map((itemProps) => {
+			const { key, error, errorStatus, class: itemClassName, style: itemStyle } = itemProps;
+			return createVNode("div", {
+				"key": key,
+				"class": clsx(itemClassName, { [`${baseClassName.value}-${errorStatus}`]: !!errorStatus }),
+				"style": itemStyle
+			}, [error]);
+		})) ? _slot : { default: () => [_slot] }), [[vShow, !!filledKeyFullKeyList.length]])] });
+	};
+}, {
+	props: {
+		fieldId: {
+			type: String,
+			required: false
+		},
+		help: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		helpStatus: {
+			type: String,
+			required: false
+		},
+		errors: {
+			type: Array,
+			required: false
+		},
+		warnings: {
+			type: Array,
+			required: false
+		},
+		onVisibleChanged: {
+			type: Function,
+			required: false
+		}
+	},
+	name: "FormErrorList",
+	inheritAttrs: false
+});
+var ErrorList_default = ErrorList;
+
+//#endregion
+export { ErrorList_default as default };

package/dist/form/Form.d.ts

@@ -0,0 +1,87 @@
+import { SizeType } from "../config-provider/SizeContext.js";
+import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { ColProps } from "../grid/col.js";
+import "../grid/index.js";
+import { FormLabelAlign, ScrollFocusOptions } from "./interface.js";
+import { FieldData, InternalNamePath, NamePath, Rule, ValidateErrorEntity, ValidateMessages, ValidateOptions } from "./types.js";
+import { FeedbackIcons } from "./FormItem/index.js";
+import { ComponentBaseProps, Variant } from "../config-provider/context.js";
+import * as vue263 from "vue";
+import { SlotsType } from "vue";
+
+//#region src/form/Form.d.ts
+type RequiredMark = boolean | 'optional' | ((labelNode: any, info: {
+  required: boolean;
+}) => any);
+type FormLayout = 'horizontal' | 'inline' | 'vertical';
+type FormItemLayout = 'horizontal' | 'vertical';
+type FormSemanticName = 'root' | 'label' | 'content';
+type FormClassNamesType = SemanticClassNamesType<FormProps, FormSemanticName>;
+type FormStylesType = SemanticStylesType<FormProps, FormSemanticName>;
+interface FormProps extends ComponentBaseProps {
+  classes?: FormClassNamesType;
+  styles?: FormStylesType;
+  colon?: boolean;
+  name?: string;
+  layout?: FormLayout;
+  labelAlign?: FormLabelAlign;
+  labelWrap?: boolean;
+  labelCol?: ColProps;
+  wrapperCol?: ColProps;
+  feedbackIcons?: FeedbackIcons;
+  size?: SizeType;
+  disabled?: boolean;
+  scrollToFirstError?: ScrollFocusOptions | boolean;
+  requiredMark?: RequiredMark;
+  variant?: Variant;
+  validateMessages?: ValidateMessages;
+  model?: Record<string, any>;
+  rules?: Record<string, Rule[]>;
+  validateTrigger?: string | string[] | false;
+  preserve?: boolean;
+  clearOnDestroy?: boolean;
+  validateOnRuleChange?: boolean;
+}
+interface FormEmits {
+  finish: (values: Record<string, any>) => void;
+  finishFailed: (errorInfo: ValidateErrorEntity) => void;
+  submit: (e: Event) => void;
+  reset: (e: Event) => void;
+  validate: (name: InternalNamePath, status: boolean, errors: any[] | null) => void;
+  valuesChange: (changedValues: Record<string, any>, values: Record<string, any>) => void;
+  fieldsChange: (changedFields: FieldData[], allFields: FieldData[]) => void;
+  [key: string]: (...args: any[]) => void;
+}
+interface FormSlots {
+  default: () => any;
+}
+interface FormInstance {
+  getFieldValue: (name: NamePath) => any;
+  getFieldsValue: (nameList?: NamePath[] | true) => Record<string, any>;
+  getFieldError: (name: NamePath) => string[];
+  getFieldsError: (nameList?: NamePath[]) => {
+    name: InternalNamePath;
+    errors: string[];
+    warnings: string[];
+  }[];
+  getFieldWarning: (name: NamePath) => string[];
+  isFieldsTouched: (nameList?: NamePath[] | boolean, allFieldsTouched?: boolean) => boolean;
+  isFieldTouched: (name: NamePath) => boolean;
+  isFieldsValidating: (nameList?: NamePath[]) => boolean;
+  isFieldValidating: (name: NamePath) => boolean;
+  resetFields: (nameList?: NamePath[] | InternalNamePath[]) => void;
+  clearValidate: (nameList?: NamePath[] | InternalNamePath[]) => void;
+  setFields: (data: FieldData[]) => void;
+  setFieldValue: (name: NamePath, value: any) => void;
+  setFieldsValue: (values: Record<string, any>) => void;
+  validateFields: (nameList?: NamePath[], options?: ValidateOptions) => Promise<Record<string, any>>;
+  validate: () => Promise<Record<string, any>>;
+  submit: () => void;
+  nativeElement: HTMLFormElement | undefined;
+}
+declare const InternalForm: vue263.DefineSetupFnComponent<FormProps, FormEmits, SlotsType<FormSlots>, FormProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue263.PublicProps>;
+//#endregion
+export { FormEmits, FormInstance, FormItemLayout, FormProps, FormSlots, InternalForm, RequiredMark };