@gct-paas/core-web 0.1.6-dev.9 → 6.0.0-dev.10

package/es/modules/data-rules-container/src/constant/interface.mjs

@@ -1,5 +1,32 @@
 import { t } from "@gct-paas/core";
 //#region src/modules/data-rules-container/src/constant/interface.ts
+/**
+* 搜索类型
+* @alias USER_GROUP  用户组
+* @alias MEMBER      成员
+* @alias ROLE        角色
+* @alias MODEL       模型
+*/
+var SearchTypeEnum = /* @__PURE__ */ function(SearchTypeEnum) {
+	/** 用户组 */
+	SearchTypeEnum["USER_GROUP"] = "USER_GROUP";
+	/** 成员 */
+	SearchTypeEnum["MEMBER"] = "MEMBER";
+	/** 角色 */
+	SearchTypeEnum["ROLE"] = "ROLE";
+	/** 模型 */
+	SearchTypeEnum["MODEL"] = "MODEL";
+	return SearchTypeEnum;
+}({});
+var ModalTypeEnum = /* @__PURE__ */ function(ModalTypeEnum) {
+	/** 新建 */
+	ModalTypeEnum["Create"] = "create";
+	/** 编辑 */
+	ModalTypeEnum["Edit"] = "edit";
+	/** 删除 */
+	ModalTypeEnum["Delete"] = "delete";
+	return ModalTypeEnum;
+}({});
 /** 用户组关联关系 */
 var RelationTypeEnum = /* @__PURE__ */ function(RelationTypeEnum) {
 	/** 部门 */
@@ -16,7 +43,38 @@ var RelationTypeEnum = /* @__PURE__ */ function(RelationTypeEnum) {
 	RelationTypeEnum["PERMISSION_SCOPE"] = "PERMISSION_SCOPE";
 	return RelationTypeEnum;
 }({});
-t("sys.appDesigner.physicalBusinessModel"), RelationTypeEnum.ENTITY_MODEL_DATA, t("sys.appDesigner.builtinConditionalModel"), RelationTypeEnum.BUILT_CONDITION_MODEL, t("sys.appDesigner.permissionScope"), RelationTypeEnum.PERMISSION_SCOPE;
+var DataTypeOptions = [
+	{
+		label: t("sys.appDesigner.physicalBusinessModel"),
+		value: RelationTypeEnum.ENTITY_MODEL_DATA
+	},
+	{
+		label: t("sys.appDesigner.builtinConditionalModel"),
+		value: RelationTypeEnum.BUILT_CONDITION_MODEL
+	},
+	{
+		label: t("sys.appDesigner.permissionScope"),
+		value: RelationTypeEnum.PERMISSION_SCOPE
+	}
+];
+/**
+* 数据权限设置模态框tab枚举
+* @alias TAB_DATA_RULES 数据规则
+* @alias TAB_FIELD_ROLE 字段权限
+* @alias TAB_BUILT_PREM 内置权限
+* @alias TAB_PERM_SCOPE 权限作用域
+*/
+var DataRoleSetTabsEnum = /* @__PURE__ */ function(DataRoleSetTabsEnum) {
+	/** 数据规则 */
+	DataRoleSetTabsEnum["TAB_DATA_RULES"] = "tab_data_rules";
+	/** 字段权限 */
+	DataRoleSetTabsEnum["TAB_FIELD_ROLE"] = "tab_field_role";
+	/** 内置权限 */
+	DataRoleSetTabsEnum["TAB_BUILT_PREM"] = "tab_built_prem";
+	/**  */
+	DataRoleSetTabsEnum["TAB_PERM_SCOPE"] = "tab_perm_scope";
+	return DataRoleSetTabsEnum;
+}({});
 var OperatorTypeEnum = /* @__PURE__ */ function(OperatorTypeEnum) {
 	/** 与 */
 	OperatorTypeEnum["AND"] = "AND";
@@ -32,5 +90,60 @@ var Ch_Perm_Operator = {
 	[OperatorTypeEnum.AND]: t("sys.webRender.allCondition"),
 	[OperatorTypeEnum.OR]: t("sys.webRender.anyCondition")
 };
+/** 获取tree层级 */
+var calcTreeChildLevel = (nodeData) => {
+	if (!nodeData || Array.isArray(nodeData) && nodeData.length === 0) return 0;
+	const res = new Array(nodeData.length).fill(0);
+	nodeData.forEach((v, i) => {
+		res[i] += 1;
+		if (Array.isArray(v.children)) res[i] += v.children.length ? calcTreeChildLevel(v.children) : 1;
+	});
+	return Math.max(...res);
+};
+/** 递归查找是否存在树结构中的值 */
+var findTreePathById = (leafId, nodes) => {
+	for (let i = 0; i < nodes.length; i++) {
+		if (leafId === nodes[i].id) return nodes[i];
+		if (nodes[i].children) {
+			const findResult = findTreePathById(leafId, nodes[i].children);
+			if (findResult) return findResult;
+		}
+	}
+	return null;
+};
+var dropNode = (info, treeList) => {
+	const { dragNode, node } = info;
+	const dragNodeProps = dragNode.dataRef;
+	const nodeProps = node.dataRef;
+	const dropPos = info.node.pos.split("-");
+	const dropLength = Number(dropPos[dropPos.length - 1]);
+	const dropPosition = info.dropPosition - dropLength;
+	const nodeLevel = nodeProps.fullPath.split("/").length - 1;
+	const nodeMenuChildNum = calcTreeChildLevel(findTreePathById(dragNodeProps.id, treeList)?.children);
+	const maxLevel = 5;
+	const params = { id: dragNodeProps.id };
+	if (dropPosition === 0) {
+		console.log("拖拽到目录里");
+		if (nodeLevel + nodeMenuChildNum > maxLevel - 1) return {
+			type: "error",
+			msg: t("sys.webRender.dragError")
+		};
+		Object.assign(params, {
+			targetParentId: nodeProps.id,
+			targetSortNum: 0
+		});
+	} else if (dropPosition !== 0) {
+		console.log("拖拽到目录平级");
+		if (nodeLevel + nodeMenuChildNum > maxLevel) return {
+			type: "error",
+			msg: t("sys.webRender.dragError")
+		};
+		Object.assign(params, {
+			targetParentId: nodeProps.parentId,
+			targetSortNum: nodeProps.sortNum + 1
+		});
+	}
+	return params;
+};
 //#endregion
-export { Ch_Operator, Ch_Perm_Operator, OperatorTypeEnum };
+export { Ch_Operator, Ch_Perm_Operator, DataRoleSetTabsEnum, DataTypeOptions, ModalTypeEnum, OperatorTypeEnum, RelationTypeEnum, SearchTypeEnum, calcTreeChildLevel, dropNode, findTreePathById };

package/es/modules/data-rules-container/src/data-rules-modal.d.ts

@@ -0,0 +1,75 @@
+import { FIELD_TYPE, IModal } from '@gct-paas/core';
+import { PropType } from 'vue';
+/**
+ * 字段条件规则配置模态框
+ */
+export declare const DataRulesModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modal: {
+        type: PropType<IModal>;
+        required: true;
+    };
+    detail: {
+        type: PropType<IObject>;
+        default: () => {
+            dataRule: string;
+            dataRuleConfig: string;
+            dataRuleEnabled: boolean;
+        };
+    };
+    modelKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    excludeValueType: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    excludeOperatorType: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    filterFieldKeys: {
+        type: PropType<FIELD_TYPE[]>;
+    };
+    searchType: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modal: {
+        type: PropType<IModal>;
+        required: true;
+    };
+    detail: {
+        type: PropType<IObject>;
+        default: () => {
+            dataRule: string;
+            dataRuleConfig: string;
+            dataRuleEnabled: boolean;
+        };
+    };
+    modelKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    excludeValueType: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    excludeOperatorType: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    filterFieldKeys: {
+        type: PropType<FIELD_TYPE[]>;
+    };
+    searchType: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    detail: IObject;
+    modelKey: string;
+    excludeValueType: string[];
+    excludeOperatorType: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/es/modules/data-rules-container/src/data-rules-modal.mjs

@@ -0,0 +1,105 @@
+import data_rules_container_default from "./data-rules-container.vue.mjs";
+import { createVNode, defineComponent, provide, ref } from "vue";
+import { FIELD_TYPE, useNamespace } from "@gct-paas/core";
+//#region src/modules/data-rules-container/src/data-rules-modal.tsx
+/**
+* 字段条件规则配置模态框
+*/
+var DataRulesModal = /* @__PURE__ */ defineComponent({
+	name: "DataRulesModal",
+	props: {
+		modal: {
+			type: Object,
+			required: true
+		},
+		detail: {
+			type: Object,
+			default: () => ({
+				dataRule: "",
+				dataRuleConfig: "",
+				dataRuleEnabled: true
+			})
+		},
+		modelKey: {
+			type: String,
+			default: ""
+		},
+		excludeValueType: {
+			type: Array,
+			default: () => []
+		},
+		excludeOperatorType: {
+			type: Array,
+			default: () => []
+		},
+		filterFieldKeys: { type: Object },
+		searchType: {
+			type: Object,
+			required: true
+		}
+	},
+	setup(props) {
+		const ns = useNamespace("data-rules-modal");
+		const dataRulesRef = ref();
+		provide("isDataFilterEditor", true);
+		if (props.modal) props.modal.callback(async () => {
+			const dataRulesRes = dataRulesRef.value.getDataRulesResult();
+			dataRulesRef.value.resetData();
+			return {
+				ok: true,
+				data: [{
+					dataRule: {
+						query: dataRulesRes.query,
+						varKeys: dataRulesRes.varKeys,
+						exp: dataRulesRes.exp,
+						typeMap: dataRulesRes?.typeMap || {}
+					},
+					dataRuleConfig: dataRulesRes.treeStr,
+					dataRuleEnabled: true
+				}]
+			};
+		}, async () => {
+			dataRulesRef.value.resetData();
+			return true;
+		});
+		const list = ref([]);
+		const getConditionField = async (modelKey) => {
+			const result = await _api.apaas.fieldMeta.getListConditionField({ modelKey }) || [];
+			const filterFieldKeys = props.filterFieldKeys || [
+				FIELD_TYPE.TEXT,
+				FIELD_TYPE.LONG_TEXT,
+				FIELD_TYPE.INTEGER,
+				FIELD_TYPE.LONG,
+				FIELD_TYPE.DOUBLE,
+				FIELD_TYPE.DECIMAL,
+				FIELD_TYPE.BOOLEAN,
+				FIELD_TYPE.DATE,
+				FIELD_TYPE.DATE_TIME,
+				FIELD_TYPE.TIME,
+				FIELD_TYPE.ENUM,
+				FIELD_TYPE.ENUM_MULTI,
+				FIELD_TYPE.REF,
+				FIELD_TYPE.REF_MULTI
+			];
+			list.value = result.filter((i) => filterFieldKeys.includes(i.type)).filter((v) => v.createType === "USER_DEFINED" || v.createType === "BUILTIN");
+		};
+		async function onInit() {
+			if (props.modelKey) getConditionField(props.modelKey);
+		}
+		onInit();
+		return () => {
+			return createVNode("div", { "class": ns.b() }, [createVNode(data_rules_container_default, {
+				"ref": dataRulesRef,
+				"fieldList": list.value,
+				"detail": props.detail,
+				"searchType": props.searchType,
+				"isDesign": true,
+				"isPageDesigner": true,
+				"excludeValueType": props.excludeValueType,
+				"excludeOperatorType": props.excludeOperatorType
+			}, null)]);
+		};
+	}
+});
+//#endregion
+export { DataRulesModal };

package/es/modules/data-rules-container/src/hooks/useRole.d.ts

@@ -4,5 +4,4 @@ export declare function useRole(): {
         Update: boolean;
         Delete: boolean;
     }>;
-    inEDHRApp: import('vue').ComputedRef<boolean>;
 };

package/es/modules/data-rules-container/src/typing.d.ts

@@ -26,7 +26,7 @@ export interface TreeProps {
     id: string;
     /** 操作类型 */
     operatorType: string;
-    readonly: boolean;
+    readonly?: boolean;
 }
 export interface IPickerCompParams {
     modelKey?: string;

package/es/modules/gct-dnd/components/gct-dnd-container/gct-dnd-container.mjs

@@ -2,10 +2,11 @@ import { GCT_DND_INSERT_POS } from "../../constants/index.mjs";
 import GctDndItem from "../gct-dnd-item/gct-dnd-item.mjs";
 import { GctDndDropLine } from "../gct-dnd-drop-line/gct-dnd-drop-line.mjs";
 import './gct-dnd-container.css';/* empty css                        */
-import { createVNode, defineComponent, provide, reactive, ref, toRef, watch } from "vue";
+import { createVNode, defineComponent, provide, reactive, ref, watch } from "vue";
 import { cloneDeep } from "lodash-es";
 import { useNamespace } from "@gct-paas/core";
 import { useDrop } from "vue3-dnd";
+import { toRefs as toRefs$1 } from "@vueuse/core";
 //#region src/modules/gct-dnd/components/gct-dnd-container/gct-dnd-container.tsx
 var GctDndContainer = /* @__PURE__ */ defineComponent({
 	name: "GctDndContainer",
@@ -34,7 +35,7 @@ var GctDndContainer = /* @__PURE__ */ defineComponent({
 			isBeforeHover: false
 		});
 		provide("vue3-dnd-drop-line-state", dropLineState);
-		const items = toRef(props.items);
+		const { items } = toRefs$1(props);
 		const [collect, drop] = useDrop({
 			accept: config.group,
 			collect(monitor) {

package/es/modules/gct-form/components/flex-container/flex-container.d.ts

@@ -1,14 +1,10 @@
 import { PropType } from 'vue';
-import { IFlexContainer, IFormGroup } from '../../interface';
+import { IFlexContainer } from '../../interface';
 /**
  * flex 布局容器
  */
 export declare const FlexContainer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     layout: PropType<IFlexContainer>;
-}>, {
-    ns: import('@gct-paas/core').Namespace;
-    getStyle: () => IData;
-    getItemStyle: (model: IFormGroup) => IData;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     layout: PropType<IFlexContainer>;
 }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/es/modules/gct-form/components/flex-container/flex-container.mjs

@@ -1,18 +1,15 @@
 import { FlexItem } from "../flex-item/flex-item.mjs";
 import './flex-container.css';/* empty css                     */
-import { createVNode, defineComponent, isVNode } from "vue";
+import { Fragment, createVNode, defineComponent } from "vue";
 import { useNamespace } from "@gct-paas/core";
 //#region src/modules/gct-form/components/flex-container/flex-container.tsx
 /**
 * flex 布局容器
 */
-function _isSlot(s) {
-	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
-}
 var FlexContainer = /* @__PURE__ */ defineComponent({
 	name: "FlexContainer",
 	props: { layout: Object },
-	setup(props) {
+	setup(props, { slots }) {
 		const ns = useNamespace("flex-container");
 		const getStyle = () => {
 			const style = {};
@@ -35,26 +32,24 @@ var FlexContainer = /* @__PURE__ */ defineComponent({
 			}
 			return style;
 		};
-		return {
-			ns,
-			getStyle,
-			getItemStyle
+		return () => {
+			let items = slots.default?.() || [];
+			if (items.length === 1) {
+				const item = items[0];
+				if (item.type == Fragment) items = item.children || [];
+			}
+			return createVNode("div", {
+				"class": ns.b(),
+				"style": getStyle()
+			}, [items.map((item) => {
+				if (!item) return null;
+				const model = item.props.model.flexItem;
+				return createVNode(FlexItem, {
+					"layout": model,
+					"style": getItemStyle(item.props.model)
+				}, { default: () => item });
+			})]);
 		};
-	},
-	render() {
-		let items = this.$slots.default?.() || [];
-		if (items.length > 0) items = items[0].children || [];
-		return createVNode("div", {
-			"class": this.ns.b(),
-			"style": this.getStyle()
-		}, [items.map((item) => {
-			if (!item) return null;
-			const model = item.props.model.flexItem;
-			return createVNode(FlexItem, {
-				"layout": model,
-				"style": this.getItemStyle(item.props.model)
-			}, _isSlot(item) ? item : { default: () => [item] });
-		})]);
 	}
 });
 //#endregion

package/es/modules/gct-form/components/flex-item/flex-item.mjs

@@ -30,7 +30,7 @@ var FlexItem = /* @__PURE__ */ defineComponent({
 		return createVNode("div", {
 			"class": this.ns.b(),
 			"style": this.getStyle()
-		}, [this.$slots.default?.()]);
+		}, { default: this.$slots.default });
 	}
 });
 //#endregion

package/es/modules/gct-form/components/grid-container/grid-container.mjs

@@ -1,4 +1,4 @@
-import { createVNode, defineComponent, isVNode, resolveComponent } from "vue";
+import { Fragment, createVNode, defineComponent, isVNode, resolveComponent } from "vue";
 import { useNamespace } from "@gct-paas/core";
 //#region src/modules/gct-form/components/grid-container/grid-container.tsx
 function _isSlot(s) {
@@ -16,7 +16,10 @@ var GridContainer = /* @__PURE__ */ defineComponent({
 			let _slot;
 			const l = props.layout || {};
 			let items = slots.default?.() || [];
-			if (items.length > 0) items = items[0].children || [];
+			if (items.length === 1) {
+				const item = items[0];
+				if (item.type == Fragment) items = item.children || [];
+			}
 			return createVNode(resolveComponent("a-row"), {
 				"class": ns.b(),
 				"wrap": true,

package/es/modules/gct-form/controller/editor-item/editor-item.controller.d.ts

@@ -12,4 +12,5 @@ export declare class EditorController<M extends IEditorBasic = IEditorBasic> imp
     model: M;
     options: IObject[];
     constructor(model: M);
+    protected init(): void;
 }

package/es/modules/gct-form/controller/editor-item/editor-item.controller.mjs

@@ -13,6 +13,17 @@ var EditorController = class {
 	options = [];
 	constructor(model) {
 		this.model = model;
+		this.init();
+	}
+	init() {
+		if (this.model.codeList) {
+			if (this.model.codeList.mode === "static" && this.model.codeList.items) this.options = this.model.codeList.items;
+		} else if (this.model.codeTag) {
+			const cfg = _gct.dictionary.getConfig(this.model.codeTag);
+			if (cfg) {
+				if (cfg.mode === "static") this.options = _gct.dictionary.get(this.model.codeTag);
+			}
+		}
 	}
 };
 //#endregion

package/es/modules/gct-form/controller/form-edit-item/form-edit-item.controller.d.ts

@@ -14,11 +14,13 @@ import { FormItemBasicController } from '../form-item-basic/form-item-basic.cont
 export declare abstract class FormEditItemController extends FormItemBasicController implements IFormEditItemController {
     model: IFormEditItem;
     state: IFormEditItemState;
+    private _ignoreChangeOnce;
     get key(): string;
     get value(): any;
     set value(value: any);
     get editorValue(): any;
     set editorValue(v: any);
+    ignoreChangeOnce(): void;
     protected init(): void;
     blur(): void;
     reset(): void;

package/es/modules/gct-form/controller/form-edit-item/form-edit-item.controller.mjs

@@ -15,6 +15,7 @@ import { cloneDeep } from "lodash-es";
 * @implements {IFormEditItemController}
 */
 var FormEditItemController = class extends FormItemBasicController {
+	_ignoreChangeOnce = false;
 	get key() {
 		return this.model.field ?? this.model.name;
 	}
@@ -22,10 +23,14 @@ var FormEditItemController = class extends FormItemBasicController {
 		return getValue(this.key, this.form.state.data);
 	}
 	set value(value) {
-		const data = this.form.state.data;
-		const oldValue = cloneDeep(getValue(this.key, data));
-		setValue(value, this.key, data);
-		this.form.evt.emit("change", this.key, value, oldValue);
+		if (!this._ignoreChangeOnce) {
+			const oldValue = cloneDeep(getValue(this.key, this.form.state.data));
+			setValue(value, this.key, this.form.state.data);
+			this.form.evt.emit("change", this.key, value, oldValue);
+		} else {
+			setValue(value, this.key, this.form.state.data);
+			this._ignoreChangeOnce = false;
+		}
 		this.state.value = value;
 	}
 	get editorValue() {
@@ -40,6 +45,9 @@ var FormEditItemController = class extends FormItemBasicController {
 		});
 		else this.value = v;
 	}
+	ignoreChangeOnce() {
+		this._ignoreChangeOnce = true;
+	}
 	init() {
 		super.init();
 		if (this.model.type !== "hidden") {

package/es/modules/gct-form/controller/form-item-hidden/form-item-hidden.controller.d.ts

@@ -1,5 +1,5 @@
 import { IFormHiddenItem, IFormHiddenItemController, IFormHiddenItemState } from '../../interface';
-import { FormItemBasicController } from '../form-item-basic/form-item-basic.controller';
+import { FormEditItemController } from '../form-edit-item/form-edit-item.controller';
 /**
  * 表单分组控制器
  *
@@ -10,7 +10,7 @@ import { FormItemBasicController } from '../form-item-basic/form-item-basic.cont
  * @extends {FormEditItemController}
  * @implements {IFormGroupController}
  */
-export declare class FormHiddenItemController extends FormItemBasicController implements IFormHiddenItemController {
+export declare class FormHiddenItemController extends FormEditItemController implements IFormHiddenItemController {
     readonly type = "hidden";
     model: IFormHiddenItem;
     state: IFormHiddenItemState;

package/es/modules/gct-form/controller/form-item-hidden/form-item-hidden.controller.mjs

@@ -1,4 +1,4 @@
-import { FormItemBasicController } from "../form-item-basic/form-item-basic.controller.mjs";
+import { FormEditItemController } from "../form-edit-item/form-edit-item.controller.mjs";
 //#region src/modules/gct-form/controller/form-item-hidden/form-item-hidden.controller.ts
 /**
 * 表单分组控制器
@@ -10,7 +10,7 @@ import { FormItemBasicController } from "../form-item-basic/form-item-basic.cont
 * @extends {FormEditItemController}
 * @implements {IFormGroupController}
 */
-var FormHiddenItemController = class extends FormItemBasicController {
+var FormHiddenItemController = class extends FormEditItemController {
 	type = "hidden";
 };
 //#endregion

package/es/modules/gct-form/editor/gct-form-date-range/form-date-range.css

@@ -0,0 +1,67 @@
+@charset "UTF-8";
+/* stylelint-disable scss/no-global-function-names */
+/* bem('block', 'element', 'modifier') => 'ibiz-block__element--modifier' */
+/**
+ * 定义 Block 块
+ * @param {String} $block - Block 块名称
+ * @example
+ *   @include b('button') {
+ *     padding: 10px;
+ *   }
+ */
+/**
+ * 定义 Element 元素
+ * @param {String|List} $element - Element 元素名称，支持单个或多个
+ * @example
+ *   @include b('button') {
+ *     @include e('text') {
+ *       color: #000;
+ *     }
+ *   }
+ *   // 或传入多个元素
+ *   @include b('button') {
+ *     @include e(('text', 'icon')) {
+ *       margin: 5px;
+ *     }
+ *   }
+ */
+/**
+ * 定义 Modifier 修饰符
+ * @param {String|List} $modifier - Modifier 修饰符名称，支持单个或多个
+ * @example
+ *   @include b('button') {
+ *     @include m('primary') {
+ *       background: blue;
+ *     }
+ *   }
+ *   // 或传入多个修饰符
+ *   @include b('button') {
+ *     @include m(('primary', 'large')) {
+ *       background: blue;
+ *       font-size: 16px;
+ *     }
+ *   }
+ */
+/**
+ * 定义状态选择器
+ * @param {String} $state - 状态名称
+ * @example
+ *   @include b('button') {
+ *     @include when('disabled') {
+ *       opacity: 0.5;
+ *     }
+ *   }
+ */
+/**
+ * 深色主题样式
+ * @param {String} $block - Block 块名称
+ * @example
+ *   @include dark('button') {
+ *     background: #333;
+ *     color: #fff;
+ *   }
+ */
+/* stylelint-disable scss/no-global-function-names */
+.gct-gct-form-date-range {
+  width: 100%;
+}