[dist] create new build

Author: Wayne Van Son

dist/index.d.ts

@@ -1,6 +1,4 @@
 export { ReactSortable } from "./react-sortable";
 export * from "./types";
-export { MultiDrag, Swap, DOMRect, Direction, GroupOptions, MoveEvent, Options, PullResult, PutResult, SortableEvent, SortableOptions, Utils } from "sortablejs";
-import SortableGlobal from "sortablejs";
-export declare const Sortable: typeof SortableGlobal;
+export { default as Sortable, MultiDrag, Swap, DOMRect, Direction, GroupOptions, MoveEvent, Options, PullResult, PutResult, SortableEvent, SortableOptions, Utils } from "sortablejs";
 //# sourceMappingURL=index.d.ts.map

dist/index.d.ts.map

@@ -1,14 +1,9 @@
 import { Component, ReactElement } from "react";
 import Sortable, { Options, SortableEvent } from "sortablejs";
 import { AllMethodsExceptMove, HandledMethodNames, ItemInterface, ReactSortableProps } from "./types";
-/**
- * React is built for synchornizing data with the browser.
- *
- * Data should be an object.
- */
 export declare class ReactSortable<T extends ItemInterface> extends Component<ReactSortableProps<T>> {
-    private ref;
     static defaultProps: Partial<ReactSortableProps<any>>;
+    private ref;
     constructor(props: ReactSortableProps<T>);
     componentDidMount(): void;
     render(): ReactElement<import("react").RefAttributes<any>, string | ((props: any) => ReactElement<any, string | any | (new (props: any) => Component<any, any, any>)> | null) | (new (props: any) => Component<any, any, any>)>;
@@ -23,30 +18,23 @@ export declare class ReactSortable<T extends ItemInterface> extends Component<Re
     prepareOnHandlerProp(evtName: Exclude<AllMethodsExceptMove, HandledMethodNames>): (evt: Sortable.SortableEvent) => void;
     /** Calls the `props.on[Handler]` function */
     callOnHandlerProp(evt: SortableEvent, evtName: AllMethodsExceptMove): void;
-    /** Called when an element is dropped into the list from another list */
-    onAdd(evt: SortableEvent): void;
-    /** Called when an element is removed from the list into another list */
-    onRemove(evt: SortableEvent): void;
-    /** Called when sorting is changed within the same list */
+    onAdd(evt: MultiDragEvent): void;
+    onRemove(evt: MultiDragEvent): void;
     onUpdate(evt: MultiDragEvent): void;
-    /** Called when the dragging starts */
     onStart(evt: SortableEvent): void;
-    /** Called when the dragging ends */
     onEnd(evt: SortableEvent): void;
-    /** Called when the `onSpill` plugin is activated */
+    onChoose(evt: SortableEvent): void;
+    onUnchoose(evt: SortableEvent): void;
     onSpill(evt: SortableEvent): void;
-    /** Called when a clone is made. It replaces an element in with a function */
-    onClone(evt: SortableEvent): void;
-    /** @todo */
-    onSelect(evt: SortableEvent): void;
-    /** @todo */
-    onDeselect(evt: SortableEvent): void;
+    onSelect(evt: MultiDragEvent): void;
+    onDeselect(evt: MultiDragEvent): void;
 }
 interface MultiIndices {
     multiDragElement: HTMLElement;
     index: number;
 }
-interface MultiDragEvent extends SortableEvent {
+export interface MultiDragEvent extends SortableEvent {
+    clones: HTMLElement[];
     oldIndicies: MultiIndices[];
     newIndicies: MultiIndices[];
     swapItem: HTMLElement | null;

dist/index.es.js

@@ -1,14 +1,18 @@
-import Sortable, { SortableEvent, Options, MoveEvent } from "sortablejs";
-import { ForwardRefExoticComponent, RefAttributes, ReactHTML, CSSProperties } from "react";
+import { CSSProperties, ForwardRefExoticComponent, ReactHTML, RefAttributes } from "react";
+import Sortable, { MoveEvent, Options, SortableEvent } from "sortablejs";
 import { ReactSortable } from "./react-sortable";
 export interface ItemInterface {
+    /** The unique id associated with your item. It's recommended this is the same as the key prop for your list item. */
     id: string | number;
+    /** When true, the item is selected using MultiDrag */
     selected?: boolean;
+    /** When true, the item is deemed "chosen", which basically just a mousedown event. */
     chosen?: boolean;
+    /** When true, it will not be possible to pick this item up in the list. */
     filtered?: boolean;
     [property: string]: any;
 }
-export interface ReactSortableProps<T> extends ReactSortableOptions {
+export interface ReactSortableProps<T> extends ReactSortableOptions, Omit<Options, AllMethodNames> {
     /**
      * The list of items to use.
      */
@@ -26,13 +30,6 @@ export interface ReactSortableProps<T> extends ReactSortableOptions {
      * forwardRef<HTMLElement, YOURPROPS>((props, ref) => <button {...props} ref={ref} />)
      */
     tag?: ForwardRefExoticComponent<RefAttributes<any>> | keyof ReactHTML;
-    style?: CSSProperties;
-    className?: string;
-    id?: string;
-    /**
-     * Parse the plugins you'd like to use in Sortable.
-     */
-    plugins?: Sortable.Plugin | Array<Sortable.Plugin>;
     /**
      * If this is provided, the function will replace the clone in place.
      *
@@ -41,6 +38,9 @@ export interface ReactSortableProps<T> extends ReactSortableOptions {
      * and the new clone will be placed in `A`
      */
     clone?: (currentItem: T, evt: SortableEvent) => T;
+    style?: CSSProperties;
+    className?: string;
+    id?: string;
 }
 /**
  * Holds the react component as a reference so we can access it's store.
@@ -54,7 +54,7 @@ export interface Store {
  * Change the `on[...]` methods in Sortable.Options,
  * so that they all have an extra arg that is `store: Store`
  */
-export declare type ReactSortableOptions = Omit<Options, AllMethodNames> & Partial<Record<AllMethodsExceptMove, (evt: SortableEvent, sortable: Sortable | null, store: Store) => void>> & {
+export declare type ReactSortableOptions = Partial<Record<AllMethodsExceptMove, (evt: SortableEvent, sortable: Sortable | null, store: Store) => void>> & {
     /**
      * The default sortable behaviour has been changed.
      *
@@ -67,7 +67,7 @@ export declare type ReactSortableOptions = Omit<Options, AllMethodNames> & Parti
 /** All method names starting with `on` in `Sortable.Options` */
 export declare type AllMethodNames = "onAdd" | "onChange" | "onChoose" | "onClone" | "onEnd" | "onFilter" | "onMove" | "onRemove" | "onSort" | "onSpill" | "onStart" | "onUnchoose" | "onUpdate" | "onSelect" | "onDeselect";
 /** Method names that fire in `this`, when this is react-sortable */
-export declare type HandledMethodNames = "onAdd" | "onRemove" | "onUpdate" | "onStart" | "onEnd" | "onSpill" | "onSelect" | "onDeselect" | "onClone";
+export declare type HandledMethodNames = "onAdd" | "onRemove" | "onUpdate" | "onStart" | "onEnd" | "onSpill" | "onSelect" | "onDeselect" | "onChoose" | "onUnchoose";
 export declare type UnHandledMethodNames = Exclude<AllMethodsExceptMove, HandledMethodNames | "onMove">;
 /**
  * Same as `SortableMethodKeys` type but with out the string `onMove`.

dist/index.js

@@ -1,5 +1,7 @@
 import { PropsWithChildren } from "react";
 import { Options } from "sortablejs";
+import { ItemInterface } from "../dist";
+import { MultiDragEvent } from "./react-sortable";
 import { AllMethodNames, ReactSortableProps } from "./types";
 /**
  * Removes the `node` from the DOM
@@ -13,6 +15,26 @@ export declare function removeNode(node: HTMLElement): void;
  * @param index index of the parent to place the new child in.
  */
 export declare function insertNodeAt(parent: HTMLElement, newChild: HTMLElement, index: number): void;
+/** removes stuff from the dom in a nice order */
+export declare function handleDOMChanges<T extends ItemInterface>(customs: Normalized<T>[]): void;
+export declare function removeNodes<T extends ItemInterface>(customs: Normalized<T>[]): void;
+export declare function insertNodes<T extends ItemInterface>(customs: Normalized<T>[]): void;
+export declare function createCustoms<T extends ItemInterface>(evt: MultiDragEvent, list: T[]): Normalized<T>[];
+/** moves items form old index to new index without breaking anything ideally. */
+export declare function handleStateChanges<T extends ItemInterface>(normalized: Normalized<T>[], list: T[]): T[];
+export declare function handleStateRemove<T extends ItemInterface>(normalized: Normalized<T>[], list: T[]): T[];
+export declare function handleStateAdd<T extends ItemInterface>(normalized: Normalized<T>[], list: T[]): T[];
+export declare function getMode(evt: MultiDragEvent): "multidrag" | "swap" | "normal";
+export declare function createNormalized<T extends ItemInterface>(inputs: Input[], list: T[]): Normalized<T>[];
+export interface Input {
+    parentElement: HTMLElement;
+    element: HTMLElement;
+    oldIndex: number;
+    newIndex: number;
+}
+export interface Normalized<T> extends Input {
+    item: T;
+}
 /**
  * Removes the following group of properties from `props`,
  * leaving only `Sortable.Options` without any `on` methods.