assui 2.0.2 → 2.0.6

package/es/highlight-textarea/getRanges.d.ts

@@ -0,0 +1,2 @@
+import { HighlightType, RangesType } from './types';
+export default function getRanges(input: string, highlight: HighlightType): RangesType;

package/es/highlight-textarea/getRanges.js

@@ -0,0 +1,142 @@
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
+
+var __spread = this && this.__spread || function () {
+  for (var ar = [], i = 0; i < arguments.length; i++) {
+    ar = ar.concat(__read(arguments[i]));
+  }
+
+  return ar;
+};
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+/* eslint-disable no-cond-assign */
+
+
+import getType from './getType';
+export default function getRanges(input, highlight) {
+  var type = getType(highlight);
+
+  switch (type) {
+    case 'array':
+      return getArrayRanges(input, highlight);
+
+    case 'function':
+      return getFunctionRanges(input, highlight);
+
+    case 'regexp':
+      return getRegExpRanges(input, highlight);
+
+    case 'string':
+      return getStringRanges(input, highlight);
+
+    case 'range':
+      return getRangeRanges(highlight);
+
+    case 'custom':
+      return getCustomRanges(input, highlight);
+
+    default:
+      if (!highlight) {
+        // do nothing for falsely values
+        return [];
+      }
+
+      console.error('unrecognized highlight type');
+  }
+
+  return [];
+}
+
+function getArrayRanges(input, arr) {
+  // const ranges: RangesType = arr.map(getRanges.bind(this, input));
+  var ranges = arr.map(function (highlight) {
+    return getRanges(input, highlight);
+  });
+  return Array.prototype.concat.apply([], ranges);
+}
+
+function getFunctionRanges(input, func) {
+  return getRanges(input, func(input));
+}
+
+function getRegExpRanges(input, regex) {
+  var ranges = [];
+  var match;
+
+  while (match = regex.exec(input), match !== null) {
+    ranges.push([match.index, match.index + match[0].length]);
+
+    if (!regex.global) {
+      // non-global regexes do not increase lastIndex, causing an infinite loop,
+      // but we can just break manually after the first match
+      break;
+    }
+  }
+
+  return ranges;
+}
+
+function getStringRanges(input, str) {
+  var ranges = [];
+  var inputLower = input.toLowerCase();
+  var strLower = str.toLowerCase();
+  var index = 0;
+
+  while (index = inputLower.indexOf(strLower, index), index !== -1) {
+    ranges.push([index, index + strLower.length]);
+    index += strLower.length;
+  }
+
+  return ranges;
+}
+
+function getRangeRanges(range) {
+  return [range];
+}
+
+function getCustomRanges(input, custom) {
+  var ranges = getRanges(input, custom.highlight);
+
+  var resultRangesData = __spread(ranges);
+
+  if (custom.className) {
+    resultRangesData.forEach(function (range) {
+      var rangeOption = range[2] || {};
+
+      if (rangeOption.className) {
+        rangeOption.className = custom.className + " " + rangeOption.className;
+      } else {
+        rangeOption.className = custom.className;
+      }
+
+      range[2] = rangeOption;
+    });
+  }
+
+  return ranges;
+}

package/es/highlight-textarea/getType.d.ts

@@ -0,0 +1,2 @@
+import { HighlightType, TypeList } from './types';
+export default function getType(instance: HighlightType): TypeList;

package/es/highlight-textarea/getType.js

@@ -0,0 +1,29 @@
+export default function getType(instance) {
+  var type = typeof instance;
+
+  if (!instance) {
+    return 'falsely';
+  }
+
+  if (Array.isArray(instance)) {
+    if (instance.length === 2 && typeof instance[0] === 'number' && typeof instance[1] === 'number') {
+      return 'range';
+    }
+
+    return 'array';
+  }
+
+  if (type === 'object') {
+    if (instance instanceof RegExp) {
+      return 'regexp';
+    }
+
+    if (instance.highlight) {
+      return 'custom';
+    }
+  } else if (type === 'function' || type === 'string') {
+    return type;
+  }
+
+  return 'other';
+}

package/es/highlight-textarea/index.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { HighlighedContentsProps } from './HighlighedContents';
+import { HighlightType } from './types';
+export interface HighlightWithinTextareaProps extends HighlighedContentsProps {
+    prefixCls?: string;
+    className?: string;
+    textAreaClassName?: string;
+    onChange?: (value: string, e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    highlight: HighlightType;
+}
+declare const HighlightWithinTextarea: React.ForwardRefExoticComponent<HighlightWithinTextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export default HighlightWithinTextarea;

package/es/highlight-textarea/index.js

@@ -0,0 +1,132 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
+
+import * as React from 'react';
+import classNames from 'classnames';
+import trimStart from 'lodash/trimStart';
+import useMount from 'ahooks/lib/useMount';
+import HighlighedContents from './HighlighedContents';
+var HighlightWithinTextarea = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var prefixCls = props.prefixCls,
+      value = props.value,
+      onChange = props.onChange,
+      highlight = props.highlight,
+      className = props.className,
+      textAreaClassName = props.textAreaClassName,
+      textareaProps = __rest(props, ["prefixCls", "value", "onChange", "highlight", "className", "textAreaClassName"]);
+
+  var _a = __read(React.useState(''), 2),
+      textAreaValue = _a[0],
+      setTextAreaValue = _a[1];
+
+  var resultValue = value || textAreaValue;
+  var containerRef = React.useRef();
+  var backdropRef = React.useRef();
+
+  var handleScroll = function handleScroll() {
+    var _a;
+
+    var textareaDom = (_a = containerRef.current) === null || _a === void 0 ? void 0 : _a.querySelector('textarea');
+
+    if (backdropRef.current && textareaDom) {
+      backdropRef.current.scrollLeft = textareaDom.scrollLeft;
+      backdropRef.current.style.height = textareaDom.clientHeight + textareaDom.scrollTop + "px";
+      backdropRef.current.style.top = 0 - textareaDom.scrollTop + "px";
+    }
+  };
+
+  useMount(function () {
+    handleScroll();
+  });
+
+  var onTextareaChange = function onTextareaChange(e) {
+    var newValue = trimStart(e.target.value);
+
+    if (onChange) {
+      onChange(newValue, e);
+    } else {
+      setTextAreaValue(newValue);
+    }
+  };
+
+  var textareaCls = classNames(prefixCls + "-input", 'highlight-textarea-input', 'highlight-content', textAreaClassName);
+  return /*#__PURE__*/React.createElement("div", {
+    className: classNames('highlight-textarea', className),
+    ref: function ref(node) {
+      containerRef.current = node;
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "highlight-textarea-backdrop highlight-content",
+    ref: function ref(node) {
+      backdropRef.current = node;
+    }
+  }, /*#__PURE__*/React.createElement(HighlighedContents, {
+    value: resultValue,
+    highlight: highlight
+  })), /*#__PURE__*/React.createElement("textarea", __assign({
+    value: resultValue,
+    onChange: onTextareaChange,
+    className: textareaCls
+  }, textareaProps, {
+    onScroll: handleScroll,
+    ref: ref
+  })));
+});
+HighlightWithinTextarea.defaultProps = {
+  highlight: '',
+  prefixCls: 'ant'
+};
+export default HighlightWithinTextarea;

package/es/highlight-textarea/style/index.css

@@ -0,0 +1,38 @@
+.highlight-textarea {
+  position: relative;
+  display: inline-block;
+  width: 100%;
+  height: 100px;
+  overflow: hidden;
+  -webkit-text-size-adjust: none;
+}
+.highlight-textarea-backdrop {
+  overflow-x: hidden;
+  overflow-y: scroll;
+  color: transparent;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  border: 1px solid;
+  border-color: transparent;
+}
+.highlight-textarea-input.highlight-content {
+  z-index: 100;
+  overflow-x: hidden;
+  overflow-y: scroll;
+  font: inherit;
+  resize: none;
+}
+.highlight-textarea .highlight-content {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  padding: 2px 5px 0 5px;
+  background: none transparent !important;
+}
+.highlight-textarea .highlight-content mark {
+  padding: 0;
+  color: inherit;
+  background-color: #a3daff;
+}

package/es/highlight-textarea/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'antd/es/input/style';
+import './index.less';

package/es/highlight-textarea/style/index.js

@@ -0,0 +1,2 @@
+import 'antd/es/input/style';
+import './index.less';

package/es/highlight-textarea/style/index.less

@@ -0,0 +1,42 @@
+.highlight-textarea {
+  position: relative;
+  display: inline-block;
+  width: 100%;
+  height: 100px;
+  overflow: hidden;
+  -webkit-text-size-adjust: none;
+
+  &-backdrop {
+    overflow-x: hidden;
+    overflow-y: scroll;
+    color: transparent;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    border: 1px solid;
+    border-color: transparent;
+  }
+
+  &-input.highlight-content {
+    z-index: 100;
+    overflow-x: hidden;
+    overflow-y: scroll;
+    font: inherit;
+    resize: none;
+  }
+
+  .highlight-content {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    padding: 2px 5px 0 5px;
+    background: none transparent !important;
+  }
+
+  .highlight-content mark {
+    padding: 0;
+    color: inherit;
+    background-color: #a3daff;
+  }
+}

package/es/highlight-textarea/types.d.ts

@@ -0,0 +1,16 @@
+export declare type StringType = string;
+export declare type NumberArrayType = number[];
+export declare type RegExpType = RegExp;
+export declare type FuncType = (input: string) => string;
+export declare type HighlightInstanceType = StringType | NumberArrayType | RegExpType | FuncType;
+export declare type AdmixArrayType = HighlightInstanceType[];
+export declare type ObjectType = {
+    highlight: HighlightInstanceType;
+    className?: string;
+};
+export declare type CustomArrayArrayType = ObjectType[];
+export declare type RangesType = (number | {
+    className?: string;
+})[][];
+export declare type HighlightType = StringType | NumberArrayType | RegExpType | FuncType | HighlightInstanceType | AdmixArrayType | ObjectType | CustomArrayArrayType;
+export declare type TypeList = 'falsely' | 'range' | 'array' | 'regexp' | 'custom' | 'other' | 'function' | 'string';

package/es/highlight-words/index.d.ts

@@ -0,0 +1,3 @@
+import HighlightWords, { FindChunks, Chunk, HighlighterProps } from 'react-highlight-words';
+export { FindChunks, Chunk, HighlighterProps };
+export default HighlightWords;

package/es/highlight-words/index.js

@@ -0,0 +1,2 @@
+import HighlightWords from 'react-highlight-words';
+export default HighlightWords;