@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/cjs/utils/getHighlight.js

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findAll = void 0;
+
+var _isString2 = _interopRequireDefault(require("lodash/isString"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const escapeRegExpFn = string => string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+/**
+   * Examine text for any matches.
+   * If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}).
+   * @return { start:number, end:number }[]
+   */
+
+
+const findChunks = _ref => {
+  let {
+    autoEscape,
+    caseSensitive,
+    searchWords,
+    sourceString
+  } = _ref;
+  return searchWords.filter(searchWord => searchWord) // Remove empty words
+  .reduce((chunks, searchWord) => {
+    if (autoEscape) {
+      searchWord = escapeRegExpFn(searchWord);
+    }
+
+    const regex = new RegExp(searchWord, caseSensitive ? 'g' : 'gi');
+    let match;
+
+    while (match = regex.exec(sourceString)) {
+      const start = match.index;
+      const end = regex.lastIndex; // We do not return zero-length matches
+
+      if (end > start) {
+        chunks.push({
+          highlight: false,
+          start,
+          end
+        });
+      } // Prevent browsers like Firefox from getting stuck in an infinite loop
+      // See http://www.regexguru.com/2008/04/watch-out-for-zero-length-matches/
+
+
+      if (match.index === regex.lastIndex) {
+        regex.lastIndex++;
+      }
+    }
+
+    return chunks;
+  }, []);
+};
+/**
+   * Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks.
+   * @return {start:number, end:number}[]
+   */
+
+
+const combineChunks = _ref2 => {
+  let {
+    chunks
+  } = _ref2;
+  chunks = chunks.sort((first, second) => first.start - second.start).reduce((processedChunks, nextChunk) => {
+    // First chunk just goes straight in the array...
+    if (processedChunks.length === 0) {
+      return [nextChunk];
+    } else {
+      // ... subsequent chunks get checked to see if they overlap...
+      const prevChunk = processedChunks.pop();
+
+      if (nextChunk.start <= prevChunk.end) {
+        // It may be the case that prevChunk completely surrounds nextChunk, so take the
+        // largest of the end indeces.
+        const endIndex = Math.max(prevChunk.end, nextChunk.end);
+        processedChunks.push({
+          highlight: false,
+          start: prevChunk.start,
+          end: endIndex
+        });
+      } else {
+        processedChunks.push(prevChunk, nextChunk);
+      }
+
+      return processedChunks;
+    }
+  }, []);
+  return chunks;
+};
+/**
+   * Given a set of chunks to highlight, create an additional set of chunks
+   * to represent the bits of text between the highlighted text.
+   * @param chunksToHighlight {start:number, end:number}[]
+   * @param totalLength number
+   * @return {start:number, end:number, highlight:boolean}[]
+   */
+
+
+const fillInChunks = _ref3 => {
+  let {
+    chunksToHighlight,
+    totalLength
+  } = _ref3;
+  const allChunks = [];
+
+  const append = (start, end, highlight) => {
+    if (end - start > 0) {
+      allChunks.push({
+        start,
+        end,
+        highlight
+      });
+    }
+  };
+
+  if (chunksToHighlight.length === 0) {
+    append(0, totalLength, false);
+  } else {
+    let lastIndex = 0;
+    chunksToHighlight.forEach(chunk => {
+      append(lastIndex, chunk.start, false);
+      append(chunk.start, chunk.end, true);
+      lastIndex = chunk.end;
+    });
+    append(lastIndex, totalLength, false);
+  }
+
+  return allChunks;
+};
+/**
+ * Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word.
+ *
+    findAll ['z'], 'aaazaaazaaa'
+        result #=> [
+            { start: 0, end: 3, highlight: false }
+            { start: 3, end: 4, highlight: true }
+            { start: 4, end: 7, highlight: false }
+            { start: 7, end: 8, highlight: true }
+            { start: 8, end: 11, highlight: false }
+        ]
+
+    findAll ['do', 'dollar'], 'aaa do dollar aaa'
+        #=> chunks: [
+                { start: 4, end: 6 },
+                { start: 7, end: 9 },
+                { start: 7, end: 13 },
+            ]
+        #=> chunksToHight: [
+                { start: 4, end: 6 },
+                { start: 7, end: 13 },
+            ]
+        #=> result: [
+                { start: 0, end: 4, highlight: false },
+                { start: 4, end: 6, highlight: true },
+                { start: 6, end: 7, highlight: false },
+                { start: 7, end: 13, highlight: true },
+                { start: 13, end: 17, highlight: false },
+            ]
+
+ * @return Array of "chunks" (where a Chunk is { start:number, end:number, highlight:boolean })
+ */
+
+
+const findAll = _ref4 => {
+  let {
+    autoEscape = true,
+    caseSensitive = false,
+    searchWords,
+    sourceString
+  } = _ref4;
+
+  if ((0, _isString2.default)(searchWords)) {
+    searchWords = [searchWords];
+  }
+
+  const chunks = findChunks({
+    autoEscape,
+    caseSensitive,
+    searchWords,
+    sourceString
+  });
+  const chunksToHighlight = combineChunks({
+    chunks
+  });
+  const result = fillInChunks({
+    chunksToHighlight,
+    totalLength: sourceString ? sourceString.length : 0
+  });
+  return result;
+};
+
+exports.findAll = findAll;

package/lib/cjs/utils/getMotionObjFromProps.d.ts

@@ -0,0 +1,26 @@
+import { MotionObject } from "./type";
+export interface MergeMotionProps {
+    [x: string]: any;
+    motion?: any;
+    willEnter?: () => void;
+    didEnter?: () => void;
+    willLeave?: () => void;
+    didLeave?: () => void;
+    onStart?: () => void;
+    onRest?: () => void;
+    state?: Record<string, any>;
+}
+/**
+ * get motion object from props
+ *
+ * example:
+ *
+ * ```
+ *  props = { didLeave: componentHandler, motion: { didLeave: userHandler } };
+ *  return { didLeave: () => { componentHandler(); userHandler(); }};
+ * ```
+ *
+ * @param { props: Object }
+ * @returns { motion: Object }
+ */
+export default function getMotionObjFromProps(props: MergeMotionProps): MotionObject;

package/lib/cjs/utils/getMotionObjFromProps.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getMotionObjFromProps;
+
+var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
+
+var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _warning = _interopRequireDefault(require("./warning"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * get motion object from props
+ *
+ * example:
+ *
+ * ```
+ *  props = { didLeave: componentHandler, motion: { didLeave: userHandler } };
+ *  return { didLeave: () => { componentHandler(); userHandler(); }};
+ * ```
+ *
+ * @param { props: Object }
+ * @returns { motion: Object }
+ */
+function getMotionObjFromProps(props) {
+  if (typeof props !== 'object' || props === null) {
+    throw new TypeError(`props should be object type, got ${typeof props}`);
+  }
+
+  const MOTION_PROPS = ['willEnter', 'didEnter', 'willLeave', 'didLeave', 'onStart', 'onRest', 'state'];
+  const {
+    motion: motionProp = {}
+  } = props;
+  let motion = {};
+
+  if ((0, _isObject2.default)(motionProp)) {
+    motion = (0, _cloneDeep2.default)(motionProp);
+
+    for (const key of Object.keys(motionProp)) {
+      const handler = motionProp[key];
+
+      if (typeof handler === 'function') {
+        if (key in props) {
+          motion[key] = () => {
+            props[key](); // call handler function of semi build-in components firstly
+
+            handler(); // call user given handler function
+          };
+        }
+      } else {
+        (0, _warning.default)(true, `[Semi] duplicate motion key '${key}' from motion prop and props`);
+      }
+    }
+  } else if (typeof motionProp === 'function') {
+    const motionFnResult = motionProp(props);
+    motion = (0, _isObject2.default)(motionFnResult) ? motionFnResult : {};
+  }
+
+  if ((0, _isObject2.default)(motion)) {
+    for (const key of MOTION_PROPS) {
+      if (key in props && !(key in motion)) {
+        motion[key] = props[key];
+      }
+    }
+  }
+
+  return motion;
+}

package/lib/cjs/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classnames';
+export * from './function';

package/lib/cjs/utils/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classnames = require("./classnames");
+
+Object.keys(_classnames).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _classnames[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _classnames[key];
+    }
+  });
+});
+
+var _function = require("./function");
+
+Object.keys(_function).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _function[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _function[key];
+    }
+  });
+});

package/lib/cjs/utils/isBothNaN.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Determine whether both values are NaN
+ * @param {*} a
+ * @param {*} b
+ * @returns {Boolean}
+ */
+declare const isBothNaN: (a: any, b: any) => boolean;
+export default isBothNaN;

package/lib/cjs/utils/isBothNaN.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * Determine whether both values are NaN
+ * @param {*} a
+ * @param {*} b
+ * @returns {Boolean}
+ */
+const isBothNaN = (a, b) => {
+  const {
+    isNaN
+  } = Number;
+  return isNaN(a) && isNaN(b);
+};
+
+var _default = isBothNaN;
+exports.default = _default;

package/lib/cjs/utils/isElement.d.ts

@@ -0,0 +1 @@
+export default function isElement(obj: any): boolean;

package/lib/cjs/utils/isElement.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isElement;
+
+/* istanbul ignore next */
+function isElement(obj) {
+  try {
+    // Using W3 DOM2 (works for FF, Opera and Chrome)
+    return obj instanceof HTMLElement;
+  } catch (e) {
+    // Browsers not supporting W3 DOM2 don't have HTMLElement and
+    // an exception is thrown and we end up here. Testing some
+    // properties that all elements have (works on IE7)
+    return typeof obj === 'object' && obj.nodeType === 1 && typeof obj.style === 'object' && typeof obj.ownerDocument === 'object';
+  }
+}

package/lib/cjs/utils/isEnterPress.d.ts

@@ -0,0 +1,4 @@
+declare function isEnterPress<T extends {
+    key: string;
+}>(e: T): boolean;
+export default isEnterPress;

package/lib/cjs/utils/isEnterPress.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+var _keyCode = require("./keyCode");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isEnterPress(e) {
+  return (0, _get2.default)(e, 'key') === _keyCode.ENTER_KEY ? true : false;
+}
+
+var _default = isEnterPress;
+exports.default = _default;

package/lib/cjs/utils/isEscPress.d.ts

@@ -0,0 +1,4 @@
+declare function isEscPress<T extends {
+    key: string;
+}>(e: T): boolean;
+export default isEscPress;

package/lib/cjs/utils/isEscPress.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+var _keyCode = require("./keyCode");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* istanbul ignore next */
+function isEscPress(e) {
+  return (0, _get2.default)(e, 'key') === _keyCode.ESC_KEY ? true : false;
+}
+
+var _default = isEscPress;
+exports.default = _default;

package/lib/cjs/utils/isNullOrUndefined.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether null or undefined
+ * @param {*} value
+ * @returns  {boolean}
+ */
+export default function isNullOrUndefined(value: any): boolean;

package/lib/cjs/utils/isNullOrUndefined.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNullOrUndefined;
+
+/**
+ * Whether null or undefined
+ * @param {*} value
+ * @returns  {boolean}
+ */
+function isNullOrUndefined(value) {
+  return value === null || value === undefined;
+}

package/lib/cjs/utils/isNumber.d.ts

@@ -0,0 +1 @@
+export default function isNumber(value: any): boolean;

package/lib/cjs/utils/isNumber.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNumber;
+
+function isNumber(value) {
+  return typeof value === 'number' || Object.prototype.toString.call(value) === '[object Number]';
+}

package/lib/cjs/utils/isObject.d.ts

@@ -0,0 +1 @@
+export default function isObject(obj: any): boolean;

package/lib/cjs/utils/isObject.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isObject;
+
+function isObject(obj) {
+  return obj !== null && typeof obj === 'object';
+}

package/lib/cjs/utils/isPromise.d.ts

@@ -0,0 +1 @@
+export default function isPromise(value: any): boolean;

package/lib/cjs/utils/isPromise.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isPromise;
+
+var _isObject = _interopRequireDefault(require("./isObject"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isPromise(value) {
+  return (0, _isObject.default)(value) && typeof value.then === 'function';
+}

package/lib/cjs/utils/isString.d.ts

@@ -0,0 +1 @@
+export default function (str: any): str is string;

package/lib/cjs/utils/isString.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _default(str) {
+  return typeof str === 'string';
+}