shineout 1.12.2 → 1.12.3

package/esm/utils/dom/getDataset.js

@@ -0,0 +1,10 @@
+//
+export default (function (props) {
+  if (!props) return {};
+  var keys = Object.keys(props);
+  return keys.reduce(function (acc, key) {
+    if (key.indexOf('data-') !== 0) return acc;
+    acc[key] = props[key];
+    return acc;
+  }, {});
+});

package/esm/utils/dom/isDOMElement.d.ts

@@ -0,0 +1,6 @@
+interface El {
+    nodeType: number;
+    nodeName: string;
+}
+export default function (el: HTMLElement | El): boolean;
+export {};

package/esm/utils/dom/isDOMElement.js

@@ -0,0 +1,3 @@
+export default function (el) {
+  return typeof HTMLElement === 'function' ? el instanceof HTMLElement : el && typeof el === 'object' && el.nodeType === 1 && typeof el.nodeName === 'string';
+}

package/esm/utils/dom/normalizeWheel.d.ts

@@ -0,0 +1,14 @@
+interface OldWheelEvent extends WheelEvent {
+    axis?: number;
+    wheelDelta?: number;
+    wheelDeltaY?: number;
+    wheelDeltaX?: number;
+    HORIZONTAL_AXIS?: number;
+}
+export default function (event: OldWheelEvent): {
+    spinX: number;
+    spinY: number;
+    pixelX: number;
+    pixelY: number;
+};
+export {};

package/esm/utils/dom/normalizeWheel.js

@@ -0,0 +1,67 @@
+var PIXEL_STEP = 10;
+var LINE_HEIGHT = 40;
+var PAGE_HEIGHT = 800;
+var DELTA_LENGTH = 120;
+export default function (event) {
+  var sX = 0;
+  var sY = 0;
+  var pX = 0;
+  var pY = 0;
+
+  if ('detail' in event) {
+    sY = event.detail;
+  }
+
+  if ('wheelDelta' in event && event.wheelDelta) {
+    sY = -event.wheelDelta / DELTA_LENGTH;
+  }
+
+  if ('wheelDeltaY' in event && event.wheelDeltaY) {
+    sY = -event.wheelDeltaY / DELTA_LENGTH;
+  }
+
+  if ('wheelDeltaX' in event && event.wheelDeltaX) {
+    sX = -event.wheelDeltaX / DELTA_LENGTH;
+  }
+
+  if ('axis' in event && event.axis === event.HORIZONTAL_AXIS) {
+    sX = sY;
+    sY = 0;
+  }
+
+  pX = sX * PIXEL_STEP;
+  pY = sY * PIXEL_STEP;
+
+  if ('deltaY' in event) {
+    pY = event.deltaY;
+  }
+
+  if ('deltaX' in event) {
+    pX = event.deltaX;
+  }
+
+  if ((pX || pY) && event.deltaMode) {
+    if (event.deltaMode === 1) {
+      pX *= LINE_HEIGHT;
+      pY *= LINE_HEIGHT;
+    } else {
+      pX *= PAGE_HEIGHT;
+      pY *= PAGE_HEIGHT;
+    }
+  }
+
+  if (pX && !sX) {
+    sX = pX < 1 ? -1 : 1;
+  }
+
+  if (pY && !sY) {
+    sY = pY < 1 ? -1 : 1;
+  }
+
+  return {
+    spinX: sX,
+    spinY: sY,
+    pixelX: pX,
+    pixelY: pY
+  };
+}

package/esm/utils/dom/popContainer.d.ts

@@ -0,0 +1,2 @@
+declare const getContainer: () => HTMLElement;
+export default getContainer;

package/esm/utils/dom/popContainer.js

@@ -0,0 +1,17 @@
+/**
+ * 最外层容器
+ */
+import ready from './ready';
+var Container = null;
+
+var getContainer = function getContainer() {
+  if (Container) return Container;
+  Container = document.createElement('div');
+  Container.setAttribute('style', 'position: absolute; top: 0; left: 0; width: 100%; contain: size');
+  ready(function () {
+    if (Container) document.body.appendChild(Container);
+  });
+  return Container;
+};
+
+export default getContainer;

package/esm/utils/dom/popover.d.ts

@@ -0,0 +1,9 @@
+import { PopoverPosition } from '../../Popover/Props';
+interface PositionInfo {
+    top?: number;
+    left?: number;
+    right?: number;
+    bottom?: number;
+}
+export declare const getPosition: (position: PopoverPosition, el: HTMLElement, container?: HTMLElement | undefined) => Record<keyof PositionInfo, string>;
+export {};

package/esm/utils/dom/popover.js

@@ -0,0 +1,96 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import { docScroll, docSize } from './document';
+var posKeys = ['left', 'top', 'bottom', 'right'];
+export var getPosition = function getPosition(position, el, container) {
+  if (container === void 0) {
+    container = document.body;
+  }
+
+  var rect = el.getBoundingClientRect();
+  var containerRect = {
+    top: 0,
+    left: 0,
+    bottom: 0,
+    right: 0
+  };
+  if (container.tagName === 'BODY') container = undefined;
+  if (container) containerRect = container.getBoundingClientRect();
+  var scrollTop = container ? 0 : docScroll.top;
+  var scrollLeft = container ? 0 : docScroll.left;
+  var pos = {};
+
+  switch (position) {
+    case 'top-left':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+
+    case 'top':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width / 2;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+
+    case 'top-right':
+      pos.right = (containerRect.right || docSize.width) - rect.right - scrollLeft;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+
+    case 'left-top':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+
+    case 'left':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height / 2;
+      break;
+
+    case 'left-bottom':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.bottom - containerRect.bottom;
+      break;
+
+    case 'right-top':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+
+    case 'right':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height / 2;
+      break;
+
+    case 'right-bottom':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width;
+      pos.top = scrollTop + rect.bottom - containerRect.bottom;
+      break;
+
+    case 'bottom-left':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height;
+      break;
+
+    case 'bottom':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width / 2;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height;
+      break;
+
+    case 'bottom-right':
+      pos.right = (containerRect.right || docSize.width) - rect.right - scrollLeft;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height;
+      break;
+
+    case 'cover':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+
+    default:
+  }
+
+  return posKeys.reduce(function (data, key) {
+    var _objectSpread2;
+
+    return _objectSpread({}, data, (_objectSpread2 = {}, _objectSpread2[key] = typeof pos[key] === 'number' ? Math.round(pos[key]) + "px" : 'auto', _objectSpread2));
+  }, {});
+};

package/esm/utils/dom/ready.d.ts

@@ -0,0 +1 @@
+export default function (callback: (...args: any) => void): void;

package/esm/utils/dom/ready.js

@@ -0,0 +1,6 @@
+export default function (callback) {
+  if (!callback) return;
+  if (document.readyState !== 'loading') callback();else {
+    document.addEventListener('DOMContentLoaded', callback);
+  }
+}

package/esm/utils/dom/scrollBehavior.d.ts

@@ -0,0 +1 @@
+export function banOverScrollX(el: any): () => void;

package/esm/utils/dom/scrollBehavior.js

@@ -0,0 +1,27 @@
+var htmlDom;
+var lastStyle = null;
+
+var getHtml = function getHtml() {
+  if (!htmlDom) htmlDom = document.body.parentElement;
+  return htmlDom;
+};
+
+var setScrollBehavior = function setScrollBehavior() {
+  if (lastStyle !== null) return;
+  lastStyle = getHtml().style.overscrollBehaviorX;
+  htmlDom.style.overscrollBehaviorX = 'none';
+};
+
+var resetScrollBehavior = function resetScrollBehavior() {
+  htmlDom.style.overscrollBehaviorX = lastStyle;
+  lastStyle = null;
+};
+
+export var banOverScrollX = function banOverScrollX(el) {
+  el.addEventListener('mouseenter', setScrollBehavior);
+  el.addEventListener('mouseleave', resetScrollBehavior);
+  return function () {
+    el.removeEventListener('mouseenter', setScrollBehavior);
+    el.removeEventListener('mouseleave', resetScrollBehavior);
+  };
+};

package/esm/utils/dom/translate.d.ts

@@ -0,0 +1,2 @@
+export declare function setTranslate(el: HTMLElement, x: string, y: string): void;
+export declare function setTranslate3D(el: HTMLElement, x: string, y: string): void;

package/esm/utils/dom/translate.js

@@ -0,0 +1,30 @@
+import { has3d, getTransformName } from './detect';
+import { isRTL } from '../../config';
+var use3d;
+
+var getDirectionX = function getDirectionX(xs) {
+  var num = Number.parseFloat(xs);
+  var numStr = String(num);
+  var start = xs.indexOf(numStr) + numStr.length;
+  var u = xs.slice(start);
+  var result = String((isRTL() ? -1 : 1) * num) + u;
+  return result;
+};
+
+export function setTranslate(el, x, y) {
+  var tn = getTransformName();
+  el.style[tn] = "translate(" + getDirectionX(x) + "," + y + ")";
+}
+export function setTranslate3D(el, x, y) {
+  if (use3d === undefined) use3d = has3d();
+  var tn = getTransformName();
+  var xd = getDirectionX(x);
+
+  if (use3d) {
+    ;
+    el.style[tn] = "translate3d(" + xd + "," + y + ",0)";
+  } else {
+    ;
+    el.style[tn] = "translate(" + xd + "," + y + ")";
+  }
+}

package/esm/utils/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class FormError extends Error {
+    value: any;
+    constructor(message: string, name?: string, value?: any);
+}
+export declare function wrapFormError<T>(error: T): T;
+export declare function wrapFormError(error: Error): FormError;
+export declare function wrapFormError(error: Error[]): FormError[];
+export declare const promiseAll: (ops: Promise<any>[], isForm?: boolean) => Promise<unknown>;
+export declare const isSameError: (a: unknown, b: unknown) => boolean;

package/esm/utils/errors.js

@@ -0,0 +1,62 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export var FormError =
+/*#__PURE__*/
+function (_Error) {
+  _inheritsLoose(FormError, _Error);
+
+  function FormError(message, name, value) {
+    var _this;
+
+    _this = _Error.call(this) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "value", void 0);
+
+    _this.message = message;
+    _this.name = name || '';
+    _this.value = value;
+    return _this;
+  }
+
+  return FormError;
+}(_wrapNativeSuper(Error));
+export function wrapFormError(error) {
+  if (error instanceof Error) {
+    return new FormError(error.message);
+  }
+
+  if (Array.isArray(error)) {
+    return error.map(function (e) {
+      return wrapFormError(e);
+    });
+  }
+
+  return error;
+}
+export var promiseAll = function promiseAll(ops, isForm) {
+  if (isForm === void 0) {
+    isForm = true;
+  }
+
+  return new Promise(function (resolve, reject) {
+    Promise.all(ops).then(function (res) {
+      var error = res.find(function (r) {
+        return r !== true;
+      });
+      if (error) reject(error);else resolve(true);
+    }).catch(function (e) {
+      reject(isForm ? wrapFormError(e) : e);
+    });
+  });
+};
+export var isSameError = function isSameError(a, b) {
+  if (a === b) return true;
+
+  if (a instanceof Error && b instanceof Error) {
+    return a.message === b.message;
+  }
+
+  return a === b;
+};

package/esm/utils/expose.d.ts

@@ -0,0 +1,18 @@
+import { cleanCache } from './css-accessors';
+import { setInjectType, getInjectType } from './vars-inject';
+declare const types: string[];
+declare type ObjectProps = {
+    [x: string]: any;
+};
+declare function getClassname(data: ObjectProps): string;
+declare const style: {
+    getClassname: typeof getClassname;
+    setStyle(options: ObjectProps, custom?: ObjectProps): void;
+    cleanCache: typeof cleanCache;
+    setInjectType: typeof setInjectType;
+    getInjectType: typeof getInjectType;
+};
+declare const color: {
+    [x: string]: any;
+};
+export { color, style, types };

package/esm/utils/expose.js

@@ -0,0 +1,125 @@
+import { isObject } from './is';
+import { exposeClass } from '../styles/expose';
+import cssAccessors, { cleanCache } from './css-accessors';
+import { capitalize } from './strings';
+import { entries } from './objects';
+import { setInjectType, injectTag, getInjectType, cleanStyleObj } from './vars-inject';
+var types = ['primary', 'warning', 'danger', 'success', 'secondary'];
+var attrs = ['background', 'color', 'border'];
+
+function validateFormat(data) {
+  if (!isObject(data)) {
+    console.error(new Error('Should enter a json data with attrs(key) and types(types)'));
+    return false;
+  } // attributes
+
+
+  if (Object.keys(data).filter(function (v) {
+    return attrs.indexOf(v) === -1;
+  }).length > 0) {
+    console.error(new Error("The attribute your entered does not exist need[" + attrs.join('/') + "]"));
+    return false;
+  } // types
+
+
+  if (Object.values(data).filter(function (v) {
+    return types.indexOf(v) === -1;
+  }).length > 0) {
+    console.error(new Error("The type your entered does not exist need[" + types.join('/') + "]"));
+    return false;
+  }
+
+  return true;
+}
+
+function getClassname(data) {
+  if (!validateFormat(data)) return '';
+  return Object.keys(data).map(function (attr) {
+    return exposeClass(data[attr] + "-" + attr);
+  }).join(' ');
+}
+
+function resetTheme() {
+  Object.keys(cssAccessors).forEach(function (module) {
+    var setterName = "set" + capitalize(module);
+    var setter = cssAccessors[module][setterName];
+    setter(Object.keys(cssAccessors[module]).reduce(function (obj, key) {
+      obj[key] = undefined;
+      return obj;
+    }, {}));
+  });
+}
+
+function setStyleWithTag(options, custom) {
+  cleanStyleObj();
+
+  if (!options) {
+    resetTheme();
+  } else {
+    for (var _iterator = entries(options), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var _ref2 = _ref,
+          key = _ref2[0],
+          values = _ref2[1];
+      var setterName = "set" + capitalize(key);
+      var module = cssAccessors[key];
+      if (module && module[setterName]) module[setterName](values);
+    }
+  }
+
+  injectTag(custom);
+}
+
+var style = {
+  getClassname: getClassname,
+  setStyle: function setStyle(options, custom) {
+    if (custom === void 0) {
+      custom = {};
+    }
+
+    if (getInjectType() === 'tag') {
+      setStyleWithTag(options, custom);
+      return;
+    }
+
+    if (!options) {
+      resetTheme();
+      return;
+    }
+
+    for (var _iterator2 = entries(options), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref3 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref3 = _i2.value;
+      }
+
+      var _ref4 = _ref3,
+          key = _ref4[0],
+          values = _ref4[1];
+      var setterName = "set" + capitalize(key);
+      var module = cssAccessors[key];
+      if (module && module[setterName]) module[setterName](values);
+    }
+  },
+  cleanCache: cleanCache,
+  setInjectType: setInjectType,
+  getInjectType: getInjectType
+};
+var color = cssAccessors.color;
+export { color, style, types };

package/esm/utils/flat.d.ts

@@ -0,0 +1,25 @@
+export declare function insertPoint(name: string): string;
+declare type Result = {
+    [x: string]: unknown;
+};
+export declare function flatten(data: Result, skipArray?: boolean): Result;
+export declare function unflatten<T extends {}>(rawdata: T): {
+    [name: string]: any;
+};
+declare type insertObject = {
+    [x: string]: unknown;
+};
+export declare function insertValue(obj: insertObject, name: string, index: number, value: any): void;
+declare type SpliceValue = {
+    [x: string]: [];
+};
+export declare function spliceValue(obj: SpliceValue, name: keyof SpliceValue & string, index: number): void;
+declare type Source = {
+    [x: string]: any;
+};
+export declare const getSthByName: (name: keyof Source & string, source: Source) => any;
+export declare const removeSthByName: (name: string, source: {
+    [x: string]: any;
+}) => void;
+export declare const flattenArray: <T>(arr1: any[]) => T[];
+export {};