shineout 1.12.2 → 1.12.3

package/esm/utils/compose.js

@@ -0,0 +1,96 @@
+// type Fn<V, R> = (x: V) => R
+// // @ts-expect-error T is an array :troll:
+// type Q<T, V> = (...args: T) => V
+//
+// export function compose<T, V0, V1>(fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V1>
+// export function compose<T, V0, V1, V2>(fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V2>
+// export function compose<T, V0, V1, V2, V3>(fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V3>
+// export function compose<T, V0, V1, V2, V3, V4>(
+//   fn4: Fn<V3, V4>,
+//   fn3: Fn<V2, V3>,
+//   fn2: Fn<V1, V2>,
+//   fn1: Fn<V0, V1>,
+//   fn0: Q<T, V0>
+// ): Q<T, V4>
+// export function compose<T, V0, V1, V2, V3, V4, V5>(
+//   fn5: Fn<V4, V5>,
+//   fn4: Fn<V3, V4>,
+//   fn3: Fn<V2, V3>,
+//   fn2: Fn<V1, V2>,
+//   fn1: Fn<V0, V1>,
+//   fn0: Q<T, V0>
+// ): Q<T, V5>
+// export function compose<T, V0, V1, V2, V3, V4, V5, V6>(
+//   fn6: Fn<V5, V6>,
+//   fn5: Fn<V4, V5>,
+//   fn4: Fn<V3, V4>,
+//   fn3: Fn<V2, V3>,
+//   fn2: Fn<V1, V2>,
+//   fn1: Fn<V0, V1>,
+//   fn0: Q<T, V0>
+// ): Q<T, V6>
+// export function compose<T, V0, V1, V2, V3, V4, V5, V6, V7>(
+//   fn7: Fn<V6, V7>,
+//   fn6: Fn<V5, V6>,
+//   fn5: Fn<V4, V5>,
+//   fn4: Fn<V3, V4>,
+//   fn3: Fn<V2, V3>,
+//   fn2: Fn<V1, V2>,
+//   fn1: Fn<V0, V1>,
+//   fn0: Q<T, V0>
+// ): Q<T, V7>
+// export function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8>(
+//   fn8: Fn<V7, V8>,
+//   fn7: Fn<V6, V7>,
+//   fn6: Fn<V5, V6>,
+//   fn5: Fn<V4, V5>,
+//   fn4: Fn<V3, V4>,
+//   fn3: Fn<V2, V3>,
+//   fn2: Fn<V1, V2>,
+//   fn1: Fn<V0, V1>,
+//   fn0: Q<T, V0>
+// ): Q<T, V8>
+// export function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9>(
+//   fn9: Fn<V8, V9>,
+//   fn8: Fn<V7, V8>,
+//   fn7: Fn<V6, V7>,
+//   fn6: Fn<V5, V6>,
+//   fn5: Fn<V4, V5>,
+//   fn4: Fn<V3, V4>,
+//   fn3: Fn<V2, V3>,
+//   fn2: Fn<V1, V2>,
+//   fn1: Fn<V0, V1>,
+//   fn0: Q<T, V0>
+// ): Q<T, V9>
+// export function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10>(
+//   fn10: Fn<V9, V10>,
+//   fn9: Fn<V8, V9>,
+//   fn8: Fn<V7, V8>,
+//   fn7: Fn<V6, V7>,
+//   fn6: Fn<V5, V6>,
+//   fn5: Fn<V4, V5>,
+//   fn4: Fn<V3, V4>,
+//   fn3: Fn<V2, V3>,
+//   fn2: Fn<V1, V2>,
+//   fn1: Fn<V0, V1>,
+//   fn0: Q<T, V0>
+// ): Q<T, V10>
+export function compose() {
+  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
+    funcs[_key] = arguments[_key];
+  }
+
+  if (funcs.length === 0) {
+    return function (arg) {
+      return arg;
+    };
+  }
+
+  var last = funcs[funcs.length - 1];
+  var rest = funcs.slice(0, -1);
+  return function () {
+    return rest.reduceRight(function (composed, f) {
+      return f(composed);
+    }, last.apply(void 0, arguments));
+  };
+}

package/esm/utils/css-accessors.d.ts

@@ -0,0 +1,10 @@
+import cssInject from './vars-inject';
+declare type ObjectProps = {
+    [x: string]: any;
+};
+declare type Accessors = {
+    [U in keyof typeof cssInject]: ObjectProps;
+};
+export declare function cleanCache(): void;
+declare const _default: Accessors;
+export default _default;

package/esm/utils/css-accessors.js

@@ -0,0 +1,119 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import cssInject from './vars-inject';
+import { capitalize } from './strings';
+import { entries } from './objects';
+
+function setOptions(options, setter) {
+  if (!options) return;
+
+  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],
+        value = _ref2[1];
+    if (key === setter) continue;
+    this[key] = value;
+  }
+}
+
+function getDOMStyle(dom) {
+  document.body.appendChild(dom);
+  var style = window.getComputedStyle(dom);
+  Promise.resolve().then(function () {
+    if (dom.parentElement) dom.parentElement.removeChild(dom);
+  });
+  return style;
+}
+
+function getStyleAttr(className, key) {
+  if (key === void 0) {
+    key = 'color';
+  }
+
+  var div = document.createElement('div');
+  div.className = className;
+  return getDOMStyle(div)[key];
+}
+
+var cache = {};
+
+function genAccessors(obj, data) {
+  data.conf.forEach(function (item) {
+    var name = item.name,
+        className = item.className,
+        attr = item.attr,
+        _item$parser = item.parser,
+        parser = _item$parser === void 0 ? function (v) {
+      return v;
+    } : _item$parser;
+    var info = data.info;
+    var cacheKey = info.name + "-" + name;
+    Object.defineProperty(obj, name, {
+      enumerable: true,
+      get: function get() {
+        if (cache[cacheKey]) return cache[cacheKey];
+        if (item.value) return item.value;
+        var res = getStyleAttr(className, attr);
+        cache[cacheKey] = parser(res);
+        return cache[cacheKey];
+      },
+      // eslint-disable-next-line no-return-assign
+      set: function set(v) {
+        delete cache[cacheKey];
+        if (item.value) item.value = v;
+        data[name] = v;
+      }
+    });
+  });
+}
+
+var accessors = Object.keys(cssInject).reduce(function (obj, key) {
+  var _objectSpread2;
+
+  return _objectSpread({}, obj, (_objectSpread2 = {}, _objectSpread2[key] = {}, _objectSpread2));
+}, {});
+
+var _loop = function _loop() {
+  if (_isArray2) {
+    if (_i2 >= _iterator2.length) return "break";
+    _ref3 = _iterator2[_i2++];
+  } else {
+    _i2 = _iterator2.next();
+    if (_i2.done) return "break";
+    _ref3 = _i2.value;
+  }
+
+  var _ref4 = _ref3,
+      key = _ref4[0],
+      value = _ref4[1];
+  var setterName = "set" + capitalize(key);
+
+  value[setterName] = function (options) {
+    return setOptions.call(value, options, setterName);
+  };
+
+  genAccessors(value, cssInject[key]);
+};
+
+for (var _iterator2 = entries(accessors), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+  var _ref3;
+
+  var _ret = _loop();
+
+  if (_ret === "break") break;
+}
+
+export function cleanCache() {
+  cache = {};
+}
+export default accessors;

package/esm/utils/curry.d.ts

@@ -0,0 +1,24 @@
+export declare type CurriedFunction2<P0, P1, R> = {
+    (p0: P0): {
+        (p1: P1): R;
+    };
+    (p0: P0, p1: P1): R;
+};
+export declare type CurriedFunction3<P0, P1, P2, R> = {
+    (p0: P0, p1: P1, p2: P2): R;
+    (p0: P0, p1: P1): {
+        (p2: P2): R;
+    };
+    (p0: P0): CurriedFunction2<P1, P2, R>;
+};
+export declare type CurriedFunction4<P0, P1, P2, P3, R> = {
+    (p0: P0, p1: P1, p2: P2, p3: P3): R;
+    (p0: P0, p1: P1, p2: P2): {
+        (p3: P3): R;
+    };
+    (p0: P0, p1: P1): CurriedFunction2<P2, P3, R>;
+    (p0: P0): CurriedFunction3<P1, P2, P3, R>;
+};
+export declare function curry2<P0, P1, R>(fn: (p0: P0, p1: P1) => R): CurriedFunction2<P0, P1, R>;
+export declare function curry3<P0, P1, P2, R>(fn: (p0: P0, p1: P1, p2: P2) => R): CurriedFunction3<P0, P1, P2, R>;
+export declare function curry4<P0, P1, P2, P3, R>(fn: (p0: P0, p1: P1, p2: P2, p3: P3) => R): CurriedFunction4<P0, P1, P2, P3, R>;

package/esm/utils/curry.js

@@ -0,0 +1,23 @@
+// eslint-disable-next-line no-underscore-dangle
+var _curry = function _curry(fn) {
+  var curried = function curried() {
+    for (var _len = arguments.length, t = new Array(_len), _key = 0; _key < _len; _key++) {
+      t[_key] = arguments[_key];
+    }
+
+    return t.length >= fn.length ? fn.call.apply(fn, [this].concat(t)) : curried.bind.apply(curried, [this].concat(t));
+  };
+
+  return curried;
+}; // Functions
+
+
+export function curry2(fn) {
+  return _curry(fn);
+}
+export function curry3(fn) {
+  return _curry(fn);
+}
+export function curry4(fn) {
+  return _curry(fn);
+}

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

@@ -0,0 +1,12 @@
+export declare const TRANSFORMS: {
+    webkitTransform: string;
+    OTransform: string;
+    msTransform: string;
+    MozTransform: string;
+    transform: string;
+};
+export declare function getTransformName(): "transform" | "webkitTransform" | "msTransform" | "OTransform" | "MozTransform";
+export declare function has3d(): boolean;
+export declare const eventPassive: boolean | {
+    passive: boolean;
+};

package/esm/utils/dom/detect.js

@@ -0,0 +1,50 @@
+export var TRANSFORMS = {
+  webkitTransform: '-webkit-transform',
+  OTransform: '-o-transform',
+  msTransform: '-ms-transform',
+  MozTransform: '-moz-transform',
+  transform: 'transform'
+};
+var transform = 'transform';
+export function getTransformName() {
+  return transform;
+}
+export function has3d() {
+  if (!window.getComputedStyle) {
+    return false;
+  }
+
+  var el = document.createElement('p');
+  var result = ''; // Add it to the body to get the computed style.
+
+  document.body.insertBefore(el, null);
+  Object.keys(TRANSFORMS).forEach(function (t) {
+    if (el.style[t] !== undefined) {
+      ;
+      el.style[t] = 'translate3d(1px,1px,1px)';
+      transform = t;
+      result = window.getComputedStyle(el).getPropertyValue(TRANSFORMS[t]);
+    }
+  });
+  if (el && el.parentNode) el.parentNode.removeChild(el);
+  return result !== undefined && result.length > 0 && result !== 'none';
+}
+/* eslint-disable */
+// check support passive
+
+var supportsPassive = false;
+
+try {
+  var opts = Object.defineProperty({}, 'passive', {
+    get: function get() {
+      supportsPassive = true;
+    }
+  });
+  window.addEventListener('test', null, opts);
+} catch (e) {}
+/* eslint-enable */
+
+
+export var eventPassive = supportsPassive ? {
+  passive: true
+} : false;

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

@@ -0,0 +1,11 @@
+export declare const docScroll: {
+    top: number;
+    left: number;
+};
+export declare const docSize: {
+    readonly width: number;
+    readonly height: number;
+};
+export declare function addEventListener<K extends keyof HTMLElementEventMap>(target: HTMLElement | Document, eventType: keyof HTMLElementEventMap, cb: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, option?: boolean | AddEventListenerOptions): {
+    remove: () => void;
+};

package/esm/utils/dom/document.js

@@ -0,0 +1,43 @@
+export var docScroll = {
+  get top() {
+    return document.documentElement.scrollTop || document.body.scrollTop;
+  },
+
+  get left() {
+    return document.documentElement.scrollLeft || document.body.scrollLeft;
+  },
+
+  set top(value) {
+    document.documentElement.scrollTop = value;
+    document.body.scrollTop = value;
+  },
+
+  set left(value) {
+    document.documentElement.scrollLeft = value;
+    document.body.scrollLeft = value;
+  }
+
+};
+export var docSize = {
+  get width() {
+    return document.documentElement.clientWidth || document.body.clientWidth;
+  },
+
+  get height() {
+    return document.documentElement.clientHeight || document.body.clientHeight;
+  }
+
+};
+export function addEventListener(target, eventType, cb, option) {
+  if (target.addEventListener) {
+    target.addEventListener(eventType, cb, option);
+  }
+
+  return {
+    remove: function remove() {
+      if (target.removeEventListener) {
+        target.removeEventListener(eventType, cb);
+      }
+    }
+  };
+}

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

@@ -0,0 +1,37 @@
+import React, { ReactNode } from 'react';
+export declare function getParent(el: HTMLElement | null | Element, target?: string | HTMLElement): Element | null;
+export declare function wrapSpan(children: ReactNode, insertSpace?: boolean): any;
+export declare function dispatchEvent(form: HTMLFormElement, name: string, detail: any): void;
+export declare function cssSupport(attr: keyof CSSStyleDeclaration, value: string): boolean;
+export declare function copyBoundingClientRect(el: HTMLElement): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+} | null;
+export declare function getCursorOffset(length: number): any;
+declare function end<T extends HTMLElement & {
+    selectionStart?: number;
+}>(element: T): void;
+declare function select(element: HTMLElement): void;
+export declare const focusElement: {
+    select: typeof select;
+    end: typeof end;
+    wrapSpan: typeof wrapSpan;
+    copyBoundingClientRect: typeof copyBoundingClientRect;
+};
+export declare const preventPasteFile: (e: React.ClipboardEvent, beforeHandler?: Function | undefined, { noLineBreak, convertBr }?: {
+    noLineBreak?: boolean | undefined;
+    convertBr?: string | Function | undefined;
+}) => void;
+export declare const parsePxToNumber: (str: string) => number;
+interface ResizeOption {
+    direction?: 'x' | 'y' | boolean;
+    timer?: number;
+}
+export declare const addResizeObserver: (el: HTMLElement, handler: any, options?: ResizeOption) => () => void;
+export {};

package/esm/utils/dom/element.js

@@ -0,0 +1,262 @@
+var _this = this;
+
+import React from 'react';
+import { throttle } from '../func';
+
+if (Element && !Element.prototype.matches) {
+  var proto = Element.prototype;
+  proto.matches = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector;
+}
+
+export function getParent(el, target) {
+  if (!target) {
+    return null;
+  }
+
+  var temp = el;
+
+  while (temp) {
+    if (typeof target === 'string') {
+      if (temp.matches && temp.matches(target)) {
+        return temp;
+      }
+    } else if (temp === target) {
+      return temp;
+    }
+
+    temp = temp.parentElement;
+  }
+
+  return null;
+}
+
+var isTwoCNChar = function isTwoCNChar(str) {
+  return /^[\u4e00-\u9fa5]{2}$/.test(str);
+};
+
+var SPACE = ' ';
+export function wrapSpan(children, insertSpace) {
+  if (insertSpace === void 0) {
+    insertSpace = false;
+  }
+
+  if (!children) return children;
+  return React.Children.map(children, function (item) {
+    if (typeof item === 'string') {
+      if (insertSpace && isTwoCNChar(item)) return React.createElement("span", null, item.split('').join(SPACE));
+      return React.createElement("span", null, item);
+    }
+
+    return item;
+  });
+}
+export function dispatchEvent(form, name, detail) {
+  if (!form) return;
+  var event;
+
+  if (CustomEvent) {
+    event = new CustomEvent(name, {
+      bubbles: false,
+      cancelable: true,
+      detail: detail
+    });
+  } else {
+    event = document.createEvent('HTMLEvents');
+    event.initEvent(name, true, true);
+  }
+
+  form.dispatchEvent(event);
+}
+export function cssSupport(attr, value) {
+  var element = document.createElement('div');
+
+  if (attr in element.style) {
+    if (attr !== 'length' && attr !== 'parentRule') {
+      var attrs = element.style[attr];
+      element.style[attr] = value;
+    }
+
+    return element.style[attr] === value;
+  }
+
+  return false;
+}
+export function copyBoundingClientRect(el) {
+  if (!el) return null;
+  var rect = el.getBoundingClientRect();
+  return {
+    top: rect.top,
+    right: rect.right,
+    bottom: rect.bottom,
+    left: rect.left,
+    width: rect.width,
+    height: rect.height,
+    x: rect.x,
+    y: rect.y
+  };
+}
+export function getCursorOffset(length) {
+  if (window.getSelection) {
+    return window.getSelection().anchorOffset;
+  }
+
+  if (document.selection) {
+    var range = document.selection.createRange();
+    range.moveStart('character', -length);
+    return range.text.length;
+  }
+
+  return null;
+}
+
+function end(element) {
+  if (!element) return;
+  element.focus();
+
+  if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
+    element.selectionStart = -1;
+    return;
+  }
+
+  if (window.getSelection) {
+    var range = window.getSelection();
+
+    if (range) {
+      range.selectAllChildren(element);
+      range.collapseToEnd();
+    }
+  } else if (document.selection) {
+    var _range = document.selection.createRange();
+
+    _range.moveToElementText(element);
+
+    _range.collapse(false);
+
+    _range.select();
+  }
+}
+
+function select(element) {
+  if (element && element.innerText && element.innerText.length === 0) {
+    element.focus();
+    return;
+  }
+
+  if (window.getSelection && document.createRange) {
+    if (element) element.focus();
+    var range = document.createRange();
+    if (element) range.selectNodeContents(element);
+    var sel = window.getSelection();
+
+    if (sel) {
+      sel.removeAllRanges();
+      sel.addRange(range);
+    }
+  } else if (document.selection) {
+    var _range2 = document.selection.createRange();
+
+    _range2.moveToElementText(element);
+
+    _range2.select();
+  }
+}
+
+export var focusElement = {
+  select: select,
+  end: end,
+  wrapSpan: wrapSpan,
+  copyBoundingClientRect: copyBoundingClientRect
+};
+export var preventPasteFile = function preventPasteFile(e, beforeHandler, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      _ref$noLineBreak = _ref.noLineBreak,
+      noLineBreak = _ref$noLineBreak === void 0 ? true : _ref$noLineBreak,
+      _ref$convertBr = _ref.convertBr,
+      convertBr = _ref$convertBr === void 0 ? ' ' : _ref$convertBr;
+
+  var text = (e.clipboardData || window.clipboardData).getData('text/plain'); // 删除复制的换行符号
+
+  if (noLineBreak && text) {
+    if (typeof convertBr === 'function') {
+      text = convertBr(text).replace(/([\t\n\f\r\v])+/g, ' ');
+    } else {
+      text = text.replace(/([\t\n\f\r\v])+/g, convertBr);
+    }
+  }
+
+  e.preventDefault();
+
+  if (beforeHandler) {
+    beforeHandler(text);
+  }
+
+  document.execCommand('insertText', false, text);
+};
+export var parsePxToNumber = function parsePxToNumber(str) {
+  return Number(str.replace(/\s+|px/gi, ''));
+};
+export var addResizeObserver = function addResizeObserver(el, handler, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var _options = options,
+      direction = _options.direction,
+      timer = _options.timer;
+
+  var _throttle = throttle(handler, timer),
+      throttleHandler = _throttle[0],
+      cleanTimer = _throttle[1];
+
+  var h = throttleHandler;
+  var lastWidth;
+  var lastHeight;
+
+  if (window.ResizeObserver) {
+    if (direction) {
+      lastWidth = el.clientWidth;
+      lastHeight = el.clientHeight;
+
+      h = function h(entry) {
+        var _entry$0$contentRect = entry[0].contentRect,
+            width = _entry$0$contentRect.width,
+            height = _entry$0$contentRect.height;
+
+        if (width && direction === 'x') {
+          if (lastWidth !== width) {
+            throttleHandler(entry);
+          }
+        } else if (direction === 'y') {
+          if (height && lastHeight !== height) {
+            throttleHandler(entry);
+          }
+        } else if (width && height) {
+          throttleHandler(entry, {
+            x: lastWidth !== width,
+            y: lastHeight !== height
+          });
+        }
+
+        lastWidth = width;
+        lastHeight = height;
+      };
+    }
+
+    var observer = new ResizeObserver(h);
+    observer.observe(el);
+    return function () {
+      if (observer) {
+        observer.disconnect();
+      }
+
+      cleanTimer(_this);
+      observer = null;
+    };
+  }
+
+  window.addEventListener('resize', throttleHandler);
+  return function () {
+    window.removeEventListener('resize', handler);
+    cleanTimer();
+  };
+};

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

@@ -0,0 +1,4 @@
+declare const _default: <T extends {}>(props?: T | undefined) => {
+    [key: string]: T[keyof T];
+};
+export default _default;