Fix types

Author: RobbieTheWagner

addon/components/drag-sort-item.ts

@@ -19,11 +19,11 @@ interface DragSortItemSignature {
     determineForeignPositionAction: unknown;
     draggingEnabled: boolean;
     dragEndAction?: unknown;
-    dragStartAction?: unknown;
+    dragStartAction?: (args: { event: DragEvent; element: HTMLElement; draggedItem: unknown }) => void;
     group: string;
-    handle?: unknown;
-    index?: number;
-    isHorizontal?: boolean;
+    handle?: string;
+    index: number;
+    isHorizontal: boolean;
     isRtl?: boolean;
     item: unknown;
     items: Array<unknown>;

addon/components/drag-sort-list.ts

@@ -9,15 +9,15 @@ interface DragSortListSignature {
     additionalArgs: unknown;
     childClass?: string;
     childTagName?: string;
-    determineForeignPositionAction?: unknown;
+    determineForeignPositionAction?: (args: { draggedItem: unknown; items: Array<unknown> }) => number;
     draggingEnabled: boolean;
     dragEndAction?: unknown;
     dragStartAction?: unknown;
     handle?: unknown;
     items: Array<unknown>;
     isHorizontal?: boolean;
     isRtl?: boolean;
-    group: unknown;
+    group: string;
     sourceOnly: boolean;
   };
 }
@@ -175,8 +175,8 @@ export default class DragSortList extends Component<DragSortListSignature> {
 
     let index =
       items === sourceList
-        ? items.indexOf(draggedItem) + 1
-        : determineForeignPositionAction({ draggedItem, items });
+        ? (items as Array<unknown>).indexOf(draggedItem) + 1
+        : determineForeignPositionAction!({ draggedItem, items });
 
     if (index >= itemsLength) {
       index = itemsLength - 1;

addon/services/drag-sort.ts

@@ -23,7 +23,22 @@ export default class DragSort extends Service.extend(EventedMixin) {
   @tracked lastDragEnteredList: unknown | null = null;
   @tracked isHorizontal?: boolean;
 
-  startDragging({ additionalArgs, item, index, items, group, isHorizontal }) {
+  startDragging({
+    additionalArgs,
+    item,
+    index,
+    items,
+    group,
+    isHorizontal,
+  }: {
+    additionalArgs: unknown;
+    item: unknown;
+    index: number;
+    items: Array<unknown>;
+    group: string;
+    isHorizontal: boolean;
+  }) {
+    // @ts-expect-error TODO: fix this type error
     setProperties(this, {
       isDragging: true,
       isDraggingUp: false,
@@ -51,7 +66,17 @@ export default class DragSort extends Service.extend(EventedMixin) {
     });
   }
 
-  draggingOver({ group, index, items, isDraggingUp }) {
+  draggingOver({
+    group,
+    index,
+    items,
+    isDraggingUp,
+  }: {
+    group: string;
+    index: number;
+    items: Array<unknown>;
+    isDraggingUp: boolean;
+  }) {
     // Ignore hovers over irrelevant groups
     if (group !== this.group) return;
 
@@ -81,7 +106,19 @@ export default class DragSort extends Service.extend(EventedMixin) {
     });
   }
 
-  dragEntering({ group, items, isHorizontal, targetArgs, targetIndex = 0 }) {
+  dragEntering({
+    group,
+    items,
+    isHorizontal,
+    targetArgs,
+    targetIndex = 0,
+  }: {
+    group: string;
+    items: Array<unknown>;
+    isHorizontal?: boolean;
+    targetArgs: unknown;
+    targetIndex?: number;
+  }) {
     // Ignore entering irrelevant groups
     if (group !== this.group) return;
 
@@ -106,14 +143,15 @@ export default class DragSort extends Service.extend(EventedMixin) {
     }
 
     // Remember entering a new list
+    // @ts-expect-error TODO: fix this type error
     setProperties(this, {
       targetList: items,
       lastDragEnteredList: items,
       isHorizontal: isHorizontal,
     });
   }
 
-  endDragging({ action }) {
+  endDragging({ action }: { action: unknown }) {
     const sourceArgs = this.sourceArgs;
     const sourceList = this.sourceList;
     const sourceIndex = this.sourceIndex as number;
@@ -133,11 +171,11 @@ export default class DragSort extends Service.extend(EventedMixin) {
         // Dragging down
         !isDraggingUp &&
         // Target index is not after the last item
-        targetIndex < targetList.get('length') &&
+        targetIndex < (targetList as any)?.get('length') &&
         // The only element in target list is not the one dragged
         !(
-          targetList.get('length') === 1 &&
-          targetList.get('firstObject') === draggedItem
+          (targetList as any)?.get('length') === 1 &&
+          (targetList as any)?.get('firstObject') === draggedItem
         )
       )
         targetIndex++;