@progress/kendo-react-sortable 6.1.1 → 7.0.0-develop.2

package/index.mjs

@@ -0,0 +1,485 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as p from "react";
+import * as U from "react-dom";
+import * as h from "prop-types";
+import { hasRelativeStackingContext as M, getter as x, getActiveElement as O, Keys as f, getTabIndex as P, validatePackage as B, Draggable as F } from "@progress/kendo-react-common";
+import { provideLocalizationService as k, registerForLocalization as L } from "@progress/kendo-react-intl";
+class K {
+  constructor() {
+    this.prevented = !1;
+  }
+  /* eslint-disable max-len */
+  /**
+   * Prevents the default action for a specified event.
+   * In this way, the source component suppresses the built-in behavior that follows the event.
+   */
+  preventDefault() {
+    this.prevented = !0;
+  }
+  /**
+   * Returns `true` if the event was prevented by any of its subscribers.
+   *
+   * @returns - Returns `true` if the default action was prevented.
+   * Otherwise, returns `false`.
+   */
+  isDefaultPrevented() {
+    return this.prevented;
+  }
+}
+class X extends K {
+  /**
+   * @hidden
+   */
+  constructor(n, t, e) {
+    super(), this.target = n, this.prevIndex = t, this.element = e;
+  }
+}
+class Y {
+  /**
+   * @hidden
+   */
+  constructor(n, t, e, s) {
+    this.target = n, this.prevIndex = t, this.nextIndex = e, this.newState = s;
+  }
+}
+class _ {
+  /**
+   * @hidden
+   */
+  constructor(n, t, e, s) {
+    this.target = n, this.prevIndex = t, this.nextIndex = e, this.newState = s;
+  }
+}
+class z {
+  /**
+   * @hidden
+   */
+  constructor(n, t, e, s) {
+    this.target = n, this.prevIndex = t, this.nextIndex = e, this.newState = s;
+  }
+}
+const S = "sortable.noData", W = {
+  [S]: "No Data"
+}, H = (o, n) => {
+  for (let t = 0; t < o.length; t++)
+    if (n(o[t]))
+      return o[t];
+}, C = (o, n) => {
+  for (let t = 0; t < o.length; t++)
+    if (n(o[t]))
+      return t;
+  return -1;
+}, w = (o) => String(o).trim().split(" "), q = (o, n) => {
+  const t = w(n);
+  return !!w(o.className).find((e) => t.indexOf(e) >= 0);
+}, G = /^(?:a|input|select|option|textarea|button|object)$/i, $ = (o) => {
+  if (o.tagName) {
+    const n = o.tagName.toLowerCase(), t = o.getAttribute("tabIndex"), e = t === "-1";
+    let s = t !== null && !e;
+    return G.test(n) && (s = !o.disabled && !e), s;
+  }
+  return !1;
+}, j = (o, n) => {
+  for (; o && !n(o); )
+    o = o.parentNode;
+  return o;
+}, V = M(), J = (o) => {
+  if (!o || !V)
+    return null;
+  let n = o.parentElement;
+  for (; n; ) {
+    if (window.getComputedStyle(n).transform !== "none")
+      return n;
+    n = n.parentElement;
+  }
+}, Q = {
+  name: "@progress/kendo-react-sortable",
+  productName: "KendoReact",
+  productCodes: ["KENDOUIREACT", "KENDOUICOMPLETE"],
+  publishDate: 1700573232,
+  version: "",
+  licensingDocsUrl: "https://www.telerik.com/kendo-react-ui/components/my-license/"
+}, y = 200, D = "data-sortable-id", A = "data-sortable-component", Z = { [A]: !0 };
+class E extends p.Component {
+  constructor(n) {
+    super(n), this.state = {
+      clientX: 0,
+      clientY: 0,
+      isDragging: !1,
+      activeId: "",
+      dragCueWidth: 0,
+      dragCueHeight: 0
+    }, this.isRtl = !1, this.itemRefsMap = {}, this.oldSizesMap = {}, this.animatingItemMap = {}, this.draggableRef = null, this.isUnmounted = !1, this.focusActiveId = !1, this.isKeyboardNavigated = !1, this.isDragPrevented = !1, this.swapItems = (t, e, s) => {
+      let i = t[e];
+      return t[e] = t[s], t[s] = i, e = s, e;
+    }, this.generateNewState = (t, e) => {
+      const { data: s } = this.props, i = [...s];
+      if (t > e)
+        for (let l = t - 1; l >= e; l--) {
+          const c = s[l];
+          this.isItemDisabled(c) || (t = this.swapItems(i, t, l));
+        }
+      else
+        for (let l = t + 1; l <= e; l++) {
+          const c = s[l];
+          this.isItemDisabled(c) || (t = this.swapItems(i, t, l));
+        }
+      return i;
+    }, this.closestSortableItem = (t) => {
+      let e = t;
+      for (; e; ) {
+        const s = e.getAttribute(D);
+        if (s && this.itemRefsMap[s] === e)
+          return {
+            id: s,
+            element: e
+          };
+        e = e.parentElement;
+      }
+      return {
+        id: "",
+        element: null
+      };
+    }, this.isSortable = (t) => !!t.hasAttribute(A), this.closestSortable = (t) => {
+      let e = t;
+      for (; e; ) {
+        if (this.isSortable(e))
+          return e;
+        e = e.parentElement;
+      }
+      return null;
+    }, this.isSameSortable = (t) => this.closestSortable(t) === this.container, this.idComparer = (t, e) => t + "" == e + "", this.findItem = (t) => {
+      const { data: e, idField: s } = this.props;
+      if (!(t + ""))
+        return;
+      const i = x(s);
+      return H(e, (r) => this.idComparer(i(r), t));
+    }, this.findIndex = (t) => {
+      const { data: e, idField: s } = this.props;
+      return t + "" ? C(e, (i) => this.idComparer(i[s], t)) : -1;
+    }, this.isItemDisabled = (t) => t && t[this.props.disabledField || ""] === !0, this.shouldResetActive = () => {
+      const t = O(document);
+      return t instanceof HTMLElement ? !this.closestSortableItem(t).element : !1;
+    }, this.widgetTarget = (t) => {
+      const e = j(t, (s) => q(s, "k-widget") || this.isSortable(s));
+      return e && !this.isSortable(e);
+    }, this.allowDrag = (t) => t.hasAttribute(D) || !($(t) || this.widgetTarget(t)), this.onDragStart = (t) => {
+      const { event: e } = t, { onDragStart: s } = this.props, i = document.elementFromPoint(e.clientX, e.clientY), { id: r, element: l } = this.closestSortableItem(i), c = this.findItem(r);
+      if (!r || c && this.isItemDisabled(c) || !this.allowDrag(i) || !this.isSameSortable(i)) {
+        this.isDragPrevented = !0;
+        return;
+      }
+      e.isTouch && e.originalEvent.preventDefault();
+      const a = new X(
+        this,
+        this.findIndex(r),
+        i
+      );
+      s && s.call(void 0, a), this.isDragPrevented = a.isDefaultPrevented(), this.isDragPrevented ? e.originalEvent.preventDefault() : (this.offsetParent = J(this.container), this.setState({
+        activeId: r,
+        dragCueWidth: l && l.clientWidth || 0,
+        dragCueHeight: l && l.clientHeight || 0
+      }));
+    }, this.onDragOver = (t) => {
+      const { event: e } = t, { onDragOver: s, data: i } = this.props;
+      if (this.isDragPrevented)
+        return;
+      e.originalEvent.preventDefault();
+      const r = this.findIndex(this.state.activeId);
+      if (r === -1) {
+        this.resetState();
+        return;
+      }
+      const l = document.elementFromPoint(e.clientX, e.clientY), c = this.closestSortableItem(l), a = this.findIndex(c.id), d = i[a];
+      if (s && a > -1 && r !== a && !this.isItemDisabled(d) && !this.animatingItemMap[c.id] && this.shouldReorder(c.element, e.clientX, e.clientY)) {
+        const m = new Y(
+          this,
+          r,
+          a,
+          this.generateNewState(r, a)
+        );
+        s.call(void 0, m);
+      }
+      const g = this.parentOffset();
+      this.setState({
+        clientX: e.clientX - g.left,
+        clientY: e.clientY - g.top,
+        isDragging: !0
+      });
+    }, this.onDragEnd = (t) => {
+      const { event: e } = t, s = this.shouldResetActive();
+      if (this.isDragPrevented)
+        return;
+      const { onDragEnd: i, data: r } = this.props, l = document.elementFromPoint(e.clientX, e.clientY), c = this.closestSortableItem(l);
+      let a = this.findIndex(c.id), d = this.findIndex(this.state.activeId);
+      const g = this.isItemDisabled(r[a]);
+      if ((a === -1 || g) && (a = d), i) {
+        let m = this.generateNewState(d, a);
+        if (!g) {
+          const u = this.thresholdRect(c.element);
+          if (u && (e.clientX < u.left || e.clientX > u.right || e.clientY < u.top || e.clientY > u.bottom)) {
+            const b = d;
+            d = a, a = b, m = this.props.data.slice();
+          }
+        }
+        const I = new _(
+          this,
+          d,
+          a,
+          m
+        );
+        i.call(void 0, I);
+      }
+      this.resetState(s);
+    }, this.shouldReorder = (t, e, s) => {
+      const i = this.thresholdRect(t);
+      return i && e > i.left && e < i.right && s > i.top && s < i.bottom;
+    }, this.thresholdRect = (t) => {
+      const e = this.state.activeId, s = this.container, r = (s ? Array.from(s.childNodes) : []).find(
+        (u) => u instanceof HTMLElement && u.getAttribute(D) === e
+      );
+      if (!t || !r)
+        return null;
+      const { width: l, height: c } = r.getBoundingClientRect(), a = t.getBoundingClientRect(), d = a.top + a.height / 2 - c / 2, g = a.left + a.width / 2 - l / 2, m = d + c, I = g + l;
+      return { top: d, left: g, bottom: m, right: I };
+    }, this.onItemBlur = () => {
+      window.setTimeout(() => {
+        this.isUnmounted || this.shouldResetActive() && !this.state.isDragging && this.setState({
+          activeId: ""
+          // what happends on destroyed component
+        });
+      });
+    }, this.onItemFocus = (t) => {
+      const { id: e, element: s } = this.closestSortableItem(t.currentTarget);
+      !this.idComparer(e, this.state.activeId) && this.isSameSortable(t.target) && s === t.target && this.setState({
+        activeId: e
+      });
+    }, this.onKeyDown = (t) => {
+      const { data: e, idField: s, onNavigate: i, navigation: r } = this.props, { activeId: l } = this.state;
+      if (!r || !l || !this.isSameSortable(t.target))
+        return;
+      const c = this.isRtl, a = e.filter((v) => !this.isItemDisabled(v)), d = C(a, (v) => this.idComparer(v[s], l)), g = a.length - 1;
+      let m = d;
+      switch (t.keyCode === f.left && (c ? t.keyCode = f.down : t.keyCode = f.up), t.keyCode === f.right && (c ? t.keyCode = f.up : t.keyCode = f.down), t.keyCode) {
+        case f.up:
+          d > 0 && (m = d - 1);
+          break;
+        case f.down:
+          d < g && (m = d + 1);
+          break;
+      }
+      if (m === d)
+        return;
+      t.stopPropagation(), t.preventDefault();
+      const I = a[m], u = I ? I[s] : "", b = a[d], N = b ? b[s] : "";
+      if (t.ctrlKey) {
+        if (i) {
+          const v = this.findIndex(N), R = this.findIndex(u), T = new z(
+            this,
+            v,
+            R,
+            this.generateNewState(v, R)
+          );
+          this.isKeyboardNavigated = !0, i.call(void 0, T);
+        }
+      } else
+        this.focusActiveId = !0, this.setState({
+          activeId: u + ""
+        });
+    }, this.resetState = (t) => {
+      this.isDragPrevented = !1, this.setState({
+        clientX: 0,
+        clientY: 0,
+        isDragging: !1,
+        dragCueWidth: 0,
+        dragCueHeight: 0,
+        activeId: t ? "" : this.state.activeId
+      });
+    }, this.renderData = () => {
+      const {
+        data: t,
+        itemUI: e,
+        idField: s,
+        tabIndex: i
+      } = this.props;
+      return t.map((r) => {
+        const c = x(s)(r), a = this.isItemDisabled(r), d = this.idComparer(this.state.activeId, c);
+        return /* @__PURE__ */ p.createElement(
+          e,
+          {
+            key: c,
+            forwardRef: (g) => this.refAssign(g, c),
+            dataItem: r,
+            isDisabled: a,
+            isActive: d,
+            isDragged: d && this.state.isDragging,
+            isDragCue: !1,
+            attributes: {
+              [D]: c,
+              ["aria-disabled"]: a,
+              ["aria-grabbed"]: d && this.state.isDragging && !this.isDragPrevented,
+              ["aria-dropeffect"]: a ? "none" : "move",
+              tabIndex: P(i, a),
+              onFocus: this.onItemFocus,
+              onBlur: this.onItemBlur
+            },
+            style: {
+              cursor: a ? "auto" : "move",
+              MozUserSelect: "none",
+              msUserSelect: "none",
+              WebkitUserSelect: "none",
+              userSelect: "none"
+            }
+          }
+        );
+      });
+    }, this.renderNoData = () => {
+      const { emptyItemUI: t } = this.props, s = k(this).toLanguageString(S, W[S]);
+      if (t)
+        return /* @__PURE__ */ p.createElement(t, { message: s });
+    }, this.renderDragCue = () => {
+      const { itemUI: t } = this.props, { isDragging: e, activeId: s, clientX: i, clientY: r } = this.state, l = this.findItem(s);
+      if (!(!e || !l))
+        return /* @__PURE__ */ p.createElement(
+          t,
+          {
+            dataItem: l,
+            isDisabled: !1,
+            isActive: !0,
+            isDragged: !0,
+            isDragCue: !0,
+            style: {
+              position: "fixed",
+              top: r + 10,
+              left: i + 10,
+              width: this.state.dragCueWidth,
+              height: this.state.dragCueHeight
+            },
+            attributes: {}
+          }
+        );
+    }, this.refAssign = (t, e) => {
+      t ? this.itemRefsMap[e] = t : delete this.itemRefsMap[e];
+    }, this.draggableRefAssign = (t) => {
+      this.draggableRef = t;
+    }, B(Q);
+  }
+  get container() {
+    return this.draggableRef && this.draggableRef.element;
+  }
+  /**
+   * @hidden
+   */
+  getSnapshotBeforeUpdate() {
+    const { idField: n, animation: t } = this.props;
+    return this.oldSizesMap = {}, t && this.props.data.forEach((e) => {
+      const s = e[n], i = this.itemRefsMap[s], r = U.findDOMNode(i);
+      r && (this.oldSizesMap[s] = r.getBoundingClientRect());
+    }), null;
+  }
+  /**
+   * @hidden
+   */
+  componentDidUpdate(n) {
+    const { idField: t, animation: e } = this.props;
+    this.focusActiveId && (this.focusActiveId = !1, this.itemRefsMap[this.state.activeId].focus()), !(!e || !this.state.isDragging && !this.isKeyboardNavigated) && (this.isKeyboardNavigated = !1, n.data.forEach((s) => {
+      const i = s[t], r = this.itemRefsMap[i];
+      if (!r)
+        return;
+      const l = r.getBoundingClientRect(), c = this.oldSizesMap[i], a = c.left - l.left, d = c.top - l.top;
+      a === 0 && d === 0 || requestAnimationFrame(() => {
+        this.animatingItemMap[i] = !0, r.style.transform = `translate(${a}px, ${d}px)`, r.style.transition = "transform 0s", requestAnimationFrame(() => {
+          r.style.transform = "", r.style.transition = `transform ${y}ms cubic-bezier(0.2, 0, 0, 1) 0s`, window.setTimeout(() => this.animatingItemMap[i] = !1, y);
+        });
+      });
+    }));
+  }
+  /**
+   * @hidden
+   */
+  componentDidMount() {
+    this.isRtl = this.container && getComputedStyle(this.container).direction === "rtl" || !1;
+  }
+  /**
+   * @hidden
+   */
+  componentWillUnmount() {
+    this.isUnmounted = !0;
+  }
+  /**
+   * @hidden
+   */
+  parentOffset() {
+    const n = this.offsetParent;
+    if (n && n.ownerDocument && n !== n.ownerDocument.body) {
+      const t = n.getBoundingClientRect();
+      return {
+        left: t.left - n.scrollLeft,
+        top: t.top - n.scrollTop
+      };
+    }
+    return { left: 0, top: 0 };
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const { data: n, style: t, className: e, itemsWrapUI: s } = this.props, i = s || "div";
+    return /* @__PURE__ */ p.createElement(
+      F,
+      {
+        onDragStart: this.onDragStart,
+        onDrag: this.onDragOver,
+        onDragEnd: this.onDragEnd,
+        ref: this.draggableRefAssign
+      },
+      /* @__PURE__ */ p.createElement(
+        i,
+        {
+          ...Z,
+          className: e,
+          style: {
+            touchAction: "none",
+            ...t
+          },
+          onKeyDown: this.onKeyDown
+        },
+        n && n.length ? this.renderData() : this.renderNoData(),
+        this.renderDragCue()
+      )
+    );
+  }
+}
+E.defaultProps = {
+  navigation: !0,
+  animation: !0,
+  emptyItemUI: (o) => /* @__PURE__ */ p.createElement("div", null, o.message)
+};
+E.propTypes = {
+  idField: h.string.isRequired,
+  disabledField: h.string,
+  data: h.array.isRequired,
+  tabIndex: h.number,
+  navigation: h.bool,
+  animation: h.bool,
+  itemsWrapUI: h.any,
+  itemUI: h.func.isRequired,
+  emptyItemUI: h.func,
+  style: h.object,
+  className: h.string,
+  onDragStart: h.func,
+  onDragOver: h.func,
+  onDragEnd: h.func,
+  onNavigate: h.func
+};
+L(E);
+export {
+  E as Sortable,
+  _ as SortableOnDragEndEvent,
+  Y as SortableOnDragOverEvent,
+  X as SortableOnDragStartEvent,
+  z as SortableOnNavigateEvent
+};

package/{dist/es/interfaces → interfaces}/SortableDefaultProps.d.ts

@@ -1,4 +1,7 @@
-/// <reference types="react" />
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
 import { SortableEmptyItemUIProps } from './SortableEmptyItemUIProps';
 /**
  * @hidden

package/interfaces/SortableEmptyItemUIProps.d.ts

@@ -0,0 +1,13 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * Represents the props of the UI component that is rendered when no data is available.
+ */
+export interface SortableEmptyItemUIProps {
+    /**
+     * The `noData` localization message.
+     */
+    message: string;
+}

package/{dist/npm/interfaces → interfaces}/SortableItemUIProps.d.ts

@@ -1,4 +1,7 @@
-/// <reference types="react" />
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
 /**
  * Represents the props of the Sortable item UI component.
  */

package/{dist/es/interfaces → interfaces}/SortableProps.d.ts

@@ -1,4 +1,7 @@
-/// <reference types="react" />
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
 import { SortableOnDragStartEvent } from './../events/SortableOnDragStartEvent';
 import { SortableOnDragOverEvent } from './../events/SortableOnDragOverEvent';
 import { SortableOnDragEndEvent } from './../events/SortableOnDragEndEvent';

package/messages/index.d.ts

@@ -0,0 +1,14 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export declare const noData = "sortable.noData";
+/**
+ * @hidden
+ */
+export declare const messages: {
+    "sortable.noData": string;
+};

package/package-metadata.d.ts

@@ -0,0 +1,9 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+import { PackageMetadata } from '@progress/kendo-licensing';
+/**
+ * @hidden
+ */
+export declare const packageMetadata: PackageMetadata;

package/package.json

@@ -1,22 +1,29 @@
 {
   "name": "@progress/kendo-react-sortable",
-  "version": "6.1.1",
+  "version": "7.0.0-develop.2",
   "description": "React Sortable provides a sortable drag-and-drop functionality to elements within a list. KendoReact Sortable package",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/telerik/kendo-react.git"
+  "author": "Progress",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "homepage": "https://www.telerik.com/kendo-react-ui",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js"
+    }
   },
-  "main": "dist/npm/main.js",
-  "types": "dist/npm/main.d.ts",
-  "module": "dist/es/main.js",
-  "jsnext:main": "dist/es/main.js",
-  "scripts": {
-    "test": "cd ../../ && npm run test -- --testPathPattern=/packages/sortable/.*",
-    "e2e": "cd ../../ && npx jest --maxWorkers=4 --config jest.e2e.js packages/sortable/e2e/",
-    "start": "gulp start",
-    "build-package": "gulp build-package"
+  "sideEffects": false,
+  "peerDependencies": {
+    "@progress/kendo-licensing": "^1.3.0",
+    "@progress/kendo-react-common": "7.0.0-develop.2",
+    "@progress/kendo-react-intl": "7.0.0-develop.2",
+    "react": "^16.8.2 || ^17.0.0 || ^18.0.0",
+    "react-dom": "^16.8.2 || ^17.0.0 || ^18.0.0"
+  },
+  "dependencies": {
+    "prop-types": "^15.6.0"
   },
-  "homepage": "https://www.telerik.com/kendo-react-ui",
   "keywords": [
     "Kendo UI",
     "React",
@@ -29,32 +36,15 @@
     "React component",
     "Telerik"
   ],
-  "peerDependencies": {
-    "@progress/kendo-licensing": "^1.3.0",
-    "react": "^16.8.2 || ^17.0.0 || ^18.0.0",
-    "react-dom": "^16.8.2 || ^17.0.0 || ^18.0.0"
-  },
-  "dependencies": {
-    "@progress/kendo-react-common": "6.1.1",
-    "prop-types": "^15.6.0"
-  },
-  "devDependencies": {
-    "@progress/kendo-licensing": "^1.3.0",
-    "@progress/kendo-react-dateinputs": "6.1.1",
-    "@progress/kendo-react-form": "6.1.1",
-    "@progress/kendo-react-grid": "6.1.1",
-    "@progress/kendo-react-inputs": "6.1.1",
-    "@progress/kendo-react-intl": "6.1.1",
-    "@progress/kendo-react-labels": "6.1.1"
-  },
   "@progress": {
     "friendlyName": "Sortable",
     "framework": "KendoReact"
   },
-  "author": "Progress",
-  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/telerik/kendo-react.git"
+  },
   "publishConfig": {
     "access": "public"
-  },
-  "sideEffects": false
-}
+  }
+}

package/{dist/npm/utils → utils}/utils.d.ts

@@ -1,3 +1,7 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
 /**
  * @hidden
  */

package/about.md

@@ -1,3 +0,0 @@
-<a href="https://www.telerik.com/kendo-react-ui?utm_medium=referral&utm_source=npm&utm_campaign=kendo-ui-react-trial-npm-sortable&utm_content=banner" target="_blank">
-<img src="https://www.telerik.com/kendo-react-ui/components/npm-banner.svg" alt="KendoReact NPM Banner">
-</a>