@dfsj/components 3.0.0

package/dist/node_modules/.pnpm/@vueuse_core@10.7.2_vue@3.4.21/node_modules/@vueuse/core/index.js

@@ -0,0 +1,268 @@
+import '@babel/runtime/helpers/objectWithoutProperties';
+import '@babel/runtime/helpers/typeof';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { tryOnScopeDispose, toValue, noop, isObject, isClient } from '../../../../@vueuse_shared@10.7.2_vue@3.4.21/node_modules/@vueuse/shared/index.js';
+export { getLifeCycleTarget, tryOnUnmounted } from '../../../../@vueuse_shared@10.7.2_vue@3.4.21/node_modules/@vueuse/shared/index.js';
+import { computed, ref, watch, getCurrentInstance, onMounted } from 'vue';
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function unrefElement(elRef) {
+  var _a;
+  var plain = toValue(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+var defaultWindow = isClient ? window : void 0;
+var defaultDocument = isClient ? window.document : void 0;
+function useEventListener() {
+  var target;
+  var events;
+  var listeners;
+  var options;
+  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    args[_key3] = arguments[_key3];
+  }
+  if (typeof args[0] === "string" || Array.isArray(args[0])) {
+    events = args[0];
+    listeners = args[1];
+    options = args[2];
+    target = defaultWindow;
+  } else {
+    target = args[0];
+    events = args[1];
+    listeners = args[2];
+    options = args[3];
+  }
+  if (!target) return noop;
+  if (!Array.isArray(events)) events = [events];
+  if (!Array.isArray(listeners)) listeners = [listeners];
+  var cleanups = [];
+  var cleanup = function cleanup() {
+    cleanups.forEach(function (fn) {
+      return fn();
+    });
+    cleanups.length = 0;
+  };
+  var register = function register(el, event, listener, options2) {
+    el.addEventListener(event, listener, options2);
+    return function () {
+      return el.removeEventListener(event, listener, options2);
+    };
+  };
+  var stopWatch = watch(function () {
+    return [unrefElement(target), toValue(options)];
+  }, function (_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+      el = _ref6[0],
+      options2 = _ref6[1];
+    cleanup();
+    if (!el) return;
+    var optionsClone = isObject(options2) ? _objectSpread({}, options2) : options2;
+    cleanups.push.apply(cleanups, _toConsumableArray(events.flatMap(function (event) {
+      return listeners.map(function (listener) {
+        return register(el, event, listener, optionsClone);
+      });
+    })));
+  }, {
+    immediate: true,
+    flush: "post"
+  });
+  var stop = function stop() {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+function useMounted() {
+  var isMounted = ref(false);
+  if (getCurrentInstance()) {
+    onMounted(function () {
+      isMounted.value = true;
+    });
+  }
+  return isMounted;
+}
+function useSupported(callback) {
+  var isMounted = useMounted();
+  return computed(function () {
+    isMounted.value;
+    return Boolean(callback());
+  });
+}
+var eventHandlers = ["fullscreenchange", "webkitfullscreenchange", "webkitendfullscreen", "mozfullscreenchange", "MSFullscreenChange"];
+function useFullscreen(target) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$document6 = options.document,
+    document = _options$document6 === void 0 ? defaultDocument : _options$document6,
+    _options$autoExit = options.autoExit,
+    autoExit = _options$autoExit === void 0 ? false : _options$autoExit;
+  var targetRef = computed(function () {
+    var _a;
+    return (_a = unrefElement(target)) != null ? _a : document == null ? void 0 : document.querySelector("html");
+  });
+  var isFullscreen = ref(false);
+  var requestMethod = computed(function () {
+    return ["requestFullscreen", "webkitRequestFullscreen", "webkitEnterFullscreen", "webkitEnterFullScreen", "webkitRequestFullScreen", "mozRequestFullScreen", "msRequestFullscreen"].find(function (m) {
+      return document && m in document || targetRef.value && m in targetRef.value;
+    });
+  });
+  var exitMethod = computed(function () {
+    return ["exitFullscreen", "webkitExitFullscreen", "webkitExitFullScreen", "webkitCancelFullScreen", "mozCancelFullScreen", "msExitFullscreen"].find(function (m) {
+      return document && m in document || targetRef.value && m in targetRef.value;
+    });
+  });
+  var fullscreenEnabled = computed(function () {
+    return ["fullScreen", "webkitIsFullScreen", "webkitDisplayingFullscreen", "mozFullScreen", "msFullscreenElement"].find(function (m) {
+      return document && m in document || targetRef.value && m in targetRef.value;
+    });
+  });
+  var fullscreenElementMethod = ["fullscreenElement", "webkitFullscreenElement", "mozFullScreenElement", "msFullscreenElement"].find(function (m) {
+    return document && m in document;
+  });
+  var isSupported = useSupported(function () {
+    return targetRef.value && document && requestMethod.value !== void 0 && exitMethod.value !== void 0 && fullscreenEnabled.value !== void 0;
+  });
+  var isCurrentElementFullScreen = function isCurrentElementFullScreen() {
+    if (fullscreenElementMethod) return (document == null ? void 0 : document[fullscreenElementMethod]) === targetRef.value;
+    return false;
+  };
+  var isElementFullScreen = function isElementFullScreen() {
+    if (fullscreenEnabled.value) {
+      if (document && document[fullscreenEnabled.value] != null) {
+        return document[fullscreenEnabled.value];
+      } else {
+        var target2 = targetRef.value;
+        if ((target2 == null ? void 0 : target2[fullscreenEnabled.value]) != null) {
+          return Boolean(target2[fullscreenEnabled.value]);
+        }
+      }
+    }
+    return false;
+  };
+  function exit() {
+    return _exit.apply(this, arguments);
+  }
+  function _exit() {
+    _exit = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {
+      var target2;
+      return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+        while (1) switch (_context25.prev = _context25.next) {
+          case 0:
+            if (!(!isSupported.value || !isFullscreen.value)) {
+              _context25.next = 2;
+              break;
+            }
+            return _context25.abrupt("return");
+          case 2:
+            if (!exitMethod.value) {
+              _context25.next = 12;
+              break;
+            }
+            if (!((document == null ? void 0 : document[exitMethod.value]) != null)) {
+              _context25.next = 8;
+              break;
+            }
+            _context25.next = 6;
+            return document[exitMethod.value]();
+          case 6:
+            _context25.next = 12;
+            break;
+          case 8:
+            target2 = targetRef.value;
+            if (!((target2 == null ? void 0 : target2[exitMethod.value]) != null)) {
+              _context25.next = 12;
+              break;
+            }
+            _context25.next = 12;
+            return target2[exitMethod.value]();
+          case 12:
+            isFullscreen.value = false;
+          case 13:
+          case "end":
+            return _context25.stop();
+        }
+      }, _callee25);
+    }));
+    return _exit.apply(this, arguments);
+  }
+  function enter() {
+    return _enter.apply(this, arguments);
+  }
+  function _enter() {
+    _enter = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee26() {
+      var target2;
+      return _regeneratorRuntime.wrap(function _callee26$(_context26) {
+        while (1) switch (_context26.prev = _context26.next) {
+          case 0:
+            if (!(!isSupported.value || isFullscreen.value)) {
+              _context26.next = 2;
+              break;
+            }
+            return _context26.abrupt("return");
+          case 2:
+            if (!isElementFullScreen()) {
+              _context26.next = 5;
+              break;
+            }
+            _context26.next = 5;
+            return exit();
+          case 5:
+            target2 = targetRef.value;
+            if (!(requestMethod.value && (target2 == null ? void 0 : target2[requestMethod.value]) != null)) {
+              _context26.next = 10;
+              break;
+            }
+            _context26.next = 9;
+            return target2[requestMethod.value]();
+          case 9:
+            isFullscreen.value = true;
+          case 10:
+          case "end":
+            return _context26.stop();
+        }
+      }, _callee26);
+    }));
+    return _enter.apply(this, arguments);
+  }
+  function toggle() {
+    return _toggle.apply(this, arguments);
+  }
+  function _toggle() {
+    _toggle = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee27() {
+      return _regeneratorRuntime.wrap(function _callee27$(_context27) {
+        while (1) switch (_context27.prev = _context27.next) {
+          case 0:
+            _context27.next = 2;
+            return isFullscreen.value ? exit() : enter();
+          case 2:
+          case "end":
+            return _context27.stop();
+        }
+      }, _callee27);
+    }));
+    return _toggle.apply(this, arguments);
+  }
+  var handlerCallback = function handlerCallback() {
+    var isElementFullScreenValue = isElementFullScreen();
+    if (!isElementFullScreenValue || isElementFullScreenValue && isCurrentElementFullScreen()) isFullscreen.value = isElementFullScreenValue;
+  };
+  useEventListener(document, eventHandlers, handlerCallback, false);
+  useEventListener(function () {
+    return unrefElement(targetRef);
+  }, eventHandlers, handlerCallback, false);
+  if (autoExit) tryOnScopeDispose(exit);
+  return {
+    isSupported: isSupported,
+    isFullscreen: isFullscreen,
+    enter: enter,
+    exit: exit,
+    toggle: toggle
+  };
+}
+
+export { defaultDocument, defaultWindow, isClient, isObject, noop, toValue, tryOnScopeDispose, unrefElement, useEventListener, useFullscreen, useMounted, useSupported };

package/dist/node_modules/.pnpm/@vueuse_shared@10.7.2_vue@3.4.21/node_modules/@vueuse/shared/index.js

@@ -0,0 +1,34 @@
+import '@babel/runtime/helpers/objectWithoutProperties';
+import '@babel/runtime/helpers/asyncToGenerator';
+import '@babel/runtime/helpers/toConsumableArray';
+import '@babel/runtime/helpers/slicedToArray';
+import '@babel/runtime/helpers/defineProperty';
+import '@babel/runtime/regenerator';
+import { getCurrentScope, onScopeDispose, unref, onUnmounted, getCurrentInstance } from 'vue';
+
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+function toValue(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+var toString = Object.prototype.toString;
+var isObject = function isObject(val) {
+  return toString.call(val) === "[object Object]";
+};
+var noop = function noop() {};
+function getLifeCycleTarget(target) {
+  return target || getCurrentInstance();
+}
+function tryOnUnmounted(fn, target) {
+  var instance = getLifeCycleTarget(target);
+  if (instance) onUnmounted(fn, target);
+}
+
+export { getLifeCycleTarget, isClient, isObject, noop, toValue, tryOnScopeDispose, tryOnUnmounted };

package/dist/themes/index.d.ts

@@ -0,0 +1 @@
+import "./index.scss";

package/dist/themes/index.js

@@ -0,0 +1 @@
+

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export type Recordable<T = any, K = string> = Record<K extends null | undefined ? string : K, T>;
+export type Fn = any;
+export type ComponentRef<T extends abstract new (...args: any) => any> = InstanceType<T>;
+export type Nullable<T> = T | null;
+export type ElRef<T extends HTMLElement = HTMLDivElement> = Nullable<T>;
+export type ElementPlusInfoType = 'success' | 'info' | 'warning' | 'danger';
+export type TimeoutHandle = ReturnType<typeof setTimeout>;
+export type IntervalHandle = ReturnType<typeof setInterval>;

package/dist/utils/index.d.ts

@@ -0,0 +1,11 @@
+import { Fn, Recordable } from '../types';
+export declare const withInstall: <T>(component: T, alias?: string) => T & Plugin;
+export declare const humpToUnderline: (str: string) => string;
+export declare const underlineToHump: (str: string) => string;
+export declare const humpToDash: (str: string) => string;
+export declare const setCssVar: (prop: string, val: any, dom?: HTMLElement) => void;
+export declare const findIndex: <T = Recordable>(ary: T[], fn: Fn) => number;
+export declare const trim: (str: string) => string;
+export declare function formatTime(time: Date | number | string, fmt: string): string;
+export declare function toAnyString(): string;
+export declare function firstUpperCase(str: string): string;

package/dist/utils/index.js

@@ -0,0 +1,24 @@
+var humpToDash = function humpToDash(str) {
+  return str.replace(/([A-Z])/g, '-$1').toLowerCase();
+};
+var findIndex = function findIndex(ary, fn) {
+  if (ary.findIndex) {
+    return ary.findIndex(fn);
+  }
+  var index = -1;
+  ary.some(function (item, i, ary) {
+    var ret = fn(item, i, ary);
+    if (ret) {
+      index = i;
+      return ret;
+    }
+  });
+  return index;
+};
+function firstUpperCase(str) {
+  return str.toLowerCase().replace(/( |^)[a-z]/g, function (L) {
+    return L.toUpperCase();
+  });
+}
+
+export { findIndex, firstUpperCase, humpToDash };

package/dist/utils/is.d.ts

@@ -0,0 +1,25 @@
+export declare const is: (val: unknown, type: string) => boolean;
+export declare const isDef: <T = unknown>(val?: T) => val is T;
+export declare const isUnDef: <T = unknown>(val?: T) => val is T;
+export declare const isObject: (val: any) => val is Record<any, any>;
+export declare const isEmpty: <T = unknown>(val: T) => val is T;
+export declare const isDate: (val: unknown) => val is Date;
+export declare const isNull: (val: unknown) => val is null;
+export declare const isNullAndUnDef: (val: unknown) => val is null;
+export declare const isNullOrUnDef: (val: unknown) => val is null;
+export declare const isNumber: (val: unknown) => val is number;
+export declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+export declare const isString: (val: unknown) => val is string;
+export declare const isFunction: (val: unknown) => val is Function;
+export declare const isBoolean: (val: unknown) => val is boolean;
+export declare const isRegExp: (val: unknown) => val is RegExp;
+export declare const isArray: (val: any) => val is any[];
+export declare const isWindow: (val: any) => val is Window;
+export declare const isElement: (val: unknown) => val is Element;
+export declare const isMap: (val: unknown) => val is Map<any, any>;
+export declare const isServer: boolean;
+export declare const isClient: boolean;
+export declare const isUrl: (path: string) => boolean;
+export declare const isDark: () => boolean;
+export declare const isImgPath: (path: string) => boolean;
+export declare const isEmptyVal: (val: any) => boolean;

package/dist/utils/is.js

@@ -0,0 +1,36 @@
+var toString = Object.prototype.toString;
+var is = function is(val, type) {
+  return toString.call(val) === "[object ".concat(type, "]");
+};
+var isObject = function isObject(val) {
+  return val !== null && is(val, 'Object');
+};
+var isEmpty = function isEmpty(val) {
+  if (isArray(val) || isString(val)) {
+    return val.length === 0;
+  }
+  if (val instanceof Map || val instanceof Set) {
+    return val.size === 0;
+  }
+  if (isObject(val)) {
+    return Object.keys(val).length === 0;
+  }
+  return false;
+};
+var isNumber = function isNumber(val) {
+  return is(val, 'Number');
+};
+var isString = function isString(val) {
+  return is(val, 'String');
+};
+var isFunction = function isFunction(val) {
+  return typeof val === 'function';
+};
+var isArray = function isArray(val) {
+  return val && Array.isArray(val);
+};
+var isEmptyVal = function isEmptyVal(val) {
+  return val === '' || val === null || val === undefined;
+};
+
+export { is, isArray, isEmpty, isEmptyVal, isFunction, isNumber, isObject, isString };

package/dist/utils/propTypes.d.ts

@@ -0,0 +1,10 @@
+import { VueTypesInterface, VueTypeValidableDef } from 'vue-types';
+import { CSSProperties } from 'vue';
+type PropTypes = VueTypesInterface & {
+    readonly style: VueTypeValidableDef<CSSProperties>;
+};
+declare const newPropTypes: PropTypes;
+declare class propTypes extends newPropTypes {
+    static get style(): VueTypeValidableDef<any, import("vue-types/dist/types").ValidatorFunction<any>>;
+}
+export default propTypes;

package/dist/utils/propTypes.js

@@ -0,0 +1,35 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _inherits from '@babel/runtime/helpers/inherits';
+import { createTypes, toValidableType } from 'vue-types';
+
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var newPropTypes = createTypes({
+  func: undefined,
+  bool: undefined,
+  string: undefined,
+  number: undefined,
+  object: undefined,
+  integer: undefined
+});
+var propTypes = /*#__PURE__*/function (_newPropTypes) {
+  _inherits(propTypes, _newPropTypes);
+  function propTypes() {
+    _classCallCheck(this, propTypes);
+    return _callSuper(this, propTypes, arguments);
+  }
+  _createClass(propTypes, null, [{
+    key: "style",
+    get: function get() {
+      return toValidableType('style', {
+        type: [String, Object]
+      });
+    }
+  }]);
+  return propTypes;
+}(newPropTypes);
+
+export { propTypes as default };

package/dist/utils/tsxHelper.d.ts

@@ -0,0 +1,5 @@
+import { Slots } from 'vue';
+import { Recordable } from '../types';
+export declare const getSlot: (slots: Slots, slot?: string, data?: Recordable) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[];

package/dist/utils/tsxHelper.js

@@ -0,0 +1,18 @@
+import { isFunction } from './is.js';
+
+var getSlot = function getSlot(slots) {
+  var slot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default';
+  var data = arguments.length > 2 ? arguments[2] : undefined;
+  if (!slots || !Reflect.has(slots, slot)) {
+    return null;
+  }
+  if (!isFunction(slots[slot])) {
+    console.error("".concat(slot, " is not a function!"));
+    return null;
+  }
+  var slotFn = slots[slot];
+  if (!slotFn) return null;
+  return slotFn(data);
+};
+
+export { getSlot };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@dfsj/components",
+  "version": "3.0.0",
+  "description": "通用的vue组件;包括专业组件、原子级组件",
+  "type": "module",
+  "keywords": [
+    "vue3",
+    "component"
+  ],
+  "author": "yangbo <1747837358@qq.com>",
+  "homepage": "",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "directories": {
+    "lib": "lib",
+    "test": "__tests__"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "node ./__tests__/component.test.js",
+    "watch": "rollup --config ./rollup.config.ts --configPlugin typescript -w",
+    "build": "rollup --config ./rollup.config.ts --configPlugin typescript"
+  },
+  "devDependencies": {
+    "@dfsj/rollup": "workspace:^",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^20.11.3",
+    "@unocss/transformer-variant-group": "^0.58.6",
+    "@vueuse/core": "^10.5.0",
+    "element-plus": "^2.6.1",
+    "unocss": "^0.58.6",
+    "vue": "^3.4.21"
+  },
+  "peerDependencies": {
+    "element-plus": "^2.6.1",
+    "vue": "^3.4.21"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.24.0",
+    "@dfsj/echarts": "^3.0.0",
+    "@dfsj/utils": "^3.0.0",
+    "@element-plus/icons-vue": "^2.3.1",
+    "@iconify/iconify": "^3.1.1",
+    "@wangeditor/editor": "^5.1.23",
+    "@wangeditor/editor-for-vue": "^5.1.10",
+    "@zxcvbn-ts/core": "^3.0.4",
+    "dayjs": "^1.11.7",
+    "lodash-es": "^4.17.21",
+    "vue-draggable-plus": "^0.3.5",
+    "vue-types": "^5.0.2"
+  },
+  "gitHead": "9a2fe7ed1e52959d2655a684ff2ef1e94d72a738",
+  "module": "dist/index.js",
+  "browser": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  }
+}