shineout 1.12.2 → 1.12.3

package/esm/utils/flat.js

@@ -0,0 +1,166 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+// https://stackoverflow.com/questions/19098797/fastest-way-to-flatten-un-flatten-nested-json-objects
+import { isEmpty, isObject } from './is';
+import { deepClone } from './clone';
+export function insertPoint(name) {
+  var reg = /(\[\d+\])/gi;
+  return name.replace(reg, function (s, m, i) {
+    return s.replace(m, i === 0 ? m : "." + m);
+  });
+}
+export function flatten(data, skipArray) {
+  if (isEmpty(data)) return data;
+  var result = {};
+
+  function recurse(cur, prop) {
+    if (Object(cur) !== cur || typeof cur === 'function' || cur instanceof Date || cur instanceof Error || skipArray && Array.isArray(cur)) {
+      if (!(cur === undefined && /\[\d+\]$/.test(prop))) {
+        result[prop] = cur;
+      }
+    } else if (Array.isArray(cur)) {
+      if (cur.length === 0) {
+        result[prop] = [];
+      } else {
+        for (var i = 0, l = cur.length; i < l; i++) {
+          recurse(cur[i], prop ? prop + "[" + i + "]" : "[" + i + "]");
+        }
+      }
+    } else {
+      var empty = true;
+
+      if (typeof cur === 'object') {
+        // eslint-disable-next-line
+        for (var p in cur) {
+          empty = false;
+          recurse(cur[p], prop ? prop + "." + p : p);
+        }
+
+        if (empty) {
+          result[prop] = {};
+        }
+      }
+    }
+  }
+
+  recurse(data, '');
+  return result;
+}
+export function unflatten(rawdata) {
+  if (Object(rawdata) !== rawdata || isEmpty(rawdata) || Array.isArray(rawdata)) {
+    return rawdata;
+  }
+
+  var data = _objectSpread({}, rawdata);
+
+  var result = {}; // let { cur, prop, idx, last, temp, match } = {}
+
+  var cur;
+  var prop;
+  var idx;
+  var last;
+  var temp;
+  var match; // eslint-disable-next-line
+
+  Object.keys(data).sort().forEach(function (p) {
+    var pathWithPoint = insertPoint(p);
+    cur = result;
+    prop = '';
+    last = 0;
+
+    do {
+      idx = pathWithPoint.indexOf('.', last);
+      temp = pathWithPoint.substring(last, idx !== -1 ? idx : undefined);
+      match = /^\[(\d+)\]$/.exec(temp);
+      cur = cur[prop] || (cur[prop] = match ? [] : {});
+      prop = match ? match[1] : temp;
+      last = idx + 1;
+    } while (idx >= 0);
+
+    cur[prop] = deepClone(data[p]);
+  });
+  return result[''];
+}
+export function insertValue(obj, name, index, value) {
+  var _flatten;
+
+  Object.keys(obj).filter(function (n) {
+    return n.indexOf(name + "[") === 0;
+  }).sort().reverse().forEach(function (n) {
+    // const reg = new RegExp(`${name}\\[(\\d+)\\]`)
+    var reg = new RegExp(name.replace(/\[/g, '\\[').replace(/\]/g, '\\]') + "\\[(\\d+)\\]");
+    var match = reg.exec(n);
+    var i = parseInt(match[1], 10);
+    if (i < index) return;
+    var newName = n.replace(reg, name + "[" + (i + 1) + "]");
+    if (obj[n]) obj[newName] = obj[n];
+    delete obj[n];
+  });
+  var newValue = flatten((_flatten = {}, _flatten[name + "[" + index + "]"] = value, _flatten));
+  Object.keys(newValue).forEach(function (k) {
+    if (newValue[k] !== undefined) obj[k] = newValue[k];
+  });
+}
+export function spliceValue(obj, name, index) {
+  var names = Object.keys(obj).filter(function (n) {
+    return n === name || n.indexOf(name + "[") === 0;
+  }).sort();
+  names.forEach(function (n) {
+    if (n === name && !Array.isArray(obj[name])) return;
+
+    if (n === name) {
+      obj[name].splice(index, 1);
+      return;
+    }
+
+    var reg = new RegExp(name.replace(/\[/g, '\\[').replace(/\]/g, '\\]') + "\\[(\\d+)\\]");
+    var match = reg.exec(n);
+    var i = parseInt(match[1], 10);
+    if (i < index) return;
+
+    if (i === index) {
+      delete obj[n];
+      return;
+    }
+
+    var newName = n.replace(reg, name + "[" + (i - 1) + "]");
+    obj[newName] = obj[n];
+    delete obj[n];
+  });
+}
+
+var isNameWithPath = function isNameWithPath(name, path) {
+  if (name.indexOf(path) !== 0) return false;
+  var remain = name.replace(path, '')[0];
+  return [undefined, '[', '.'].includes(remain);
+};
+
+export var getSthByName = function getSthByName(name, source) {
+  if (source[name]) return source[name];
+  var result = unflatten(source);
+  name = insertPoint(name);
+  name.split('.').forEach(function (n) {
+    var match = /^\[(\d+)\]$/.exec(n); // eslint-disable-next-line
+
+    if (match) n = match[1];
+    if (result) result = result[n];else result = undefined;
+  }); // get from form-error
+
+  if (!result && isObject(source[''])) result = source[''][name];
+  return result;
+};
+export var removeSthByName = function removeSthByName(name, source) {
+  var match = /(.*)\[(\d+)\]$/.exec(name);
+
+  if (match) {
+    spliceValue(source, match[1], parseInt(match[2], 10));
+  } else {
+    Object.keys(source).forEach(function (n) {
+      if (isNameWithPath(n, name)) delete source[n];
+    });
+  }
+};
+export var flattenArray = function flattenArray(arr1) {
+  return arr1.reduce(function (acc, val) {
+    return Array.isArray(val) ? acc.concat(flattenArray(val)) : acc.concat(val);
+  }, []);
+};

package/esm/utils/func.d.ts

@@ -0,0 +1,25 @@
+/**
+ * from redux.compose https://github.com/reactjs/redux/blob/master/src/compose.js
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for
+ * the resulting composite function.
+ *
+ * @param {...Function} funcs The functions to compose.
+ * @returns {Function} A function obtained by composing the argument functions
+ * from right to left. For example, compose(f, g, h) is identical to doing
+ * (...args) => f(g(h(...args))).
+ */
+declare type AnyFunction = (...args: any) => any;
+export { compose } from './compose';
+export * from './curry';
+export declare function curry<U extends AnyFunction>(f: U, ...args: any): any;
+export declare function empty(e: {
+    preventDefault: () => void;
+}): void;
+export declare function memoize<T extends Function>(fn: T & {
+    cache?: {
+        [name: string]: any;
+    };
+}): (key: string) => any;
+export declare function createFunc(func?: Function | string): Function;
+export declare const throttle: (func: Function, timer?: number | undefined) => Function[];

package/esm/utils/func.js

@@ -0,0 +1,72 @@
+/**
+ * from redux.compose https://github.com/reactjs/redux/blob/master/src/compose.js
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for
+ * the resulting composite function.
+ *
+ * @param {...Function} funcs The functions to compose.
+ * @returns {Function} A function obtained by composing the argument functions
+ * from right to left. For example, compose(f, g, h) is identical to doing
+ * (...args) => f(g(h(...args))).
+ */
+export { compose } from './compose';
+export * from './curry';
+export function curry(f) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  if (args.length >= f.length) {
+    return f.apply(void 0, args);
+  }
+
+  return function () {
+    for (var _len2 = arguments.length, next = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      next[_key2] = arguments[_key2];
+    }
+
+    return curry.apply(void 0, [f.bind.apply(f, [f].concat(args))].concat(next));
+  };
+}
+export function empty(e) {
+  e.preventDefault();
+}
+export function memoize(fn) {
+  return function (key) {
+    fn.cache = fn.cache || {};
+
+    if (!(key in fn.cache)) {
+      fn.cache[key] = fn(key);
+    }
+
+    return fn.cache[key];
+  };
+}
+export function createFunc(func) {
+  if (typeof func === 'function') return func;
+  return function (data) {
+    return func ? data[func] : data;
+  };
+}
+export var throttle = function throttle(func, timer) {
+  var that = {};
+
+  var cleanTimer = function cleanTimer() {
+    if (that.timer) {
+      clearTimeout(that.timer);
+      that.timer = null;
+    }
+  };
+
+  if (!timer) return [func, cleanTimer];
+  return [function () {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+
+    cleanTimer();
+    that.timer = setTimeout(function () {
+      func.apply(void 0, args);
+    }, timer);
+  }, cleanTimer];
+};

package/esm/utils/hash.d.ts

@@ -0,0 +1 @@
+export default function createHash(obj: any): string | number;

package/esm/utils/hash.js

@@ -0,0 +1,36 @@
+export default function createHash(obj) {
+  var hash = 0;
+  var i;
+  var chr;
+  var len;
+  var str;
+  var type = typeof obj;
+
+  switch (type) {
+    case 'object':
+      str = JSON.stringify(obj);
+      break;
+
+    case 'string':
+      str = obj;
+      break;
+
+    default:
+      str = obj ? obj.toString() : '';
+      break;
+  }
+
+  if (typeof str === 'string') {
+    if (str.length === 0) return hash;
+
+    for (i = 0, len = str.length; i < len; i++) {
+      chr = str.charCodeAt(i); // eslint-disable-next-line
+
+      hash = (hash << 5) - hash + chr; // eslint-disable-next-line
+
+      hash |= 0; // Convert to 32bit integer
+    }
+  }
+
+  return hash.toString(36);
+}

package/esm/utils/index.d.ts

@@ -0,0 +1,24 @@
+import classname from './classname';
+import * as clone from './clone';
+import * as color from './color';
+import * as flat from './flat';
+import * as func from './func';
+import hash from './hash';
+import * as is from './is';
+import * as number from './numbers';
+import * as objects from './objects';
+import shallowEqual from './shallowEqual';
+import * as string from './strings';
+import * as tree from './tree';
+import * as detect from './dom/detect';
+import * as doc from './dom/document';
+import * as element from './dom/element';
+import normalizeWheel from './dom/normalizeWheel';
+import * as position from './dom/popover';
+import ready from './dom/ready';
+import isJson from './validate/isJson';
+import validate from './validate';
+import cssAccessors from './css-accessors';
+import cssInject from './vars-inject';
+import accept from './accept';
+export { classname, clone, color, flat, func, hash, is, number, objects, shallowEqual, string, tree, detect, doc, element, normalizeWheel, position, ready, isJson, validate, cssAccessors, cssInject, accept, };

package/esm/utils/index.js

@@ -0,0 +1,24 @@
+import classname from './classname';
+import * as clone from './clone';
+import * as color from './color';
+import * as flat from './flat';
+import * as func from './func';
+import hash from './hash';
+import * as is from './is';
+import * as number from './numbers';
+import * as objects from './objects';
+import shallowEqual from './shallowEqual';
+import * as string from './strings';
+import * as tree from './tree';
+import * as detect from './dom/detect';
+import * as doc from './dom/document';
+import * as element from './dom/element';
+import normalizeWheel from './dom/normalizeWheel';
+import * as position from './dom/popover';
+import ready from './dom/ready';
+import isJson from './validate/isJson';
+import validate from './validate';
+import cssAccessors from './css-accessors';
+import cssInject from './vars-inject';
+import accept from './accept';
+export { classname, clone, color, flat, func, hash, is, number, objects, shallowEqual, string, tree, detect, doc, element, normalizeWheel, position, ready, isJson, validate, cssAccessors, cssInject, accept };

package/esm/utils/is.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+export declare const isArray: (arg: any) => arg is any[];
+export declare const isUndef: (v: unknown) => boolean;
+export declare const isNotUndef: (v: unknown) => boolean;
+export declare const isNan: (a: unknown) => boolean;
+export declare const isFunc: (f: unknown) => f is Function;
+export declare const isNumber: (n: unknown) => n is number;
+export declare const isObject: (val: unknown) => val is Object;
+export declare const isString: (s: unknown) => s is String;
+export declare const isDate: (val: unknown) => boolean;
+export declare const isError: (val: unknown) => boolean;
+export declare const isRegexp: (val: unknown) => boolean;
+export declare const isMap: any;
+export declare const isSet: any;
+export declare const isSymbol: any;
+export declare const isPromise: (p: unknown) => p is Promise<any>;
+export declare const isValidKey: (key: string | number | symbol, object: object) => key is never;
+export declare const isInPath: (val: unknown, path: string) => boolean;
+export declare const isEmpty: (val: unknown) => boolean;
+export declare const isBuffer: (val: unknown) => boolean;
+export declare const isMergeable: (val: unknown) => boolean;
+export declare const isOne: (val: unknown) => boolean;
+export declare const isPercent: (n: unknown) => boolean;
+export declare const isInseparable: (val: unknown) => boolean;
+export declare const isLink: (el: unknown) => el is React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare const isEnterPress: (e: unknown) => boolean;
+export declare const isMacOS: () => boolean;
+export declare const isFirefox: () => boolean;

package/esm/utils/is.js

@@ -0,0 +1,111 @@
+import React from 'react';
+import { curry } from './func';
+var nameIs = curry(function (name, val) {
+  if (typeof val === 'object') {
+    return val && val.constructor && val.constructor.name === name;
+  }
+
+  return false;
+}); // eslint-disable-next-line
+
+export var isArray = Array.isArray;
+export var isUndef = function isUndef(v) {
+  return v == null;
+};
+export var isNotUndef = function isNotUndef(v) {
+  return v != null;
+}; // eslint-disable-next-line
+
+export var isNan = function isNan(a) {
+  return a !== a;
+};
+export var isFunc = function isFunc(f) {
+  return typeof f === 'function';
+};
+export var isNumber = function isNumber(n) {
+  return typeof n === 'number';
+};
+export var isObject = function isObject(val) {
+  return !!val && typeof val === 'object' && !isArray(val);
+};
+export var isString = function isString(s) {
+  return typeof s === 'string';
+};
+export var isDate = function isDate(val) {
+  return val instanceof Date;
+};
+export var isError = function isError(val) {
+  return val instanceof Error;
+};
+export var isRegexp = function isRegexp(val) {
+  return val instanceof RegExp;
+};
+export var isMap = nameIs('Map');
+export var isSet = nameIs('Set');
+export var isSymbol = nameIs('Symbol');
+export var isPromise = function isPromise(p) {
+  return p && (nameIs('Promise', p) || isFunc(p.then));
+};
+export var isValidKey = function isValidKey(key, object) {
+  return key in object;
+};
+export var isInPath = function isInPath(val, path) {
+  if (val === path) return true;
+  return path.indexOf(val + "[") === 0 || path.indexOf(val + ".") === 0;
+};
+export var isEmpty = function isEmpty(val) {
+  if (val == null) return true;
+  if (isNan(val)) return true;
+  if (val.length !== undefined) return val.length === 0;
+  if (val instanceof Date) return false;
+  if (typeof val === 'object') return Object.keys(val).length === 0;
+  return false;
+};
+export var isBuffer = function isBuffer(val) {
+  if (val && typeof val === 'object' && val.constructor && typeof val.constructor.isBuffer === 'function') {
+    return val.constructor.isBuffer(val);
+  }
+
+  return false;
+};
+export var isMergeable = function isMergeable(val) {
+  if (!isObject(val)) return false;
+  var fns = [isDate, isError, isRegexp, isMap, isSet, isBuffer];
+
+  for (var i = 0; i < fns.length; i++) {
+    if (fns[i](val)) return false;
+  }
+
+  return true;
+};
+export var isOne = function isOne(val) {
+  if (val === 1) return true;
+  return typeof val === 'string' && val.indexOf('.') !== -1 && parseFloat(val) === 1;
+}; // /\d{1,3}%$/
+
+export var isPercent = function isPercent(n) {
+  return typeof n === 'string' && /\d{1,3}%$/.test(n);
+};
+export var isInseparable = function isInseparable(val) {
+  return Object(val) !== val || isFunc(val) || isDate(val) || isError(val) || isSet(val) || isMap(val) || isRegexp(val);
+};
+export var isLink = function isLink(el) {
+  if (typeof el === 'object') {
+    if (!React.isValidElement(el)) return false;
+    if (!el.type) return false;
+    if (el.type === 'a') return true;
+    if (el.props && el.props.to) return true;
+  }
+
+  return false;
+};
+export var isEnterPress = function isEnterPress(e) {
+  if (typeof e !== 'object') return false;
+  return e.keyCode === 13;
+};
+export var isMacOS = function isMacOS() {
+  return /macintosh|mac os x/i.test(navigator.userAgent);
+};
+export var isFirefox = function isFirefox() {
+  return navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
+};

package/esm/utils/lazyload.d.ts

@@ -0,0 +1,13 @@
+declare type LazyConfig = {
+    container?: Element | null;
+    element: Element;
+    render: Function;
+    offset: number;
+    noRemove?: boolean;
+    observer?: IntersectionObserver;
+};
+export declare function dispatch(): void;
+export declare function removeStack(id?: string | null, removeListener?: boolean): void;
+export declare function addStack(obj: LazyConfig): string | null;
+export declare function throttleWrapper(cb: Function): (...args: any[]) => void;
+export {};

package/esm/utils/lazyload.js

@@ -0,0 +1,136 @@
+import { eventPassive } from './dom/detect';
+import { getUidStr } from './uid';
+import { docSize } from './dom/document';
+var throttle = 80;
+var components = {};
+var timeout = null;
+var isLock = false;
+var winHeight = docSize.height;
+
+var getRect = function getRect(el) {
+  // document or invalid element
+  if (!el || !el.getBoundingClientRect) {
+    if (el) console.error("the " + el + " is not a element");
+    return {
+      top: 0,
+      bottom: winHeight
+    };
+  }
+
+  return el.getBoundingClientRect();
+};
+
+export function dispatch() {
+  if (isLock) return;
+  isLock = true; // handle
+
+  Object.keys(components).forEach(function (k) {
+    var _components$k = components[k],
+        element = _components$k.element,
+        render = _components$k.render,
+        container = _components$k.container,
+        offset = _components$k.offset,
+        noRemove = _components$k.noRemove;
+    var rect = element.getBoundingClientRect();
+    var containerRect = getRect(container);
+    if (rect.bottom + offset < containerRect.top || rect.top - offset > containerRect.bottom) return;
+    if (!noRemove) delete components[k];
+    render();
+  });
+  isLock = false;
+}
+
+var handleScroll = function handleScroll() {
+  if (timeout) clearTimeout(timeout);
+  timeout = setTimeout(function () {
+    dispatch();
+    timeout = null;
+  }, throttle);
+};
+
+export function removeStack(id, removeListener) {
+  if (!id || !components[id]) return;
+  var _components$id = components[id],
+      observer = _components$id.observer,
+      container = _components$id.container;
+  var scrollEl = container || document;
+
+  if (window.IntersectionObserver) {
+    if (observer && observer.disconnect) observer.disconnect();
+  } else if (removeListener) {
+    scrollEl.removeEventListener('scroll', handleScroll);
+  }
+
+  delete components[id];
+}
+
+function getObserver(obj, id) {
+  var _obj$container = obj.container,
+      container = _obj$container === void 0 ? null : _obj$container,
+      offset = obj.offset,
+      render = obj.render,
+      noRemove = obj.noRemove;
+  var observer = new IntersectionObserver(function (entries) {
+    entries.forEach(function (en) {
+      if (en.isIntersecting || en.intersectionRatio > 0) {
+        render();
+        if (!noRemove) removeStack(id);
+      }
+    });
+  }, {
+    root: container,
+    rootMargin: offset + "px"
+  });
+  obj.observer = observer;
+  return observer;
+}
+
+export function addStack(obj) {
+  var id = getUidStr();
+  var scrollEl = obj.container || document;
+  obj.offset = obj.offset || 0;
+
+  if (window.IntersectionObserver) {
+    components[id] = obj;
+    var observer = getObserver(obj, id);
+    observer.observe(obj.element);
+    return id;
+  }
+
+  scrollEl.addEventListener('scroll', handleScroll, eventPassive);
+  var rect = obj.element.getBoundingClientRect();
+  var containerRect = getRect(obj.container);
+
+  if (rect.bottom + obj.offset < containerRect.top || rect.top - obj.offset > containerRect.bottom) {
+    components[id] = obj;
+    return id;
+  }
+
+  obj.render();
+
+  if (obj.noRemove) {
+    components[id] = obj;
+    return id;
+  }
+
+  return null;
+}
+export function throttleWrapper(cb) {
+  var _this = this;
+
+  var timer = null;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var ctx = _this;
+
+    if (!timer) {
+      timer = setTimeout(function () {
+        cb.apply(ctx, args);
+        timer = null;
+      }, throttle);
+    }
+  };
+}

package/esm/utils/notification.d.ts

@@ -0,0 +1,15 @@
+interface Listener extends Function {
+    (...args: any[]): void;
+    fn?: Listener;
+}
+interface Events {
+    [event: string]: Listener[];
+}
+export default class Notification {
+    $events: Events;
+    constructor();
+    dispatch(name: keyof Events, ...args: any[]): void;
+    subscribe(name: keyof Events, fn: Listener): void;
+    unsubscribe(name: keyof Events, fn: Listener): void;
+}
+export {};