@gct-paas/core-web 0.1.6-dev.3 → 0.1.6-dev.31

package/es/modules/data-rules-container/src/components/perm-action-node.vue_vue_type_script_setup_true_name_perm-action-node_lang.mjs

@@ -0,0 +1,384 @@
+import FieldCascader_default from "../../../../components/field-cascader/src/FieldCascader.vue.mjs";
+import "../../../../components/index.mjs";
+import { useDataRulesTree } from "../hooks/useDataRulesTree.mjs";
+import select_userdep_cmp_default from "./select-userdep-cmp.vue.mjs";
+import request_select_cmp_default from "./request-select-cmp.vue.mjs";
+import request_tree_select_cmp_default from "./request-tree-select-cmp.vue.mjs";
+import ndo_select_cmp_default from "./ndo-select-cmp.vue.mjs";
+import rdo_select_cmp_default from "./rdo-select-cmp.vue.mjs";
+import tree_select_cmp_default from "./tree-select-cmp.vue.mjs";
+import { ComponentTypeEnum, ValueTypeEnum, getCmpConfig } from "../constant/config.mjs";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, nextTick, normalizeClass, openBlock, ref, renderList, resolveComponent, resolveDynamicComponent, toDisplayString, unref, watch, withCtx } from "vue";
+import { isEmpty } from "lodash-es";
+import { FIELD_TYPE, SEARCH_SERVICE, t } from "@gct-paas/core";
+import { DatePicker, Input, Select } from "ant-design-vue";
+import dayjs from "dayjs";
+//#region src/modules/data-rules-container/src/components/perm-action-node.vue?vue&type=script&setup=true&name=perm-action-node&lang.ts
+var _hoisted_1 = { class: "perm-action-node" };
+var _hoisted_2 = {
+	key: 0,
+	class: "mx-4px"
+};
+var _hoisted_3 = {
+	key: 1,
+	style: {
+		"flex": "1",
+		"min-width": "0",
+		"background-color": "#f5f6f7"
+	}
+};
+var _hoisted_4 = { class: "perm-action-node__flex-value" };
+var _hoisted_5 = { class: "perm-action-node__actions" };
+var perm_action_node_vue_vue_type_script_setup_true_name_perm_action_node_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "perm-action-node",
+	props: {
+		data: {},
+		fieldList: {},
+		selectFiledKeys: {},
+		filterType: {},
+		readonly: { type: Boolean },
+		isPageDesigner: { type: Boolean },
+		isAllowClear: { type: Boolean },
+		excludeValueType: {},
+		excludeOperatorType: {},
+		apiConfig: {},
+		modelName: {},
+		cascadeField: { type: Boolean },
+		hasPermScopeError: { type: Boolean }
+	},
+	setup(__props) {
+		const 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
+		];
+		function filterFieldByFunction(field) {
+			return filterFieldKeys.includes(field.type) && (field.createType === "USER_DEFINED" || field.createType === "BUILTIN");
+		}
+		const cmps = {
+			[ComponentTypeEnum.INPUT]: Input,
+			[ComponentTypeEnum.SELECT]: Select,
+			[ComponentTypeEnum.DATEPICKER]: DatePicker,
+			[ComponentTypeEnum.CUSTOM]: select_userdep_cmp_default,
+			[ComponentTypeEnum.REQUEST_SELECT]: request_select_cmp_default,
+			[ComponentTypeEnum.REQUEST_TREE_SELECT]: request_tree_select_cmp_default,
+			[ComponentTypeEnum.NDO_SELECT]: ndo_select_cmp_default,
+			[ComponentTypeEnum.RDO_SELECT]: rdo_select_cmp_default,
+			[ComponentTypeEnum.TREE_SELECT]: tree_select_cmp_default
+		};
+		const dateFormat = {
+			[FIELD_TYPE.DATE]: "YYYY-MM-DD",
+			[FIELD_TYPE.DATE_TIME]: "YYYY-MM-DD HH:mm:ss",
+			[FIELD_TYPE.TIME]: "HH:mm:ss"
+		};
+		const props = __props;
+		const { deleteRow, updateNodeItem } = useDataRulesTree(props.readonly);
+		const configs = ref([]);
+		const varOptions = ref([]);
+		const fieldOptions = ref([]);
+		const isFilterConfig = computed(() => props.filterType === "filterConfig");
+		const isPermScope = computed(() => props.filterType === "permissionScope");
+		const treeId = computed(() => props.data.key);
+		const fieldType = computed(() => props.data.leftValue?.type);
+		const isDate = computed(() => [
+			FIELD_TYPE.DATE,
+			FIELD_TYPE.DATE_TIME,
+			FIELD_TYPE.TIME
+		].includes(fieldType.value));
+		const fields = computed(() => {
+			if (isPermScope.value) return props.fieldList?.map((i) => ({
+				key: i.key,
+				value: i.id,
+				label: i.name,
+				filedInfo: {
+					id: i.id,
+					key: i.key,
+					name: i.name,
+					type: i.type
+				}
+			}));
+			return props.fieldList?.filter((field) => ![
+				FIELD_TYPE.IMAGE,
+				FIELD_TYPE.ATTACHMENT,
+				FIELD_TYPE.MASTERSLAVE
+			].includes(field.type)).map((item) => {
+				return {
+					label: isFilterConfig.value ? `${item.modelName}.${item.name}` : item.name,
+					value: item.id,
+					disabled: false,
+					filedInfo: {
+						id: item.id,
+						key: item.key,
+						name: item.name,
+						type: item.type,
+						bindInfo: item.bindInfo,
+						modelKey: item.modelKey,
+						refModelType: item.refModelType,
+						nodeKey: void 0
+					}
+				};
+			});
+		});
+		const fieldOpts = computed(() => {
+			return fields.value?.filter((i) => i.filedInfo?.type === props.data?.leftValue?.type && i.filedInfo?.key !== props.data?.leftValue?.key);
+		});
+		const permOperatorOpts = computed(() => {
+			return [{
+				label: t(`sys.appDesigner.conditionVisible`),
+				value: fieldType.value === "RDO" ? "defVersionIn" : SEARCH_SERVICE.IN
+			}, {
+				label: t(`sys.appDesigner.conditionInvisible`),
+				value: fieldType.value === "RDO" ? "defVersionNotIn" : SEARCH_SERVICE.NOTIN
+			}];
+		});
+		const value = computed(() => {
+			return props.data?.rightValue?.map((item) => {
+				if (isDate.value) {
+					if (item.result && item.valueType === ValueTypeEnum.FIXED) return dayjs(item.result).format(dateFormat[fieldType.value] || "YYYY-MM-DD");
+				}
+				return item.result;
+			}) || [];
+		});
+		if (isPermScope.value) props.data.operatorValue = fieldType.value === "RDO" ? "defVersionIn" : SEARCH_SERVICE.IN;
+		function handlePageNo(index) {
+			const config = configs.value[index];
+			if (config[config?.typeKeys?.[index]]?.attrs?.apiParams?.pageNo) configs.value[index][configs.value[index].typeKeys[index]].attrs.apiParams.pageNo = configs.value[index][configs.value[index].typeKeys[index]].attrs.apiParams.pageNo + 1;
+		}
+		const getConfig = async (opts) => {
+			configs.value = getCmpConfig({
+				fieldType: fieldType.value,
+				operatorType: opts?.operatorType || props.data?.operatorValue,
+				modelKey: props.data.leftValue?.modelKey,
+				fieldKey: props.data.leftValue?.key,
+				bindInfo: props.data.leftValue?.bindInfo,
+				refModelType: props.data.leftValue?.refModelType,
+				valueType: opts?.valueType || void 0,
+				fieldOptions: (props.isPageDesigner ? fieldOpts.value : fieldOptions.value) ?? [],
+				mainModelKey: void 0,
+				isPageDesigner: props.isPageDesigner,
+				isOnlineFormDesigner: false,
+				varOptions: varOptions.value
+			});
+			configs.value.forEach((config, index) => {
+				const options = config[config?.typeKeys?.[index]]?.attrs?.options || [];
+				options.length && options.forEach((item) => {
+					item.label = t(item.label);
+				});
+				config.valueTypeOptions = config.valueTypeOptions?.filter((e) => !props.excludeValueType?.includes(e.value));
+			});
+		};
+		watch([
+			fieldType.value,
+			() => props.data.leftValue,
+			() => props.data.operatorValue
+		], async () => {
+			if (fieldType.value && props.data.leftValue && props.data.operatorValue) {
+				const params = {};
+				if (isDate.value && props.data?.operatorValue === SEARCH_SERVICE.RANGE && Array.isArray(props.data.rightValue) && props.data.rightValue.length !== 0) {
+					const rightValueItem = props.data.rightValue[0];
+					if (rightValueItem.valueType === ValueTypeEnum.FIXED) Object.assign(params, { valueType: rightValueItem.valueType });
+				}
+				if (props.isPageDesigner && props.data.rightValue?.[0]["valueType"] == "FIELD" && !fieldOpts.value?.length) setTimeout(() => getConfig(params), 200);
+				else getConfig(params);
+			}
+		}, {
+			deep: true,
+			immediate: true
+		});
+		const FieldClick = (value, row) => {
+			if (!value) {
+				handleLeftChange(value, {});
+				return;
+			}
+			const { key, bindInfo, id, modelKey, name, refModelType, type } = row;
+			handleLeftChange(id, { filedInfo: {
+				field_search_key: value,
+				key,
+				bindInfo,
+				id,
+				modelKey,
+				name,
+				refModelType,
+				type
+			} });
+		};
+		const filterOption = (input, option) => {
+			if (option.name) return option.name.includes(input?.trim());
+			return option.label?.includes(input?.trim());
+		};
+		const leftValue = computed(() => {
+			if (!(fields.value?.map((i) => i.value))?.includes(props.data.leftValue?.id)) return props.data.leftValue?.name;
+			return props.data.leftValue?.id;
+		});
+		const handleLeftChange = async (value, option) => {
+			if (value) {
+				updateNodeItem(treeId.value, "leftValue", option.filedInfo);
+				configs.value = [];
+				if (isPermScope.value) {
+					const permOpt = permOperatorOpts.value?.[0];
+					await nextTick();
+					handleOperatorChange(permOpt.value, permOpt);
+				}
+			} else {
+				updateNodeItem(treeId.value, "leftValue", void 0);
+				configs.value = [];
+			}
+		};
+		const handleOperatorChange = (value, _option) => {
+			if (isPermScope.value && !props.data?.leftValue?.key) return;
+			getConfig({
+				operatorType: value,
+				valueType: void 0
+			});
+			const defaultValues = configs.value.map((item) => item.default);
+			updateNodeItem(treeId.value, "operatorValue", value, {
+				key: "valueType",
+				defaultValues
+			});
+		};
+		const handleInputChange = (event, index) => {
+			const valueType = props.data?.rightValue?.[index].valueType;
+			let value;
+			if (isDate.value) if (valueType === ValueTypeEnum.FIXED && !isEmpty(event)) value = dayjs(event).format(dateFormat[fieldType.value]);
+			else value = event;
+			else value = event?.target ? event.target?.value : event;
+			updateNodeItem(treeId.value, "rightValue", value, {
+				index,
+				key: "result"
+			});
+		};
+		const handleDeleteRow = () => {
+			deleteRow(treeId.value);
+		};
+		return (_ctx, _cache) => {
+			const _component_a_select = resolveComponent("a-select");
+			const _component_a_form_item_rest = resolveComponent("a-form-item-rest");
+			const _component_a_input = resolveComponent("a-input");
+			const _component_a_button = resolveComponent("a-button");
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				createVNode(_component_a_form_item_rest, null, {
+					default: withCtx(() => [__props.modelName && __props.cascadeField ? (openBlock(), createBlock(unref(FieldCascader_default), {
+						key: 0,
+						value: __props.data?.leftValue?.field_search_key || __props.data?.leftValue?.key,
+						"filter-field-by-function": filterFieldByFunction,
+						"field-meta-list": __props.fieldList,
+						"model-name": __props.modelName,
+						style: {
+							"flex": "1",
+							"min-width": "0",
+							"margin-right": "12px"
+						},
+						onFieldClick: FieldClick
+					}, null, 8, [
+						"value",
+						"field-meta-list",
+						"model-name"
+					])) : (openBlock(), createBlock(_component_a_select, {
+						key: 1,
+						value: leftValue.value,
+						options: fields.value,
+						disabled: __props.readonly,
+						"allow-clear": __props.isAllowClear,
+						"filter-option": filterOption,
+						placeholder: unref(t)("sys.chooseText"),
+						"show-search": "",
+						style: {
+							"width": "212px",
+							"margin-right": "12px"
+						},
+						class: normalizeClass(["tree-action-select", __props.hasPermScopeError && !leftValue.value ? "is-perm-scope-error" : ""]),
+						onChange: handleLeftChange
+					}, null, 8, [
+						"value",
+						"options",
+						"disabled",
+						"allow-clear",
+						"placeholder",
+						"class"
+					]))]),
+					_: 1
+				}),
+				createVNode(_component_a_form_item_rest, null, {
+					default: withCtx(() => [createVNode(_component_a_select, {
+						class: normalizeClass(__props.readonly ? "tree-action-select" : ""),
+						disabled: __props.readonly || false,
+						placeholder: unref(t)("sys.chooseText"),
+						options: permOperatorOpts.value,
+						value: __props.data?.operatorValue,
+						style: {
+							"width": "120px",
+							"margin-right": "12px"
+						},
+						onChange: handleOperatorChange
+					}, null, 8, [
+						"class",
+						"disabled",
+						"placeholder",
+						"options",
+						"value"
+					])]),
+					_: 1
+				}),
+				Array.isArray(configs.value) && configs.value.length === 0 ? (openBlock(), createBlock(_component_a_form_item_rest, { key: 0 }, {
+					default: withCtx(() => [createVNode(_component_a_input, {
+						disabled: true,
+						placeholder: unref(t)("sys.chooseText"),
+						style: {
+							"flex": "1",
+							"min-width": "0"
+						}
+					}, null, 8, ["placeholder"])]),
+					_: 1
+				})) : createCommentVNode("", true),
+				(openBlock(true), createElementBlock(Fragment, null, renderList(configs.value, (config, index) => {
+					return openBlock(), createElementBlock(Fragment, { key: index }, [configs.value.length > 1 && index === configs.value.length - 1 ? (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(unref(t)("sys.webRender.to")), 1)) : createCommentVNode("", true), config.isHide ? (openBlock(), createElementBlock("div", _hoisted_3)) : (openBlock(), createBlock(_component_a_form_item_rest, { key: 2 }, {
+						default: withCtx(() => [createElementVNode("div", _hoisted_4, [(openBlock(), createBlock(resolveDynamicComponent(cmps[config[__props.data?.rightValue?.[index].valueType]?.cmp]), mergeProps({
+							disabled: __props.readonly,
+							style: { "width": "100%" },
+							placeholder: unref(t)("sys.pleaseSelectSth"),
+							value: value.value[index],
+							bordered: ""
+						}, { ref_for: true }, config[__props.data?.rightValue?.[index].valueType]?.attrs, {
+							"filter-type": __props.filterType,
+							class: [__props.readonly ? "tree-action-select left-border" : "", __props.hasPermScopeError && leftValue.value && (!value.value[index] || !value.value[index]?.length) ? "is-perm-scope-error" : ""],
+							onChange: (event) => handleInputChange(event, index),
+							"onUpdate:pageNo": ($event) => handlePageNo(index)
+						}), null, 16, [
+							"disabled",
+							"placeholder",
+							"value",
+							"filter-type",
+							"class",
+							"onChange",
+							"onUpdate:pageNo"
+						]))])]),
+						_: 2
+					}, 1024))], 64);
+				}), 128)),
+				createElementVNode("div", _hoisted_5, [!__props.readonly && (__props.selectFiledKeys && __props.selectFiledKeys.length > 1 || __props.data.dataLen > 1) ? (openBlock(), createBlock(_component_a_button, {
+					key: 0,
+					type: "link",
+					size: "small",
+					class: "ml-12px perm-action-delete",
+					onClick: handleDeleteRow
+				}, {
+					icon: withCtx(() => [..._cache[0] || (_cache[0] = [createElementVNode("i", { class: "gct-iconfont icon-icon_shanchu" }, null, -1)])]),
+					_: 1
+				})) : createCommentVNode("", true)])
+			]);
+		};
+	}
+});
+//#endregion
+export { perm_action_node_vue_vue_type_script_setup_true_name_perm_action_node_lang_default as default };

package/es/modules/data-rules-container/src/components/perm-action-node.vue_vue_type_style_index_0_scoped_a053095c_lang.css

@@ -0,0 +1,73 @@
+.perm-action-node[data-v-a053095c] {
+  display: flex;
+  align-items: center;
+  width: 100%;
+  min-width: 0;
+}
+.perm-action-node__actions[data-v-a053095c] {
+  display: flex;
+  flex-shrink: 0;
+  align-items: center;
+}
+.perm-action-node__flex-value[data-v-a053095c] {
+  flex: 1 1 0%;
+  min-width: 0;
+}
+.perm-action-node__flex-value[data-v-a053095c] .ant-select,
+.perm-action-node__flex-value[data-v-a053095c] .ant-tree-select {
+  max-width: 100%;
+}
+.perm-action-node[data-v-a053095c] .ant-select.tree-action-select.ant-select-disabled .ant-select-selector {
+  border-color: #fff !important;
+  background: #fff;
+  color: rgba(0, 0, 0, 0.85);
+  cursor: default;
+}
+.perm-action-node[data-v-a053095c] .ant-select.tree-action-select.ant-select-disabled.is-unit .ant-select-selector {
+  color: #3168ec;
+}
+.perm-action-node[data-v-a053095c] .ant-select.tree-action-select.ant-select-disabled.left-border {
+  border-left: 1px solid #e8ebf0 !important;
+}
+.perm-action-node[data-v-a053095c] .ant-select.tree-action-select.ant-select-disabled .ant-select-arrow {
+  display: none;
+}
+.perm-action-node[data-v-a053095c] .ant-input.ant-input-disabled.tree-action-select {
+  border-left: 1px solid #e8ebf0 !important;
+  border-color: #fff !important;
+  background: #fff;
+  color: rgba(0, 0, 0, 0.85);
+  cursor: default;
+}
+.perm-action-node[data-v-a053095c] .ant-picker.tree-action-select.ant-picker-disabled {
+  border-left: 1px solid #e8ebf0 !important;
+  border-color: #fff !important;
+  background: #fff;
+  cursor: default;
+}
+.perm-action-node[data-v-a053095c] .ant-picker.tree-action-select.ant-picker-disabled .ant-picker-input > input {
+  border-color: #fff !important;
+  background: #fff;
+  color: rgba(0, 0, 0, 0.85);
+}
+.perm-action-node .perm-action-delete[data-v-a053095c] {
+  width: 32px;
+  height: 32px;
+  padding: 6px;
+  border-radius: 4px;
+  color: #8b8b8b;
+}
+.perm-action-node .perm-action-delete[data-v-a053095c]:hover {
+  color: #000000;
+  background: #e8eaee;
+}
+.perm-action-node .ant-btn-icon-only.ant-btn-sm[data-v-a053095c] > * {
+  font-size: 18px;
+}
+.perm-action-node[data-v-a053095c] .is-perm-scope-error.ant-select .ant-select-selector {
+  border-color: #f54547;
+}
+[data-v-a053095c] .anticon {
+  color: #797a7d;
+  font-size: 16px;
+}

package/es/modules/data-rules-container/src/components/perm-root-node.vue.d.ts

@@ -0,0 +1,3 @@
+import { TreeProps } from '../typing';
+declare const _default: import('vue').DefineComponent<TreeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/es/modules/data-rules-container/src/components/perm-root-node.vue.mjs

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../../../../_virtual/_plugin-vue_export-helper.mjs";
+import perm_root_node_vue_vue_type_script_setup_true_name_perm_root_node_lang_default from "./perm-root-node.vue_vue_type_script_setup_true_name_perm-root-node_lang.mjs";
+import './perm-root-node.vue_vue_type_style_index_0_scoped_ca5c9d20_lang.css';/* empty css                                                                     */
+//#region src/modules/data-rules-container/src/components/perm-root-node.vue
+var perm_root_node_default = /* @__PURE__ */ _plugin_vue_export_helper_default(perm_root_node_vue_vue_type_script_setup_true_name_perm_root_node_lang_default, [["__scopeId", "data-v-ca5c9d20"]]);
+//#endregion
+export { perm_root_node_default as default };

package/es/modules/data-rules-container/src/components/perm-root-node.vue_vue_type_script_setup_true_name_perm-root-node_lang.mjs

@@ -0,0 +1,61 @@
+import { Ch_Perm_Operator, OperatorTypeEnum } from "../constant/interface.mjs";
+import { useDataRulesTree } from "../hooks/useDataRulesTree.mjs";
+import { Fragment, computed, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, openBlock, renderList, resolveComponent, toDisplayString, withCtx } from "vue";
+import { t } from "@gct-paas/core";
+//#region src/modules/data-rules-container/src/components/perm-root-node.vue?vue&type=script&setup=true&name=perm-root-node&lang.ts
+var _hoisted_1 = { class: "perm-root-node" };
+var perm_root_node_vue_vue_type_script_setup_true_name_perm_root_node_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "perm-root-node",
+	props: {
+		data: {},
+		level: {},
+		id: {},
+		operatorType: {},
+		readonly: { type: Boolean }
+	},
+	setup(__props) {
+		const OperatorOptions = [{
+			label: t(Ch_Perm_Operator[OperatorTypeEnum.AND]),
+			value: OperatorTypeEnum.AND
+		}, {
+			label: t(Ch_Perm_Operator[OperatorTypeEnum.OR]),
+			value: OperatorTypeEnum.OR
+		}];
+		const props = __props;
+		const { updateNodeItem } = useDataRulesTree(props.readonly);
+		const operatorType = computed({
+			get() {
+				return props.operatorType;
+			},
+			set(value) {
+				updateNodeItem(props.id, "operatorType", value);
+			}
+		});
+		return (_ctx, _cache) => {
+			const _component_a_radio_button = resolveComponent("a-radio-button");
+			const _component_a_radio_group = resolveComponent("a-radio-group");
+			const _component_a_form_item_rest = resolveComponent("a-form-item-rest");
+			return openBlock(), createElementBlock("div", _hoisted_1, [createElementVNode("div", null, [createVNode(_component_a_form_item_rest, null, {
+				default: withCtx(() => [createVNode(_component_a_radio_group, {
+					value: operatorType.value,
+					"onUpdate:value": _cache[0] || (_cache[0] = ($event) => operatorType.value = $event),
+					disabled: __props.readonly
+				}, {
+					default: withCtx(() => [(openBlock(), createElementBlock(Fragment, null, renderList(OperatorOptions, (operator) => {
+						return createVNode(_component_a_radio_button, {
+							key: operator.value,
+							value: operator.value
+						}, {
+							default: withCtx(() => [createTextVNode(toDisplayString(operator.label), 1)]),
+							_: 2
+						}, 1032, ["value"]);
+					}), 64))]),
+					_: 1
+				}, 8, ["value", "disabled"])]),
+				_: 1
+			})])]);
+		};
+	}
+});
+//#endregion
+export { perm_root_node_vue_vue_type_script_setup_true_name_perm_root_node_lang_default as default };

package/es/modules/data-rules-container/src/components/perm-root-node.vue_vue_type_style_index_0_scoped_ca5c9d20_lang.css

@@ -0,0 +1,74 @@
+.perm-root-node[data-v-ca5c9d20] {
+  display: flex;
+  justify-content: space-between;
+}
+.perm-root-node .ant-btn[data-v-ca5c9d20] {
+  line-height: 22px;
+}
+.perm-root-node .ant-btn .iconfont[data-v-ca5c9d20] {
+  font-size: 14px;
+}
+.ant-radio-button-wrapper-checked[data-v-ca5c9d20] {
+  background-color: rgba(from var(--ant-primary-color) r g b / 8%);
+}
+[data-v-ca5c9d20] .ant-select.perm-root-node-select.ant-select-disabled .ant-select-selector {
+  border-color: #fff !important;
+  background: #e6eeff;
+  color: #3168ec;
+  cursor: default;
+}
+[data-v-ca5c9d20] .ant-select.perm-root-node-select.ant-select-disabled .ant-select-selector .ant-select-selection-item {
+  padding-right: 0;
+}
+.perm-root-node-add-row[data-v-ca5c9d20] {
+  color: var(--ant-primary-color);
+  cursor: pointer;
+}
+[data-v-ca5c9d20] .ant-select-selector {
+  border: none !important;
+  background-color: var(--ant-primary-1) !important;
+  color: var(--ant-primary-color) !important;
+}
+[data-v-ca5c9d20] .ant-select-arrow {
+  color: var(--ant-primary-color) !important;
+}
+[data-v-ca5c9d20] .ant-radio-group {
+  border-radius: 6px;
+  border: 1px solid #e8ebf0;
+  background-color: #e8ebf0;
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper {
+  border-color: #e8ebf0;
+  color: #5a5f6b;
+  padding: 0 24px;
+  font-weight: 400;
+  background-color: transparent;
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper:first-child {
+  border-radius: 4px;
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper:last-child {
+  border-radius: 4px;
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper:hover {
+  color: #5a5f6b;
+  background-color: #f5f6f8;
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper.ant-radio-button-wrapper-checked {
+  color: #1a1d23;
+  background-color: #fff;
+  font-weight: 500;
+  box-shadow: 0px 2px 4px 0px rgba(0, 0, 0, 0.1);
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper-checked.ant-radio-button-wrapper:first-child {
+  border-right-color: #e8ebf0;
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper:not(:first-child):before {
+  width: 2px;
+  background-color: #e8ebf0;
+}
+[data-v-ca5c9d20] .ant-radio-group .ant-radio-button-wrapper-checked:not(
+      .ant-radio-button-wrapper-disabled
+    ):focus-within {
+  box-shadow: 0px 2px 4px 0px rgba(0, 0, 0, 0.1);
+}

package/es/modules/data-rules-container/src/components/rdo-select-cmp.vue.d.ts

@@ -0,0 +1,11 @@
+import { ApiParams } from '../typing';
+type __VLS_Props = {
+    value?: string[];
+    apiParams: ApiParams;
+    /** 是否选中父级实际选中默认子版本 */
+    parentToDefault?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    parentToDefault: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/modules/data-rules-container/src/components/rdo-select-cmp.vue.mjs

@@ -0,0 +1,5 @@
+import rdo_select_cmp_vue_vue_type_script_setup_true_lang_default from "./rdo-select-cmp.vue_vue_type_script_setup_true_lang.mjs";
+//#region src/modules/data-rules-container/src/components/rdo-select-cmp.vue
+var rdo_select_cmp_default = rdo_select_cmp_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { rdo_select_cmp_default as default };