assui 2.0.2 → 2.0.6

package/lib/highlight-textarea/HighlighedContents.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var react_1 = __importDefault(require("react"));
+
+var getRanges_1 = __importDefault(require("./getRanges"));
+
+var extractSpansOfClasses_1 = __importDefault(require("./extractSpansOfClasses"));
+
+var HighlighedContents = function HighlighedContents(_a) {
+  var value = _a.value,
+      highlight = _a.highlight;
+  var ranges = getRanges_1["default"](value, highlight);
+  var parts = extractSpansOfClasses_1["default"](value, ranges);
+  return react_1["default"].createElement(react_1["default"].Fragment, null, parts.map(function (part) {
+    return part.render();
+  }));
+};
+
+exports["default"] = HighlighedContents;

package/lib/highlight-textarea/extractSpansOfClasses.d.ts

@@ -0,0 +1,15 @@
+import { RangesType } from './types';
+declare class Span {
+    beginIndex: number;
+    endIndex: number;
+    markClasses: Set<string>;
+    isMark: boolean;
+    text: string;
+    constructor(text: string, beginIndex: number);
+    setMark(className: string): void;
+    carve(beginIndex2: number): Span;
+    get className(): string;
+    render(): JSX.Element;
+}
+export default function extractSpansOfClasses(value: string, ranges: RangesType): Span[];
+export {};

package/lib/highlight-textarea/extractSpansOfClasses.js

@@ -0,0 +1,173 @@
+"use strict";
+
+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;
+};
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var react_1 = __importDefault(require("react"));
+
+var Span = function () {
+  function Span(text, beginIndex) {
+    this.beginIndex = beginIndex;
+    this.endIndex = beginIndex + text.length;
+    this.text = text;
+    this.isMark = false;
+    this.markClasses = new Set();
+  }
+
+  Span.prototype.setMark = function (className) {
+    var _this = this;
+
+    this.isMark = true;
+
+    if (className) {
+      className.split(' ').forEach(function (cls) {
+        _this.markClasses.add(cls);
+      });
+    }
+  };
+
+  Span.prototype.carve = function (beginIndex2) {
+    var rightText = this.text.slice(beginIndex2 - this.beginIndex);
+    this.text = this.text.slice(0, beginIndex2 - this.beginIndex);
+    this.endIndex = beginIndex2;
+    var right = new Span(rightText, beginIndex2);
+    right.isMark = this.isMark;
+    right.markClasses = new Set(__spread(this.markClasses));
+    return right;
+  };
+
+  Object.defineProperty(Span.prototype, "className", {
+    get: function get() {
+      if (this.markClasses && this.markClasses.size > 0) {
+        return __spread(this.markClasses).sort().join(' ');
+      }
+
+      return '';
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  Span.prototype.render = function () {
+    if (this.isMark) {
+      var className = this.className;
+
+      if (className) {
+        return react_1["default"].createElement("mark", {
+          key: this.beginIndex,
+          className: className
+        }, this.text);
+      }
+
+      return react_1["default"].createElement("mark", {
+        key: this.beginIndex
+      }, this.text);
+    }
+
+    return react_1["default"].createElement("span", {
+      key: this.beginIndex
+    }, this.text);
+  };
+
+  return Span;
+}();
+
+function extractSpansOfClasses(value, ranges) {
+  var spans = [new Span(value, 0)];
+  ranges.forEach(function (range) {
+    var beginIndex = range[0];
+    var endIndex = range[1];
+    var rangeOption = range[2];
+    var _a = (rangeOption || {}).className,
+        className = _a === void 0 ? '' : _a;
+
+    for (var i = 0; i < spans.length; i++) {
+      var span = spans[i]; // since spans are sorted, So this is always true: beginIndex >= span.beginIndex.
+
+      if (beginIndex < span.endIndex) {
+        if (beginIndex === span.beginIndex) {
+          if (endIndex < span.endIndex) {
+            // [range]
+            // [s  p  a  n]
+            var span2 = span.carve(endIndex);
+            span.setMark(className);
+            spans.splice(i + 1, 0, span2);
+            beginIndex = endIndex;
+            i += 1;
+          } else {
+            // [range]   or   [r a n g e]
+            // [span-]        [span]
+            span.setMark(className);
+            beginIndex = span.endIndex;
+          }
+        } else if (endIndex < span.endIndex) {
+          //   [range]
+          // [s  p  a  n]
+          var span2 = span.carve(beginIndex);
+          var span3 = span2.carve(endIndex);
+          span2.setMark(className);
+          spans.splice(i + 1, 0, span2, span3);
+          beginIndex = endIndex;
+          i += 2;
+        } else {
+          //   [range]  or     [range]
+          // [s p a n]       [span]
+          var span2 = span.carve(beginIndex);
+          span2.setMark(className);
+          spans.splice(i + 1, 0, span2);
+          beginIndex = span2.endIndex;
+          i += 1;
+        }
+      }
+
+      if (beginIndex === endIndex) {
+        break;
+      }
+    }
+  });
+  return spans;
+}
+
+exports["default"] = extractSpansOfClasses;

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

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

package/lib/highlight-textarea/getRanges.js

@@ -0,0 +1,156 @@
+"use strict";
+
+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;
+};
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+/* eslint-disable no-cond-assign */
+
+var getType_1 = __importDefault(require("./getType"));
+
+function getRanges(input, highlight) {
+  var type = getType_1["default"](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 [];
+}
+
+exports["default"] = getRanges;
+
+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/lib/highlight-textarea/getType.d.ts

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

package/lib/highlight-textarea/getType.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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';
+}
+
+exports["default"] = getType;

package/lib/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/lib/highlight-textarea/index.js

@@ -0,0 +1,183 @@
+"use strict";
+
+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 __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, {
+    enumerable: true,
+    get: function get() {
+      return m[k];
+    }
+  });
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+
+var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
+
+var __importStar = this && this.__importStar || function (mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) {
+    if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+  }
+
+  __setModuleDefault(result, mod);
+
+  return result;
+};
+
+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;
+};
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var React = __importStar(require("react"));
+
+var classnames_1 = __importDefault(require("classnames"));
+
+var trimStart_1 = __importDefault(require("lodash/trimStart"));
+
+var useMount_1 = __importDefault(require("ahooks/lib/useMount"));
+
+var HighlighedContents_1 = __importDefault(require("./HighlighedContents"));
+
+var HighlightWithinTextarea = 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_1["default"](function () {
+    handleScroll();
+  });
+
+  var onTextareaChange = function onTextareaChange(e) {
+    var newValue = trimStart_1["default"](e.target.value);
+
+    if (onChange) {
+      onChange(newValue, e);
+    } else {
+      setTextAreaValue(newValue);
+    }
+  };
+
+  var textareaCls = classnames_1["default"](prefixCls + "-input", 'highlight-textarea-input', 'highlight-content', textAreaClassName);
+  return React.createElement("div", {
+    className: classnames_1["default"]('highlight-textarea', className),
+    ref: function ref(node) {
+      containerRef.current = node;
+    }
+  }, React.createElement("div", {
+    className: "highlight-textarea-backdrop highlight-content",
+    ref: function ref(node) {
+      backdropRef.current = node;
+    }
+  }, React.createElement(HighlighedContents_1["default"], {
+    value: resultValue,
+    highlight: highlight
+  })), React.createElement("textarea", __assign({
+    value: resultValue,
+    onChange: onTextareaChange,
+    className: textareaCls
+  }, textareaProps, {
+    onScroll: handleScroll,
+    ref: ref
+  })));
+});
+HighlightWithinTextarea.defaultProps = {
+  highlight: '',
+  prefixCls: 'ant'
+};
+exports["default"] = HighlightWithinTextarea;