@progress/kendo-angular-sortable 21.4.1 → 22.0.0-develop.1

package/esm2022/sortable.module.mjs

@@ -1,44 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { NgModule } from '@angular/core';
-import { SortableService } from "./sortable.service";
-import { KENDO_SORTABLE } from './directives';
-import * as i0 from "@angular/core";
-import * as i1 from "./sortable.component";
-import * as i2 from "./draggable.directive";
-import * as i3 from "./item-template.directive";
-import * as i4 from "./binding.directive";
-//IMPORTANT: NgModule export kept for backwards compatibility
-/**
- * Represents the [`NgModule`](link:site.data.urls.angular['ngmoduleapi']) definition for the Sortable component.
- *
- * @example
- * ```typescript
- * import { NgModule } from '@angular/core';
- * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
- * import { SortableModule } from '@progress/kendo-angular-sortable';
- * import { AppComponent } from './app.component';
- *
- * @NgModule({
- *     declarations: [AppComponent],
- *     imports:      [BrowserModule, SortableModule],
- *     bootstrap:    [AppComponent]
- * })
- * export class AppModule {}
- * ```
- */
-export class SortableModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SortableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: SortableModule, imports: [i1.SortableComponent, i2.DraggableDirective, i3.PlaceholderTemplateDirective, i3.ItemTemplateDirective, i4.SortableBindingDirective], exports: [i1.SortableComponent, i2.DraggableDirective, i3.PlaceholderTemplateDirective, i3.ItemTemplateDirective, i4.SortableBindingDirective] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SortableModule, providers: [SortableService] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SortableModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [...KENDO_SORTABLE],
-                    exports: [...KENDO_SORTABLE],
-                    providers: [SortableService]
-                }]
-        }] });

package/esm2022/sortable.service.mjs

@@ -1,238 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable, NgZone } from '@angular/core';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import { draggableFromEvent, isFocusable, MINIMAL_DRAG_DISTANCE, widgetTarget } from './util';
-import { Subject } from 'rxjs';
-import { switchMap, filter, take, tap } from 'rxjs/operators';
-import * as i0 from "@angular/core";
-const allowDrag = (e) => {
-    const target = e.originalEvent.target;
-    return target.hasAttribute('data-sortable-item') || !(isFocusable(target) || widgetTarget(target));
-};
-/**
- * The `SortableService` is a service that manages the drag-and-drop functionality
- * for transferring items between Sortable components.
- */
-export class SortableService {
-    ngZone;
-    /**
-     * Specifies the Draggable item that is currently being moved.
-     */
-    activeDraggable = null;
-    /**
-     * Specifies the Draggable item from which the dragging started.
-     */
-    originDraggable = null;
-    /**
-     * @hidden
-     */
-    originIndex;
-    /**
-     * @hidden
-     */
-    targetSortable = null;
-    /**
-     * Specifies the Draggable item that last emitted an event.
-     */
-    lastDraggable = null;
-    /**
-     * @hidden
-     */
-    onPressSubject = new Subject();
-    /**
-     * @hidden
-     */
-    onDragSubject = new Subject();
-    /**
-     * @hidden
-     */
-    onReleaseSubject = new Subject();
-    subscriptions;
-    source = null;
-    _target = null;
-    sortableCounter = 0;
-    sortableRegister = {};
-    pressArgs;
-    /**
-     * Specifies the `SortableComponent` instance under the currently dragged item.
-     */
-    set target(target) {
-        this._target = target;
-    }
-    get target() {
-        return this._target;
-    }
-    /**
-     * @hidden
-     */
-    constructor(ngZone) {
-        this.ngZone = ngZone;
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        this.subscriptions = this.onPressSubject.pipe(filter(allowDrag), tap(press => {
-            this.targetSortable = this.getSortableComponentFromTouch(press);
-        }), filter(_ => Boolean(this.targetSortable)), tap(press => {
-            this.onReleaseSubject.pipe(take(1)).subscribe(event => this.release(event));
-            this.pressArgs = press;
-            if (press.isTouch) {
-                press.originalEvent.preventDefault();
-            }
-        }), switchMap(_drag => this.onDragSubject.pipe(filter(_ => Boolean(this.targetSortable)), //stop further events if dragStart is prevented
-        tap((e) => this.drag(e))))).subscribe();
-    }
-    /**
-     * @hidden
-     */
-    onPress(e) {
-        this.onPressSubject.next(e);
-    }
-    /**
-     * @hidden
-     */
-    onDrag(e) {
-        this.onDragSubject.next(e);
-    }
-    /**
-     * @hidden
-     */
-    onRelease(e) {
-        this.onReleaseSubject.next(e);
-    }
-    /**
-     * @hidden
-     */
-    ngOnDestroy() {
-        if (this.subscriptions) {
-            this.subscriptions.unsubscribe();
-        }
-    }
-    /**
-     * Registers a `SortableComponent` with the `SortableService` so that it can be managed by the service.
-     *
-     * @param sortableComponent - The `SortableComponent`.
-     * @return - The unique key that the current `SortableComponent` gets when registered.
-     */
-    registerComponent(sortableComponent) {
-        const id = this.sortableCounter.toString();
-        this.sortableRegister[id] = sortableComponent;
-        this.sortableCounter++;
-        return id;
-    }
-    /**
-     * Removes a `SortableComponent` from the registered `SortableComponents` with which the service operates.
-     *
-     * @param key - The key of the `SortableComponent` which will be removed from the register.
-     * Obtained when `registerComponent` is called.
-     */
-    unregisterComponent(key) {
-        this.sortableRegister[key] = null;
-    }
-    /**
-     * Sets the `SortableComponent` as a source component. When dragging an item from one Sortable to another,
-     * the source component is the one from which the item originates.
-     *
-     * @param sortable - The `SortableComponent`.
-     */
-    setSource(sortable) {
-        this.source = sortable;
-    }
-    /**
-     * Returns the source `SortableComponent` from which
-     * an item is dragged to other Sortable components.
-     *
-     * @return - The `SourceComponent`.
-     */
-    getSource() {
-        return this.source;
-    }
-    /**
-     * The method that finds the `SortableComponent` which is registered to
-     * the `SortableService` by using the arguments of the `touch` event.
-     *
-     * @param touch - A Touch-Object of the `Touch` type interface.
-     * Represents a single contact point (finger or stylus)
-     * on a touch-sensitive device (touchscreen or trackpad).
-     *
-     * @return { component: SortableComponent, index: number } - An object where the component is the `SortableComponent` that owns the item and the index is the index of the touched item.
-     */
-    getSortableComponentFromTouch(touch) {
-        if (!isDocumentAvailable()) {
-            return { component: undefined, index: undefined };
-        }
-        let realTarget = document.elementFromPoint(touch.clientX, touch.clientY);
-        while (realTarget) {
-            const id = realTarget.getAttribute('data-sortable-id');
-            const index = realTarget.getAttribute('data-sortable-index');
-            if (id) {
-                const targetSortable = this.sortableRegister[id];
-                if (targetSortable) {
-                    return { component: targetSortable, index: parseInt(index, 10) };
-                }
-            }
-            realTarget = realTarget.parentElement;
-        }
-    }
-    start() {
-        const pressArgs = this.pressArgs;
-        if (pressArgs) {
-            this.pressArgs = null;
-            const startTarget = draggableFromEvent(pressArgs, this.targetSortable.component);
-            if (this.targetSortable.component.startDrag({ target: startTarget, originalEvent: pressArgs })) {
-                this.targetSortable = null;
-                return true;
-            }
-        }
-    }
-    release(event) {
-        if (this.source) {
-            this.ngZone.run(() => {
-                if (this.targetSortable) {
-                    const dropTarget = draggableFromEvent(event, this.targetSortable.component);
-                    this.source.endDrag({ target: dropTarget, originalEvent: event });
-                }
-                this.source.positionHintFromEvent(null);
-                this.source.markForCheck();
-            });
-        }
-        this.targetSortable = null;
-        this.pressArgs = null;
-    }
-    drag(event) {
-        const distance = this.pressArgs && Math.sqrt((event.pageX - this.pressArgs.pageX) ** 2 + (event.pageY - this.pressArgs.pageY) ** 2);
-        if (distance && distance < MINIMAL_DRAG_DISTANCE) {
-            return;
-        }
-        this.ngZone.run(() => {
-            if (this.start()) {
-                return;
-            }
-            this.source.positionHintFromEvent(event);
-            const sortable = this.getSortableComponentFromTouch(event);
-            if (!sortable || sortable && sortable.component !== this.target) {
-                if (this.target) {
-                    this.target.leave({ target: undefined, originalEvent: event });
-                }
-                else if (this.source !== this.target) {
-                    this.source.leave({ target: undefined, originalEvent: event });
-                }
-            }
-            if (sortable && sortable.component) {
-                const draggable = draggableFromEvent(event, sortable.component);
-                sortable.component.drag({ target: draggable, originalEvent: event });
-            }
-            this.source.markForCheck();
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SortableService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SortableService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SortableService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i0.NgZone }] });

package/esm2022/util.mjs

@@ -1,176 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { focusableSelector, isDocumentAvailable } from '@progress/kendo-angular-common';
-const NODE_NAME_PREDICATES = {};
-const NODE_ATTR_PREDICATES = {};
-const focusableRegex = /^(?:a|input|select|option|textarea|button|object)$/i;
-/**
- * @hidden
- */
-export const MINIMAL_DRAG_DISTANCE = 5;
-/**
- * @hidden
- */
-export const matchesNodeName = (nodeName) => {
-    if (!NODE_NAME_PREDICATES[nodeName]) {
-        NODE_NAME_PREDICATES[nodeName] = (element) => String(element.nodeName).toLowerCase() === nodeName.toLowerCase();
-    }
-    return NODE_NAME_PREDICATES[nodeName];
-};
-/**
- * @hidden
- */
-export const matchesNodeAttr = (nodeAttr) => {
-    if (!NODE_ATTR_PREDICATES[nodeAttr]) {
-        NODE_ATTR_PREDICATES[nodeAttr] = (element) => element.hasAttribute ? element.hasAttribute(nodeAttr) : false;
-    }
-    return NODE_ATTR_PREDICATES[nodeAttr];
-};
-/**
- * @hidden
- */
-export const closest = (node, predicate) => {
-    while (node && !predicate(node)) {
-        node = node.parentNode;
-    }
-    return node;
-};
-/**
- * Returns an object specifying whether there is a `DraggableDirective` under the cursor.
- * @hidden
- */
-export const draggableFromPoint = (x, y) => {
-    if (!isDocumentAvailable()) {
-        return;
-    }
-    const el = document.elementFromPoint(x, y);
-    if (!el) {
-        return;
-    }
-    const isDraggable = el.hasAttribute("kendoDraggable");
-    const isChild = closest(el, matchesNodeAttr("kendoDraggable")) !== null;
-    const parentDraggable = closest(el, matchesNodeAttr("data-sortable-index"));
-    const index = parentDraggable ? parseInt(parentDraggable.getAttribute("data-sortable-index"), 10) : -1;
-    return {
-        element: el,
-        index: index,
-        isDraggable: isDraggable,
-        isDraggableChild: isChild,
-        parentDraggable: parentDraggable,
-        rect: el.getBoundingClientRect()
-    };
-};
-/**
- * Returns the DraggableDirective under the cursor.
- * @hidden
- */
-export const draggableFromEvent = (event, sortable) => {
-    let target;
-    if (event.changedTouches) {
-        const touch = event.changedTouches[0];
-        target = draggableFromPoint(touch.clientX, touch.clientY);
-    }
-    else {
-        target = draggableFromPoint(event.clientX, event.clientY);
-    }
-    // TODO: refactor sortable. Add draggable getter
-    return sortable.draggables.toArray()[target ? target.index : -1];
-};
-/**
- * @hidden
- */
-export const getAllFocusableChildren = (parent) => {
-    return Array.from(parent.querySelectorAll(focusableSelector)).filter((element) => element.offsetParent !== null);
-};
-/**
- * @hidden
- */
-export const getFirstAndLastFocusable = (parent) => {
-    const all = getAllFocusableChildren(parent);
-    const firstFocusable = all.length > 0 ? all[0] : parent;
-    const lastFocusable = all.length > 0 ? all[all.length - 1] : parent;
-    return [firstFocusable, lastFocusable];
-};
-/**
- * @hidden
- */
-export const keepFocusWithinComponent = (event, wrapper) => {
-    const [firstFocusable, lastFocusable] = getFirstAndLastFocusable(wrapper);
-    const tabAfterLastFocusable = !event.shiftKey && event.target === lastFocusable;
-    const shiftTabAfterFirstFocusable = event.shiftKey && event.target === firstFocusable;
-    if (tabAfterLastFocusable) {
-        event.preventDefault();
-        firstFocusable.focus();
-        wrapper.blur();
-    }
-    if (shiftTabAfterFirstFocusable) {
-        event.preventDefault();
-        lastFocusable.focus();
-    }
-};
-/**
- * @hidden
- */
-export const isFocusable = (element) => {
-    if (element.tagName) {
-        const tagName = element.tagName.toLowerCase();
-        const tabIndex = element.getAttribute('tabIndex');
-        const skipTab = tabIndex === '-1';
-        let focusable = tabIndex !== null && !skipTab;
-        if (focusableRegex.test(tagName)) {
-            focusable = !element.disabled && !skipTab;
-        }
-        return focusable;
-    }
-    return false;
-};
-const toClassList = (classNames) => String(classNames).trim().split(' ');
-/**
- * @hidden
- */
-export const hasClasses = (element, classNames) => {
-    const namesList = toClassList(classNames);
-    return Boolean(toClassList(element.className).find((className) => namesList.indexOf(className) >= 0));
-};
-const isSortable = matchesNodeName('kendo-sortable');
-/**
- * @hidden
- */
-export const widgetTarget = (target) => {
-    const element = closest(target, node => hasClasses(node, 'k-widget') || isSortable(node));
-    return element && !isSortable(element);
-};
-const hasRelativeStackingContext = () => {
-    if (!isDocumentAvailable()) {
-        return false;
-    }
-    const top = 10;
-    const parent = document.createElement("div");
-    parent.style.transform = "matrix(10, 0, 0, 10, 0, 0)";
-    const innerDiv = document.createElement('div');
-    innerDiv.style.position = 'fixed';
-    innerDiv.style.top = `${top}px;`;
-    parent.appendChild(innerDiv);
-    document.body.appendChild(parent);
-    const isDifferent = parent.children[0].getBoundingClientRect().top !== top;
-    document.body.removeChild(parent);
-    return isDifferent;
-};
-const HAS_RELATIVE_STACKING_CONTEXT = hasRelativeStackingContext();
-/**
- * @hidden
- */
-export const relativeContextElement = (element) => {
-    if (!element || !HAS_RELATIVE_STACKING_CONTEXT || !isDocumentAvailable()) {
-        return null;
-    }
-    let node = element.parentElement;
-    while (node) {
-        if (window.getComputedStyle(node).transform !== 'none') {
-            return node;
-        }
-        node = node.parentElement;
-    }
-};