@koi-design/uxd-ui 12.1.36-beta.0

package/lib/components/Cascader/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('../../utils/install.js');
+var Cascader = require('./Cascader.js');
+var Cascader_type = require('./Cascader.type.js');
+
+const UCascader = install.withInstall(Cascader["default"]);
+
+exports.cascaderEmits = Cascader_type.cascaderEmits;
+exports.cascaderProps = Cascader_type.cascaderProps;
+exports.isCascaderSingleValue = Cascader_type.isCascaderSingleValue;
+exports.isCascaderUnitValue = Cascader_type.isCascaderUnitValue;
+exports.UCascader = UCascader;
+exports["default"] = UCascader;
+//# sourceMappingURL=index.js.map

package/lib/components/Cascader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/components/Cascader/index.ts"],"sourcesContent":["import { withInstall } from '../../utils/install';\nimport Cascader from './Cascader';\n\nexport const UCascader = withInstall(Cascader);\nexport default UCascader;\n\nexport * from './Cascader.type';\n"],"names":["withInstall","Cascader"],"mappings":";;;;;;;;MAGa,YAAYA,oBAAYC,mBAAQ;;;;;;;;;"}

package/lib/components/Cascader/style/index.d.ts

@@ -0,0 +1 @@
+import '@koi-design/uxd-ui/styles/components/cascader/index.less';

package/lib/components/Cascader/style/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+require('@koi-design/uxd-ui/styles/components/cascader/index.less');
+
+//# sourceMappingURL=index.js.map

package/lib/components/Cascader/style/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/lib/components/Cascader/utils.d.ts

@@ -0,0 +1,14 @@
+import type { CascaderOption, CascaderProps, FieldNamesMap, CascaderSearchConfig, CascaderSearchObject, CascaderSearchRender, CascaderInnerValueType, CascaderSingleValueType } from './Cascader.type';
+export declare function getFilledFieldNames({ fieldNames }: {
+    fieldNames: FieldNamesMap;
+}): FieldNamesMap;
+export declare function flattenTree(options: CascaderOption[], props: CascaderProps, ancestor?: CascaderOption[]): CascaderOption[][];
+export declare function highlightText(str: string, keyWord: string, cls: string): (string | (string | import("vue/jsx-runtime").JSX.Element)[])[];
+export declare const defaultFilteredRenderer: CascaderSearchRender;
+export declare function getSearchOptions(searchOptions: CascaderSearchConfig | undefined): CascaderSearchObject;
+export declare function getValueIndex(values: (string | number)[], level: number, options: CascaderOption[], showSearch: boolean, names: FieldNamesMap): number;
+export declare function filterTree<T>(tree: T[], filterFn: (n: T) => boolean, childrenName?: string, parents?: T[]): (T & {
+    parents: T[];
+})[];
+export declare function arrayTreeFilter<T>(tree: T[], filterFn: (n: T, lv: number) => boolean, childrenName?: string, level?: number): T[];
+export declare function getAllChildrenValues(_opt: CascaderOption, _path: CascaderSingleValueType, nameMap: FieldNamesMap): CascaderInnerValueType;

package/lib/components/Cascader/utils.js

@@ -0,0 +1,126 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+function getFilledFieldNames({
+  fieldNames
+}) {
+  const names = {
+    children: fieldNames.children || "children",
+    label: fieldNames.label || "label",
+    value: fieldNames.value || "value"
+  };
+  return names;
+}
+function flattenTree(options, props, ancestor = []) {
+  const names = getFilledFieldNames(props);
+  let flattenOptions = [];
+  const childrenName = names.children;
+  options.forEach((option) => {
+    const path = ancestor.concat(option);
+    if (props.changeOnSelect && !props.multiple) {
+      flattenOptions.push(path);
+    } else if ((!option[childrenName] || !option[childrenName].length) && option.isLeaf !== false) {
+      flattenOptions.push(path);
+    }
+    if (option[childrenName]) {
+      flattenOptions = flattenOptions.concat(flattenTree(option[childrenName], props, path));
+    }
+  });
+  return flattenOptions;
+}
+function highlightText(str, keyWord, cls) {
+  return str.split(keyWord).map((node, index) => index === 0 ? node : [vue.createVNode("span", {
+    "class": cls
+  }, [keyWord]), node]);
+}
+const defaultFilteredRenderer = ({
+  labels,
+  keyword,
+  className
+}) => {
+  const nodes = labels.map((lable, idx) => {
+    const node = lable.indexOf(keyword) > -1 ? highlightText(lable, keyword, `${className}-menu-item-keyword`) : lable;
+    return idx === 0 ? node : [" / ", node];
+  });
+  return vue.createVNode("span", null, [nodes]);
+};
+function getSearchOptions(searchOptions) {
+  const options = typeof searchOptions === "boolean" || !searchOptions ? {} : searchOptions;
+  return {
+    filter: options.filter || ((inputValue, path, names) => {
+      return path.some((option) => option[names.label].indexOf(inputValue) !== -1);
+    }),
+    limit: options.limit || 50,
+    matchInputWidth: typeof options.matchInputWidth === "boolean" ? options.matchInputWidth : true,
+    sort: options.sort || ((a, b, inputValue, names) => {
+      const cb = (item) => {
+        return item[names.label].indexOf(inputValue) > -1;
+      };
+      return a.findIndex(cb) - b.findIndex(cb);
+    }),
+    render: options.render || defaultFilteredRenderer
+  };
+}
+function getValueIndex(values, level, options, showSearch, names) {
+  if (showSearch) {
+    return options.findIndex((opts) => opts[names.value].join("") === values.join(""));
+  }
+  return options.map((c) => c[names.value]).indexOf(values[level]);
+}
+function filterTree(tree, filterFn, childrenName = "children", parents = []) {
+  return tree.reduce((result, node) => {
+    if (filterFn(node)) {
+      const item = {
+        parents,
+        ...node
+      };
+      result.push(item);
+    }
+    if (node[childrenName]) {
+      const _parents = [...parents, node];
+      result.push(...filterTree(node[childrenName], filterFn, childrenName, _parents));
+    }
+    return result;
+  }, []);
+}
+function arrayTreeFilter(tree, filterFn, childrenName = "children", level = 0) {
+  return tree.reduce((result, node) => {
+    if (filterFn(node, level)) {
+      result.push(node);
+      if (node[childrenName]) {
+        const children = arrayTreeFilter(node[childrenName], filterFn, childrenName, level + 1);
+        result.push(...children);
+      }
+    }
+    return result;
+  }, []);
+}
+function getAllChildrenValues(_opt, _path, nameMap) {
+  if (_opt[nameMap.children]) {
+    const rst = [];
+    _opt[nameMap.children].forEach((c) => {
+      const path = [..._path, c[nameMap.value]];
+      if (c[nameMap.children] && c[nameMap.children].length) {
+        rst.push(...getAllChildrenValues(c, path, nameMap));
+      } else if (c.isLeaf !== false) {
+        rst.push(path);
+      }
+    });
+    return rst;
+  }
+  return [];
+}
+
+exports.arrayTreeFilter = arrayTreeFilter;
+exports.defaultFilteredRenderer = defaultFilteredRenderer;
+exports.filterTree = filterTree;
+exports.flattenTree = flattenTree;
+exports.getAllChildrenValues = getAllChildrenValues;
+exports.getFilledFieldNames = getFilledFieldNames;
+exports.getSearchOptions = getSearchOptions;
+exports.getValueIndex = getValueIndex;
+exports.highlightText = highlightText;
+//# sourceMappingURL=utils.js.map

package/lib/components/Cascader/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../src/components/Cascader/utils.tsx"],"sourcesContent":["import type {\n  CascaderOption,\n  CascaderProps,\n  FieldNamesMap,\n  CascaderSearchConfig,\n  CascaderSearchObject,\n  CascaderSearchRender,\n  CascaderInnerValueType,\n  CascaderSingleValueType\n} from './Cascader.type';\n\n/**\n * @param {object} fieldNames\n * @return {*}\n * @description: get field names\n */\nexport function getFilledFieldNames({ fieldNames }: { fieldNames: FieldNamesMap }): FieldNamesMap {\n  const names = {\n    children: fieldNames.children || 'children',\n    label: fieldNames.label || 'label',\n    value: fieldNames.value || 'value'\n  };\n  return names;\n}\n\nexport function flattenTree(options: CascaderOption[], props: CascaderProps, ancestor: CascaderOption[] = []) {\n  const names = getFilledFieldNames(props);\n  let flattenOptions: CascaderOption[][] = [];\n  const childrenName = names.children;\n  options.forEach((option) => {\n    const path = ancestor.concat(option);\n    if (props.changeOnSelect && !props.multiple) {\n      flattenOptions.push(path);\n    } else if ((!option[childrenName] || !(option[childrenName] as CascaderOption[]).length) && option.isLeaf !== false) {\n      flattenOptions.push(path);\n    }\n    if (option[childrenName]) {\n      flattenOptions = flattenOptions.concat(flattenTree(option[childrenName], props, path));\n    }\n  });\n  return flattenOptions;\n}\n\n/**\n * @param {string} str full text\n * @param {string} keyWord key word\n * @param {string} cls highlight class name\n * @return {array}\n * @description: highlight keyword\n */\nexport function highlightText(str: string, keyWord: string, cls: string) {\n  return str.split(keyWord).map((node, index) => (index === 0 ? node : [<span class={cls}>{keyWord}</span>, node]));\n}\n\n/**\n * @param {array} lables\n * @param {string} keyWord\n * @param {string} className\n * @return {HTMLElement}\n * @description: render filtered lables\n */\nexport const defaultFilteredRenderer: CascaderSearchRender = ({ labels, keyword, className }) => {\n  const nodes = labels.map((lable, idx) => {\n    const node = lable.indexOf(keyword) > -1 ? highlightText(lable, keyword, `${className}-menu-item-keyword`) : lable;\n    return idx === 0 ? node : [' / ', node];\n  });\n  return <span>{nodes}</span>;\n};\n\n/**\n * @param {boolean | undefined | object} searchOptions\n * @return {*}\n * @description: get search options\n */\nexport function getSearchOptions(searchOptions: CascaderSearchConfig | undefined): CascaderSearchObject {\n  const options = typeof searchOptions === 'boolean' || !searchOptions ? ({} as CascaderSearchObject) : searchOptions;\n  return {\n    filter:\n      options.filter ||\n      ((inputValue: string, path: CascaderOption[], names: FieldNamesMap) => {\n        return path.some((option) => option[names.label].indexOf(inputValue) !== -1);\n      }),\n    limit: options.limit || 50,\n    matchInputWidth: typeof options.matchInputWidth === 'boolean' ? options.matchInputWidth : true,\n    sort:\n      options.sort ||\n      ((a, b, inputValue, names) => {\n        const cb = (item: CascaderOption) => {\n          return item[names.label].indexOf(inputValue) > -1;\n        };\n        return a.findIndex(cb) - b.findIndex(cb);\n      }),\n    render: options.render || defaultFilteredRenderer\n  };\n}\n\n/**\n * @param {string[]} values current active value\n * @param {number} level current show level\n * @param {array} options current show options\n * @param {boolean} showSearch show search options or not\n * @param {object} names object with keys\n * @return {*}\n * @description: get current value index\n */\nexport function getValueIndex(values: (string | number)[], level: number, options: CascaderOption[], showSearch: boolean, names: FieldNamesMap) {\n  if (showSearch) {\n    return options.findIndex((opts) => opts[names.value].join('') === values.join(''));\n  }\n  return options.map((c) => c[names.value]).indexOf(values[level]);\n}\n\nexport function filterTree<T>(tree: T[], filterFn: (n: T) => boolean, childrenName = 'children', parents: T[] = []) {\n  return tree.reduce((result, node: T) => {\n    if (filterFn(node)) {\n      const item = { parents, ...node };\n      result.push(item);\n    }\n    if (node[childrenName]) {\n      const _parents = [...parents, node];\n      result.push(...filterTree<T>(node[childrenName] as Array<T>, filterFn, childrenName, _parents));\n    }\n    return result;\n  }, [] as Array<T & { parents: T[] }>);\n}\n\nexport function arrayTreeFilter<T>(tree: T[], filterFn: (n: T, lv: number) => boolean, childrenName = 'children', level = 0) {\n  return tree.reduce((result, node: T) => {\n    if (filterFn(node, level)) {\n      result.push(node);\n      if (node[childrenName]) {\n        const children = arrayTreeFilter<T>(node[childrenName] as Array<T>, filterFn, childrenName, level + 1);\n        result.push(...children);\n      }\n    }\n    return result;\n  }, [] as Array<T>);\n}\n\nexport function getAllChildrenValues(_opt: CascaderOption, _path: CascaderSingleValueType, nameMap: FieldNamesMap) {\n  if (_opt[nameMap.children]) {\n    const rst = [] as CascaderInnerValueType;\n    (_opt[nameMap.children] as CascaderOption[]).forEach((c) => {\n      const path = [..._path, c[nameMap.value]];\n      if (c[nameMap.children] && c[nameMap.children].length) {\n        rst.push(...getAllChildrenValues(c, path, nameMap));\n      } else if (c.isLeaf !== false) {\n        rst.push(path);\n      }\n    });\n    return rst;\n  }\n  return [] as CascaderInnerValueType;\n}\n"],"names":["getFilledFieldNames","fieldNames","names","children","label","value","flattenTree","options","props","ancestor","flattenOptions","childrenName","forEach","option","path","concat","changeOnSelect","multiple","push","length","isLeaf","highlightText","str","keyWord","cls","split","map","node","index","_createVNode","defaultFilteredRenderer","labels","keyword","className","nodes","lable","idx","indexOf","getSearchOptions","searchOptions","filter","inputValue","some","limit","matchInputWidth","sort","a","b","cb","item","findIndex","render","getValueIndex","values","level","showSearch","opts","join","c","filterTree","tree","filterFn","parents","reduce","result","_parents","arrayTreeFilter","getAllChildrenValues","_opt","_path","nameMap","rst"],"mappings":"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"}

package/lib/components/Checkbox/Checkbox.js

@@ -0,0 +1,192 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var uxdIcon = require('@koi-design/uxd-icon');
+var index = require('../Icon/index.js');
+var useGlobalConfig = require('../base/hooks/useGlobalConfig.js');
+require('../Form/index.js');
+var isValid = require('../../utils/isValid.js');
+var Checkbox_type = require('./Checkbox.type.js');
+var pluginVue_exportHelper = require('../../_virtual/plugin-vue_export-helper.js');
+var utils = require('../Form/utils.js');
+
+const _sfc_main = vue.defineComponent({
+  name: "UCheckbox",
+  components: {
+    UIcon: index.UIcon,
+    USolidCheck: uxdIcon.USolidCheck,
+    USolidRemove: uxdIcon.USolidRemove
+  },
+  props: Checkbox_type.checkboxProps,
+  emits: Checkbox_type.checkboxEmits,
+  setup(props, { emit, slots }) {
+    const { prefixCls } = useGlobalConfig["default"]("checkbox");
+    const checkboxGroupContext = vue.inject("checkboxGroupContext", {});
+    const focusWrap = vue.ref(false);
+    const focusInner = vue.ref(false);
+    const stateValue = vue.ref(props.modelValue || false);
+    const showSlot = vue.computed(() => {
+      return !!props.value || slots.default;
+    });
+    const computedChecked = vue.computed(() => {
+      if (checkboxGroupContext.stateValue) {
+        return checkboxGroupContext.stateValue.value.includes(props.value);
+      }
+      return !!stateValue.value;
+    });
+    const computedSize = vue.computed(() => {
+      if (checkboxGroupContext.size) {
+        return checkboxGroupContext.size.value || props.size;
+      }
+      return props.size;
+    });
+    const computedDisabled = vue.computed(() => {
+      if (checkboxGroupContext.disabled) {
+        return checkboxGroupContext.disabled.value || props.disabled;
+      }
+      return props.disabled;
+    });
+    const computedColor = vue.computed(() => {
+      if (checkboxGroupContext.color) {
+        return checkboxGroupContext.color.value || props.color;
+      }
+      return props.color;
+    });
+    vue.watch(
+      () => props.modelValue,
+      (nv) => {
+        stateValue.value = nv === props.trueValue;
+      },
+      { immediate: true }
+    );
+    let eventShiftKey = false;
+    const onClick = (e) => {
+      eventShiftKey = e.shiftKey;
+    };
+    const { onFieldChange } = vue.inject(utils.FormItemKey, {});
+    const change = (event) => {
+      if (props.disabled) {
+        return false;
+      }
+      if (checkboxGroupContext.change) {
+        if (isValid.isValid(props.value)) {
+          checkboxGroupContext.change({
+            value: props.value,
+            checked: event.target.checked
+          });
+        }
+      } else {
+        const value = event.target.checked ? props.trueValue : props.falseValue;
+        if (props.modelValue === void 0) {
+          stateValue.value = event.target.checked;
+        }
+        event.shiftKey = eventShiftKey;
+        emit("update:modelValue", value);
+        emit("change", value, event);
+        if (onFieldChange) {
+          onFieldChange(value);
+        }
+      }
+    };
+    const handleKeyDown = (e) => {
+      if (e.code === "Space" || e.code === "Enter") {
+        change(e);
+      }
+    };
+    const handleFocus = () => {
+      var _a;
+      if ((_a = checkboxGroupContext.buttonType) == null ? void 0 : _a.value) {
+        focusWrap.value = true;
+      }
+      focusInner.value = true;
+    };
+    const handleBlur = () => {
+      focusWrap.value = false;
+      focusInner.value = false;
+    };
+    return {
+      prefixCls,
+      computedSize,
+      computedDisabled,
+      computedColor,
+      focusWrap,
+      focusInner,
+      showSlot,
+      computedChecked,
+      change,
+      handleKeyDown,
+      handleFocus,
+      handleBlur,
+      onClick
+    };
+  }
+});
+const _hoisted_1 = ["data-color"];
+const _hoisted_2 = ["disabled", "checked", "name"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_USolidCheck = vue.resolveComponent("USolidCheck");
+  const _component_USolidRemove = vue.resolveComponent("USolidRemove");
+  const _component_UIcon = vue.resolveComponent("UIcon");
+  return vue.openBlock(), vue.createElementBlock("label", {
+    class: vue.normalizeClass([
+      `${_ctx.prefixCls}-wrap`,
+      {
+        [`${_ctx.prefixCls}-wrap-checked`]: _ctx.computedChecked,
+        [`${_ctx.prefixCls}-wrap-indeterminate`]: _ctx.indeterminate,
+        [`${_ctx.prefixCls}-wrap-disabled`]: _ctx.computedDisabled,
+        [`${_ctx.prefixCls}-${_ctx.computedSize}`]: _ctx.computedSize,
+        [`${_ctx.prefixCls}-border`]: _ctx.border,
+        [`${_ctx.prefixCls}-focus`]: _ctx.focusWrap
+      }
+    ]),
+    "data-color": _ctx.computedColor
+  }, [
+    vue.createElementVNode("span", {
+      class: vue.normalizeClass([
+        _ctx.prefixCls,
+        {
+          [`${_ctx.prefixCls}-checked`]: _ctx.computedChecked,
+          [`${_ctx.prefixCls}-disabled`]: _ctx.computedDisabled,
+          [`${_ctx.prefixCls}-indeterminate`]: _ctx.indeterminate
+        }
+      ])
+    }, [
+      vue.createElementVNode("span", {
+        class: vue.normalizeClass([`${_ctx.prefixCls}-inner`, { [`${_ctx.prefixCls}-focus`]: _ctx.focusInner }])
+      }, [
+        vue.createVNode(_component_UIcon, null, {
+          default: vue.withCtx(() => [
+            _ctx.computedChecked ? (vue.openBlock(), vue.createBlock(_component_USolidCheck, { key: 0 })) : _ctx.indeterminate ? (vue.openBlock(), vue.createBlock(_component_USolidRemove, { key: 1 })) : vue.createCommentVNode("v-if", true)
+          ]),
+          _: 1
+        })
+      ], 2),
+      vue.createElementVNode("input", {
+        type: "checkbox",
+        class: vue.normalizeClass(`${_ctx.prefixCls}-input`),
+        disabled: _ctx.computedDisabled,
+        checked: _ctx.computedChecked,
+        name: _ctx.name,
+        onKeydown: _cache[0] || (_cache[0] = (...args) => _ctx.handleKeyDown && _ctx.handleKeyDown(...args)),
+        onChange: _cache[1] || (_cache[1] = (...args) => _ctx.change && _ctx.change(...args)),
+        onClick: _cache[2] || (_cache[2] = (...args) => _ctx.onClick && _ctx.onClick(...args)),
+        onFocus: _cache[3] || (_cache[3] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
+        onBlur: _cache[4] || (_cache[4] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args))
+      }, null, 42, _hoisted_2)
+    ], 2),
+    _ctx.showSlot ? (vue.openBlock(), vue.createElementBlock("span", {
+      key: 0,
+      class: vue.normalizeClass([`${_ctx.prefixCls}-label`])
+    }, [
+      vue.renderSlot(_ctx.$slots, "default", {}, () => [
+        vue.createTextVNode(vue.toDisplayString(_ctx.value), 1)
+      ])
+    ], 2)) : vue.createCommentVNode("v-if", true)
+  ], 10, _hoisted_1);
+}
+var Checkbox = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["render", _sfc_render], ["__file", "E:\\br-fe\\uxd-ui\\src\\components\\Checkbox\\Checkbox.vue"]]);
+
+exports["default"] = Checkbox;
+//# sourceMappingURL=Checkbox.js.map

package/lib/components/Checkbox/Checkbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkbox.js","sources":["../../../../src/components/Checkbox/Checkbox.vue"],"sourcesContent":["<template>\n  <label\n    :class=\"[\n      `${prefixCls}-wrap`,\n      {\n        [`${prefixCls}-wrap-checked`]: computedChecked,\n        [`${prefixCls}-wrap-indeterminate`]: indeterminate,\n        [`${prefixCls}-wrap-disabled`]: computedDisabled,\n        [`${prefixCls}-${computedSize}`]: computedSize,\n        [`${prefixCls}-border`]: border,\n        [`${prefixCls}-focus`]: focusWrap\n      }\n    ]\"\n    :data-color=\"computedColor\"\n  >\n    <span\n      :class=\"[\n        prefixCls,\n        {\n          [`${prefixCls}-checked`]: computedChecked,\n          [`${prefixCls}-disabled`]: computedDisabled,\n          [`${prefixCls}-indeterminate`]: indeterminate\n        }\n      ]\"\n    >\n      <span :class=\"[`${prefixCls}-inner`, { [`${prefixCls}-focus`]: focusInner }]\">\n        <UIcon>\n          <USolidCheck v-if=\"computedChecked\" />\n          <USolidRemove v-else-if=\"indeterminate\" />\n        </UIcon>\n      </span>\n      <input\n        type=\"checkbox\"\n        :class=\"`${prefixCls}-input`\"\n        :disabled=\"computedDisabled\"\n        :checked=\"computedChecked\"\n        :name=\"name\"\n        @keydown=\"handleKeyDown\"\n        @change=\"change\"\n        @click=\"onClick\"\n        @focus=\"handleFocus\"\n        @blur=\"handleBlur\"\n      />\n    </span>\n\n    <span v-if=\"showSlot\" :class=\"[`${prefixCls}-label`]\">\n      <slot>{{ value }}</slot>\n    </span>\n  </label>\n</template>\n\n<script lang=\"ts\">\nimport { defineComponent, inject, computed, ref, watch } from 'vue';\nimport { USolidCheck, USolidRemove } from '@koi-design/uxd-icon';\nimport UIcon from '@uxd-ui/components/Icon';\nimport useGlobalConfig from '../base/hooks/useGlobalConfig';\nimport { FormItemKey } from '../Form';\nimport { isValid } from '../../utils/isValid';\nimport type { FormItemContext } from '../Form/Form.type';\nimport { checkboxProps, checkboxEmits, type CheckboxGroupContext } from './Checkbox.type';\n\nexport default defineComponent({\n  name: 'UCheckbox',\n  components: {\n    UIcon,\n    USolidCheck,\n    USolidRemove\n  },\n  props: checkboxProps,\n  emits: checkboxEmits,\n  setup(props, { emit, slots }) {\n    // prefixCls\n    const { prefixCls } = useGlobalConfig('checkbox');\n    const checkboxGroupContext = inject<CheckboxGroupContext>('checkboxGroupContext', {} as CheckboxGroupContext);\n    // data\n    const focusWrap = ref(false);\n    const focusInner = ref(false);\n    const stateValue = ref(props.modelValue || false);\n    // computed\n    const showSlot = computed(() => {\n      return !!props.value || slots.default;\n    });\n    const computedChecked = computed(() => {\n      if (checkboxGroupContext.stateValue) {\n        return checkboxGroupContext.stateValue.value.includes(props.value);\n      }\n      return !!stateValue.value;\n    });\n    const computedSize = computed(() => {\n      if (checkboxGroupContext.size) {\n        return checkboxGroupContext.size.value || props.size;\n      }\n      return props.size;\n    });\n    const computedDisabled = computed(() => {\n      if (checkboxGroupContext.disabled) {\n        return checkboxGroupContext.disabled.value || props.disabled;\n      }\n      return props.disabled;\n    });\n    const computedColor = computed(() => {\n      if (checkboxGroupContext.color) {\n        return checkboxGroupContext.color.value || props.color;\n      }\n      return props.color;\n    });\n    // const showInput = computed(() => !checkboxGroupContext.buttonType?.value);\n    // watch\n    watch(\n      () => props.modelValue,\n      (nv) => {\n        stateValue.value = nv === props.trueValue;\n      },\n      { immediate: true }\n    );\n    // methods\n    let eventShiftKey = false;\n    const onClick = (e: MouseEvent) => {\n      eventShiftKey = e.shiftKey;\n    };\n\n    const { onFieldChange } = inject<FormItemContext>(FormItemKey, {} as FormItemContext);\n    const change = (event: any) => {\n      if (props.disabled) {\n        return false;\n      }\n      if (checkboxGroupContext.change) {\n        if (isValid(props.value)) {\n          checkboxGroupContext.change({\n            value: props.value,\n            checked: event.target.checked\n          });\n        }\n      } else {\n        const value = event.target.checked ? props.trueValue : props.falseValue;\n        if (props.modelValue === undefined) {\n          stateValue.value = event.target.checked;\n        }\n        event.shiftKey = eventShiftKey;\n        emit('update:modelValue', value);\n        emit('change', value, event);\n        if (onFieldChange) {\n          onFieldChange(value);\n        }\n      }\n    };\n    const handleKeyDown = (e: KeyboardEvent) => {\n      if (e.code === 'Space' || e.code === 'Enter') {\n        change(e);\n      }\n    };\n    const handleFocus = () => {\n      if (checkboxGroupContext.buttonType?.value) {\n        focusWrap.value = true;\n      }\n      focusInner.value = true;\n    };\n    const handleBlur = () => {\n      focusWrap.value = false;\n      focusInner.value = false;\n    };\n\n    return {\n      prefixCls,\n      computedSize,\n      computedDisabled,\n      computedColor,\n      focusWrap,\n      focusInner,\n      showSlot,\n      computedChecked,\n      change,\n      handleKeyDown,\n      handleFocus,\n      handleBlur,\n      onClick\n    };\n  }\n});\n</script>\n\n<style></style>\n"],"names":["defineComponent","UIcon","USolidCheck","USolidRemove","checkboxProps","checkboxEmits","useGlobalConfig","inject","ref","computed","FormItemKey","isValid","_createElementBlock","_normalizeClass","_createElementVNode","_createVNode","_createBlock","_renderSlot"],"mappings":"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"}

package/lib/components/Checkbox/Checkbox.type.d.ts

@@ -0,0 +1,131 @@
+import type { ExtractPropTypes, PropType, Ref } from 'vue';
+import type { NormalSizeMap, ColorType } from '../../utils/globalType';
+import type Checkbox from './Checkbox.vue';
+import type CheckboxGroup from './CheckboxGroup.vue';
+export declare type CheckboxValueType = boolean | number | string | undefined;
+export declare type CheckboxGroupSingleValue = number | string;
+export declare const checkboxGroupType: readonly ["default", "button"];
+export declare type CheckboxGroupType = (typeof checkboxGroupType)[number];
+export interface CheckboxGroupOption {
+    value: CheckboxGroupSingleValue;
+    label: string;
+    disabled?: boolean;
+    border?: boolean;
+}
+export declare const checkboxProps: {
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    trueValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    falseValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"small" | "default" | "large">;
+        default: string;
+        validator: (val: "small" | "default" | "large") => boolean;
+    };
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    indeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: PropType<"primary" | "blue" | "red" | "orange" | "green" | "iris" | "cyan" | "yellow" | "amber" | "purple" | "lime" | "sky" | "violet" | "pink" | "mint">;
+        default: "primary" | "blue" | "red" | "orange" | "green" | "iris" | "cyan" | "yellow" | "amber" | "purple" | "lime" | "sky" | "violet" | "pink" | "mint";
+        validator: (val: "primary" | "blue" | "red" | "orange" | "green" | "iris" | "cyan" | "yellow" | "amber" | "purple" | "lime" | "sky" | "violet" | "pink" | "mint") => boolean;
+    };
+};
+export declare type CheckboxProps = ExtractPropTypes<typeof checkboxProps>;
+export declare const checkboxEmits: {
+    'update:modelValue': (val: CheckboxValueType) => boolean;
+    change: (val: CheckboxValueType, ev: Event) => boolean;
+};
+export declare type CheckboxEmits = typeof checkboxEmits;
+export declare type CheckboxInstanceType = InstanceType<typeof Checkbox>;
+export declare const checkboxButtonType: readonly ["border", "fill", "card"];
+export declare type CheckboxButtonType = (typeof checkboxButtonType)[number];
+export declare const checkboxGroupProps: {
+    modelValue: {
+        type: PropType<CheckboxGroupSingleValue[]>;
+        default: () => CheckboxGroupSingleValue[];
+    };
+    size: {
+        type: PropType<"small" | "default" | "large">;
+        default: string;
+        validator: (val: string) => boolean;
+    };
+    options: {
+        type: PropType<CheckboxGroupOption[]>;
+        default: () => CheckboxGroupOption[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingText: {
+        type: StringConstructor;
+    };
+    buttonType: {
+        type: PropType<"fill" | "border" | "card">;
+        default: string;
+        validator: (val: "fill" | "border" | "card") => boolean;
+    };
+    type: {
+        type: PropType<"default" | "button">;
+        default: string;
+        validator: (val: "default" | "button") => boolean;
+    };
+    buttonFill: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: PropType<"primary" | "blue" | "red" | "orange" | "green" | "iris" | "cyan" | "yellow" | "amber" | "purple" | "lime" | "sky" | "violet" | "pink" | "mint">;
+        default: "primary" | "blue" | "red" | "orange" | "green" | "iris" | "cyan" | "yellow" | "amber" | "purple" | "lime" | "sky" | "violet" | "pink" | "mint";
+        validator: (val: "primary" | "blue" | "red" | "orange" | "green" | "iris" | "cyan" | "yellow" | "amber" | "purple" | "lime" | "sky" | "violet" | "pink" | "mint") => boolean;
+    };
+};
+export declare type CheckboxGroupProps = ExtractPropTypes<typeof checkboxGroupProps>;
+export declare const checkboxGroupEmits: {
+    'update:modelValue': (v: CheckboxGroupSingleValue[]) => boolean;
+    change: (v: CheckboxGroupSingleValue[]) => boolean;
+};
+export declare type CheckboxGroupEmits = typeof checkboxGroupEmits;
+export declare type CheckboxGroupInstanceType = InstanceType<typeof CheckboxGroup>;
+export interface ChangeState {
+    checked: boolean;
+    value: CheckboxGroupSingleValue;
+}
+export interface CheckboxGroupContext {
+    stateValue: Ref<CheckboxGroupSingleValue[]>;
+    size: Ref<NormalSizeMap>;
+    disabled: Ref<boolean>;
+    buttonType: Ref<boolean>;
+    color: Ref<ColorType | undefined>;
+    change: (state: ChangeState) => void;
+}

package/lib/components/Checkbox/Checkbox.type.js

@@ -0,0 +1,114 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var propsValidators = require('../../utils/propsValidators.js');
+var globalType = require('../../utils/globalType.js');
+
+const checkboxGroupType = ["default", "button"];
+const checkboxProps = {
+  modelValue: {
+    type: [Boolean, String, Number],
+    default: void 0
+  },
+  trueValue: {
+    type: [String, Number, Boolean],
+    default: true
+  },
+  falseValue: {
+    type: [String, Number, Boolean],
+    default: false
+  },
+  value: {
+    type: [String, Number],
+    default: ""
+  },
+  disabled: {
+    type: Boolean,
+    default: false
+  },
+  size: {
+    type: String,
+    default: "default",
+    validator: propsValidators.oneOf(globalType.normalSizeMap.map((x) => x))
+  },
+  name: {
+    type: String,
+    default: ""
+  },
+  border: {
+    type: Boolean,
+    default: false
+  },
+  indeterminate: {
+    type: Boolean,
+    default: false
+  },
+  color: {
+    type: String,
+    default: void 0,
+    validator: propsValidators.oneOf(globalType.colorType)
+  }
+};
+const checkboxEmits = {
+  "update:modelValue": (val) => val === void 0 || typeof val === "boolean" || typeof val === "number" || typeof val === "string",
+  change: (val, ev) => (val === void 0 || typeof val === "boolean" || typeof val === "number" || typeof val === "string") && ev instanceof Event
+};
+const checkboxButtonType = ["border", "fill", "card"];
+const checkboxGroupProps = {
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  size: {
+    type: String,
+    default: "default",
+    validator: propsValidators.oneOf(["small", "large", "default"])
+  },
+  options: {
+    type: Array,
+    default: () => []
+  },
+  disabled: {
+    type: Boolean,
+    default: false
+  },
+  loading: {
+    type: Boolean,
+    default: false
+  },
+  loadingText: {
+    type: String
+  },
+  buttonType: {
+    type: String,
+    default: "border",
+    validator: propsValidators.oneOf(checkboxButtonType)
+  },
+  type: {
+    type: String,
+    default: "default",
+    validator: propsValidators.oneOf(checkboxGroupType)
+  },
+  buttonFill: {
+    type: Boolean,
+    default: false
+  },
+  color: {
+    type: String,
+    default: void 0,
+    validator: propsValidators.oneOf(globalType.colorType)
+  }
+};
+const checkboxGroupEmits = {
+  "update:modelValue": (v) => Array.isArray(v) && v.every((x) => x === void 0 || typeof x === "number" || typeof x === "string"),
+  change: (v) => Array.isArray(v) && v.every((x) => x === void 0 || typeof x === "number" || typeof x === "string")
+};
+
+exports.checkboxButtonType = checkboxButtonType;
+exports.checkboxEmits = checkboxEmits;
+exports.checkboxGroupEmits = checkboxGroupEmits;
+exports.checkboxGroupProps = checkboxGroupProps;
+exports.checkboxGroupType = checkboxGroupType;
+exports.checkboxProps = checkboxProps;
+//# sourceMappingURL=Checkbox.type.js.map