@headless-tree/core 0.0.4 → 0.0.6

package/src/features/main/types.ts

@@ -5,6 +5,7 @@ import {
   SetStateFn,
   TreeConfig,
   TreeState,
+  Updater,
 } from "../../types/core";
 import { ItemMeta } from "../tree/types";
 
@@ -12,10 +13,16 @@ export type MainFeatureDef<T = any> = {
   state: {};
   config: {
     features?: FeatureImplementation<any>[];
+    initialState?: Partial<TreeState<T>>;
     state?: Partial<TreeState<T>>;
     setState?: SetStateFn<TreeState<T>>;
   };
   treeInstance: {
+    /** @internal */
+    applySubStateUpdate: <K extends keyof TreeState<any>>(
+      stateName: K,
+      updater: Updater<TreeState<T>[K]>
+    ) => void;
     setState: SetStateFn<TreeState<T>>;
     getState: () => TreeState<T>;
     setConfig: SetStateFn<TreeConfig<T>>;

package/src/features/renaming/feature.ts

@@ -19,6 +19,11 @@ export const renamingFeature: FeatureImplementation<
     ...defaultConfig,
   }),
 
+  stateHandlerNames: {
+    renamingItem: "setRenamingItem",
+    renamingValue: "setRenamingValue",
+  },
+
   createTreeInstance: (prev, instance) => ({
     ...prev,
 
@@ -30,8 +35,8 @@ export const renamingFeature: FeatureImplementation<
         return;
       }
 
-      config.setRenamingItem?.(itemId);
-      config.setRenamingValue?.(item.getItemName());
+      instance.applySubStateUpdate("renamingItem", itemId);
+      instance.applySubStateUpdate("renamingValue", item.getItemName());
     },
 
     getRenamingItem: () => {
@@ -42,7 +47,7 @@ export const renamingFeature: FeatureImplementation<
     getRenamingValue: () => instance.getState().renamingValue || "",
 
     abortRenaming: () => {
-      instance.getConfig().setRenamingItem?.(null);
+      instance.applySubStateUpdate("renamingItem", null);
     },
 
     completeRenaming: () => {
@@ -51,7 +56,7 @@ export const renamingFeature: FeatureImplementation<
       if (item) {
         config.onRename?.(item, instance.getState().renamingValue || "");
       }
-      instance.getConfig().setRenamingItem?.(null);
+      instance.applySubStateUpdate("renamingItem", null);
     },
 
     isRenamingItem: () => !!instance.getState().renamingItem,
@@ -63,7 +68,7 @@ export const renamingFeature: FeatureImplementation<
       onBlur: () => tree.abortRenaming(),
       value: tree.getRenamingValue(),
       onChange: (e) => {
-        tree.getConfig().setRenamingValue?.(e.target.value);
+        tree.applySubStateUpdate("renamingValue", e.target.value);
       },
     }),
 

package/src/features/search/feature.ts

@@ -25,11 +25,15 @@ export const searchFeature: FeatureImplementation<
     ...defaultConfig,
   }),
 
+  stateHandlerNames: {
+    search: "setSearch",
+  },
+
   createTreeInstance: (prev, instance) => ({
     ...prev,
 
     setSearch: (search) => {
-      instance.getConfig().setSearch?.(search);
+      instance.applySubStateUpdate("search", search);
       instance
         .getItems()
         .find((item) =>
@@ -71,8 +75,9 @@ export const searchFeature: FeatureImplementation<
 
     getSearchMatchingItems: memo(
       (search, items) =>
-        items.filter((item) =>
-          instance.getConfig().isSearchMatchingItem?.(search, item)
+        items.filter(
+          (item) =>
+            search && instance.getConfig().isSearchMatchingItem?.(search, item)
         ),
       () => [instance.getSearchValue(), instance.getItems()]
     ),
@@ -105,12 +110,22 @@ export const searchFeature: FeatureImplementation<
       },
     },
 
+    submitSearch: {
+      hotkey: "Enter",
+      allowWhenInputFocused: true,
+      isEnabled: (tree) => tree.isSearchOpen(),
+      handler: (e, tree) => {
+        tree.closeSearch();
+        tree.setSelectedItems([tree.getFocusedItem().getId()]);
+      },
+    },
+
     nextSearchItem: {
       hotkey: "ArrowDown",
       allowWhenInputFocused: true,
+      canRepeat: true,
       isEnabled: (tree) => tree.isSearchOpen(),
       handler: (e, tree) => {
-        // TODO scroll into view
         const focusItem = tree
           .getSearchMatchingItems()
           .find(
@@ -119,15 +134,16 @@ export const searchFeature: FeatureImplementation<
               tree.getFocusedItem().getItemMeta().index
           );
         focusItem?.setFocused();
+        focusItem?.scrollTo({ block: "nearest", inline: "nearest" });
       },
     },
 
     previousSearchItem: {
       hotkey: "ArrowUp",
       allowWhenInputFocused: true,
+      canRepeat: true,
       isEnabled: (tree) => tree.isSearchOpen(),
       handler: (e, tree) => {
-        // TODO scroll into view
         const focusItem = [...tree.getSearchMatchingItems()]
           .reverse()
           .find(
@@ -136,6 +152,7 @@ export const searchFeature: FeatureImplementation<
               tree.getFocusedItem().getItemMeta().index
           );
         focusItem?.setFocused();
+        focusItem?.scrollTo({ block: "nearest", inline: "nearest" });
       },
     },
   },

package/src/features/search/types.ts

@@ -34,6 +34,7 @@ export type SearchFeatureDef<T> = {
   hotkeys:
     | "openSearch"
     | "closeSearch"
+    | "submitSearch"
     | "nextSearchItem"
     | "previousSearchItem";
 };

package/src/features/selection/feature.ts

@@ -22,11 +22,15 @@ export const selectionFeature: FeatureImplementation<
     ...defaultConfig,
   }),
 
+  stateHandlerNames: {
+    selectedItems: "setSelectedItems",
+  },
+
   createTreeInstance: (prev, instance) => ({
     ...prev,
 
     setSelectedItems: (selectedItems) => {
-      instance.getConfig().setSelectedItems?.(selectedItems);
+      instance.applySubStateUpdate("selectedItems", selectedItems);
     },
 
     // TODO memo
@@ -91,7 +95,8 @@ export const selectionFeature: FeatureImplementation<
 
     getProps: () => ({
       ...prev.getProps(),
-      onClick: (e) => {
+      "aria-selected": item.isSelected() ? "true" : "false",
+      onClick: item.getMemoizedProp("selection/onClick", () => (e) => {
         if (e.shiftKey) {
           item.selectUpTo(e.ctrlKey || e.metaKey);
         } else if (e.ctrlKey || e.metaKey) {
@@ -101,7 +106,7 @@ export const selectionFeature: FeatureImplementation<
         }
 
         prev.getProps().onClick?.(e);
-      },
+      }),
     }),
   }),
 

package/src/features/sync-data-loader/feature.ts

@@ -1,6 +1,7 @@
 import { FeatureImplementation } from "../../types/core";
 import { SyncDataLoaderFeatureDef } from "./types";
 import { MainFeatureDef } from "../main/types";
+import { makeStateUpdater } from "../../utils";
 
 export const syncDataLoaderFeature: FeatureImplementation<
   any,
@@ -10,14 +11,28 @@ export const syncDataLoaderFeature: FeatureImplementation<
   key: "sync-data-loader",
   dependingFeatures: ["main"],
 
+  getInitialState: (initialState) => ({
+    loadingItems: [],
+    ...initialState,
+  }),
+
+  getDefaultConfig: (defaultConfig, tree) => ({
+    setLoadingItems: makeStateUpdater("loadingItems", tree),
+    ...defaultConfig,
+  }),
+
+  stateHandlerNames: {
+    loadingItems: "setLoadingItems",
+  },
+
   createTreeInstance: (prev, instance) => ({
     ...prev,
 
     retrieveItemData: (itemId) =>
-      instance.getConfig().dataLoader.getItem(itemId),
+      instance.getConfig().dataLoader!.getItem(itemId),
 
     retrieveChildrenIds: (itemId) =>
-      instance.getConfig().dataLoader.getChildren(itemId),
+      instance.getConfig().dataLoader!.getChildren(itemId),
   }),
 
   createItemInstance: (prev) => ({

package/src/features/sync-data-loader/types.ts

@@ -7,7 +7,7 @@ export type SyncDataLoaderFeatureDef<T> = {
   state: {};
   config: {
     rootItemId: string;
-    dataLoader: SyncTreeDataLoader<T>;
+    dataLoader?: SyncTreeDataLoader<T>;
   };
   treeInstance: {
     retrieveItemData: (itemId: string) => T;

package/src/features/tree/feature.ts

@@ -1,5 +1,5 @@
 import { FeatureImplementation, ItemInstance } from "../../types/core";
-import { ItemMeta, TreeFeatureDef } from "./types";
+import { ItemMeta, TreeFeatureDef, TreeItemDataRef } from "./types";
 import { makeStateUpdater, memo, poll } from "../../utils";
 import { MainFeatureDef } from "../main/types";
 import { HotkeysCoreFeatureDef } from "../hotkeys-core/types";
@@ -28,6 +28,11 @@ export const treeFeature: FeatureImplementation<
     ...defaultConfig,
   }),
 
+  stateHandlerNames: {
+    expandedItems: "setExpandedItems",
+    focusedItem: "setFocusedItem",
+  },
+
   createTreeInstance: (prev, instance) => ({
     ...prev,
 
@@ -45,7 +50,6 @@ export const treeFeature: FeatureImplementation<
     getItemsMeta: () => {
       const { rootItemId } = instance.getConfig();
       const { expandedItems } = instance.getState();
-      // console.log("!", instance.getConfig());
       const flatItems: ItemMeta[] = [];
 
       const recursiveAdd = (
@@ -91,9 +95,10 @@ export const treeFeature: FeatureImplementation<
         return;
       }
 
-      instance
-        .getConfig()
-        .setExpandedItems?.((expandedItems) => [...expandedItems, itemId]);
+      instance.applySubStateUpdate("expandedItems", (expandedItems) => [
+        ...expandedItems,
+        itemId,
+      ]);
       instance.rebuildTree();
     },
 
@@ -102,11 +107,9 @@ export const treeFeature: FeatureImplementation<
         return;
       }
 
-      instance
-        .getConfig()
-        .setExpandedItems?.((expandedItems) =>
-          expandedItems.filter((id) => id !== itemId)
-        );
+      instance.applySubStateUpdate("expandedItems", (expandedItems) =>
+        expandedItems.filter((id) => id !== itemId)
+      );
       instance.rebuildTree();
     },
 
@@ -119,7 +122,7 @@ export const treeFeature: FeatureImplementation<
     },
 
     focusItem: (itemId) => {
-      instance.getConfig().setFocusedItem?.(itemId);
+      instance.applySubStateUpdate("focusedItem", itemId);
     },
 
     focusNextItem: () => {
@@ -134,7 +137,7 @@ export const treeFeature: FeatureImplementation<
       instance.focusItem(instance.getItems()[nextIndex].getId());
     },
 
-    updateDomFocus: (scrollIntoView) => {
+    updateDomFocus: () => {
       // Required because if the state is managed outside in react, the state only updated during next render
       setTimeout(async () => {
         const focusedItem = instance.getFocusedItem();
@@ -143,9 +146,6 @@ export const treeFeature: FeatureImplementation<
         const focusedElement = focusedItem.getElement();
         if (!focusedElement) return;
         focusedElement.focus();
-        // if (scrollIntoView) {
-        //   focusedElement.scrollIntoView();
-        // }
       });
     },
 
@@ -162,6 +162,11 @@ export const treeFeature: FeatureImplementation<
     isLoading: () => {
       throw new Error("No data-loader registered");
     },
+    scrollTo: async (scrollIntoViewArg) => {
+      tree.getConfig().scrollToItem?.(item as any);
+      await poll(() => item.getElement() !== null, 20);
+      item.getElement()!.scrollIntoView(scrollIntoViewArg);
+    },
     getId: () => item.getItemMeta().itemId,
     getProps: () => {
       const itemMeta = item.getItemMeta();
@@ -170,11 +175,11 @@ export const treeFeature: FeatureImplementation<
         role: "treeitem",
         "aria-setsize": itemMeta.setSize,
         "aria-posinset": itemMeta.posInSet,
-        "aria-selected": false,
+        "aria-selected": "false",
         "aria-label": item.getItemName(),
         "aria-level": itemMeta.level,
         tabIndex: item.isFocused() ? 0 : -1,
-        onClick: (e) => {
+        onClick: item.getMemoizedProp("tree/onClick", () => (e) => {
           item.setFocused();
           item.primaryAction();
 
@@ -191,7 +196,7 @@ export const treeFeature: FeatureImplementation<
           } else {
             item.expand();
           }
-        },
+        }),
       };
     },
     expand: () => tree.expandItem(item.getItemMeta().itemId),
@@ -224,10 +229,8 @@ export const treeFeature: FeatureImplementation<
       },
       () => [item.getItemMeta()]
     ),
-    getIndexInParent: () =>
-      item.getItemMeta().index -
-      (item.getParent()?.getItemMeta().index ?? 0) -
-      1,
+    // TODO remove
+    getIndexInParent: () => item.getItemMeta().posInSet,
     getChildren: () =>
       tree
         .retrieveChildrenIds(item.getItemMeta().itemId)
@@ -235,6 +238,23 @@ export const treeFeature: FeatureImplementation<
     getTree: () => tree as any,
     getItemAbove: () => tree.getItems()[item.getItemMeta().index - 1],
     getItemBelow: () => tree.getItems()[item.getItemMeta().index + 1],
+    getMemoizedProp: (name, create, deps) => {
+      const data = item.getDataRef<TreeItemDataRef>();
+      const memoizedValue = data.current.memoizedValues?.[name];
+      if (
+        memoizedValue &&
+        (!deps ||
+          data.current.memoizedDeps?.[name]?.every((d, i) => d === deps![i]))
+      ) {
+        return memoizedValue;
+      }
+      data.current.memoizedDeps ??= {};
+      data.current.memoizedValues ??= {};
+      const value = create();
+      data.current.memoizedDeps[name] = deps;
+      data.current.memoizedValues[name] = value;
+      return value;
+    },
   }),
 
   hotkeys: {
@@ -283,7 +303,7 @@ export const treeFeature: FeatureImplementation<
           item.getItemMeta().level !== 0
         ) {
           item.getParent()?.setFocused();
-          tree.updateDomFocus(true);
+          tree.updateDomFocus();
         } else {
           item.collapse();
         }

package/src/features/tree/types.ts

@@ -9,6 +9,11 @@ export type ItemMeta = {
   posInSet: number;
 };
 
+export type TreeItemDataRef = {
+  memoizedValues: Record<string, any>;
+  memoizedDeps: Record<string, any[] | undefined>;
+};
+
 export type TreeFeatureDef<T> = {
   state: {
     expandedItems: string[];
@@ -36,8 +41,7 @@ export type TreeFeatureDef<T> = {
     getFocusedItem: () => ItemInstance<any>;
     focusNextItem: () => void;
     focusPreviousItem: () => void;
-    scrollToItem: (item: ItemInstance<any>) => void;
-    updateDomFocus: (scrollIntoView?: boolean) => void;
+    updateDomFocus: () => void;
 
     getContainerProps: () => Record<string, any>;
   };
@@ -59,6 +63,10 @@ export type TreeFeatureDef<T> = {
     getTree: () => TreeInstance<T>;
     getItemAbove: () => ItemInstance<T> | null;
     getItemBelow: () => ItemInstance<T> | null;
+    getMemoizedProp: <X>(name: string, create: () => X, deps?: any[]) => X;
+    scrollTo: (
+      scrollIntoViewArg?: boolean | ScrollIntoViewOptions
+    ) => Promise<void>;
   };
   hotkeys:
     | "focusNextItem"

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./types/core";
 export * from "./core/create-tree";
+
 export * from "./features/tree/types";
 export * from "./features/main/types";
 export * from "./features/drag-and-drop/types";
@@ -20,4 +21,6 @@ export * from "./features/search/feature";
 export * from "./features/renaming/feature";
 export * from "./features/expand-all/feature";
 
-export * from "./data-adapters/nested-data-adapter";
+export * from "./utilities/create-on-drop-handler";
+export * from "./utilities/insert-items-at-target";
+export * from "./utilities/remove-items-from-parents";

package/src/types/core.ts

@@ -130,6 +130,10 @@ export type FeatureImplementation<
   key?: string;
   dependingFeatures?: string[];
 
+  stateHandlerNames?: Partial<
+    Record<keyof MergedFeatures<F>["state"], keyof MergedFeatures<F>["config"]>
+  >;
+
   getInitialState?: (
     initialState: Partial<MergedFeatures<F>["state"]>,
     tree: MergedFeatures<F>["treeInstance"]
@@ -174,9 +178,5 @@ export type FeatureImplementation<
     tree: MergedFeatures<F>["treeInstance"]
   ) => void;
 
-  setState?: (instance: MergedFeatures<F>["treeInstance"]) => void;
-  onConfigChange?: (instance: MergedFeatures<F>["treeInstance"]) => void;
-  onStateOrConfigChange?: (instance: MergedFeatures<F>["treeInstance"]) => void;
-
   hotkeys?: HotkeysConfig<T, D>;
 };

package/src/utilities/create-on-drop-handler.ts

@@ -0,0 +1,14 @@
+import { ItemInstance } from "../types/core";
+import { DropTarget } from "../features/drag-and-drop/types";
+import { removeItemsFromParents } from "./remove-items-from-parents";
+import { insertItemsAtTarget } from "./insert-items-at-target";
+
+export const createOnDropHandler =
+  <T>(
+    onChangeChildren: (item: ItemInstance<T>, newChildren: string[]) => void
+  ) =>
+  (items: ItemInstance<T>[], target: DropTarget<T>) => {
+    const itemIds = items.map((item) => item.getId());
+    removeItemsFromParents(items, onChangeChildren);
+    insertItemsAtTarget(itemIds, target, onChangeChildren);
+  };

package/src/utilities/insert-items-at-target.ts

@@ -0,0 +1,30 @@
+import { ItemInstance } from "../types/core";
+import { DropTarget } from "../features/drag-and-drop/types";
+
+export const insertItemsAtTarget = <T>(
+  itemIds: string[],
+  target: DropTarget<T>,
+  onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void
+) => {
+  // add moved items to new common parent, if dropped onto parent
+  if (target.childIndex === null) {
+    onChangeChildren(target.item, [
+      ...target.item.getChildren().map((item) => item.getId()),
+      ...itemIds,
+    ]);
+    // TODO items[0].getTree().rebuildTree();
+    return;
+  }
+
+  // add moved items to new common parent, if dropped between siblings
+  const oldChildren = target.item.getChildren();
+  const newChildren = [
+    ...oldChildren.slice(0, target.insertionIndex).map((item) => item.getId()),
+    ...itemIds,
+    ...oldChildren.slice(target.insertionIndex).map((item) => item.getId()),
+  ];
+
+  onChangeChildren(target.item, newChildren);
+
+  target.item.getTree().rebuildTree();
+};

package/src/utilities/remove-items-from-parents.ts

@@ -0,0 +1,21 @@
+import { ItemInstance } from "../types/core";
+
+export const removeItemsFromParents = <T>(
+  movedItems: ItemInstance<T>[],
+  onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void
+) => {
+  // TODO bulk sibling changes together
+  for (const item of movedItems) {
+    const siblings = item.getParent()?.getChildren();
+    if (siblings) {
+      onChangeChildren(
+        item.getParent(),
+        siblings
+          .filter((sibling) => sibling.getId() !== item.getId())
+          .map((i) => i.getId())
+      );
+    }
+  }
+
+  movedItems[0].getTree().rebuildTree();
+};

package/src/utils.ts

@@ -1,5 +1,4 @@
-import { ItemInstance, TreeState, Updater } from "./types/core";
-import { DropTarget } from "./features/drag-and-drop/types";
+import { TreeState, Updater } from "./types/core";
 
 export type NoInfer<T> = [T][T extends any ? 0 : never];
 
@@ -53,73 +52,6 @@ export function makeStateUpdater<K extends keyof TreeState<any>>(
   };
 }
 
-export const scrollIntoView = (element: Element | undefined | null) => {
-  if (!element) {
-    return;
-  }
-
-  if ((element as any).scrollIntoViewIfNeeded) {
-    (element as any).scrollIntoViewIfNeeded();
-  } else {
-    const boundingBox = element.getBoundingClientRect();
-    const isElementInViewport =
-      boundingBox.top >= 0 &&
-      boundingBox.left >= 0 &&
-      boundingBox.bottom <=
-        (window.innerHeight || document.documentElement.clientHeight) &&
-      boundingBox.right <=
-        (window.innerWidth || document.documentElement.clientWidth);
-    if (!isElementInViewport) {
-      element.scrollIntoView();
-    }
-  }
-};
-
-export const performItemsMove = <T>(
-  items: ItemInstance<T>[],
-  target: DropTarget<T>,
-  onChangeChildren: (
-    item: ItemInstance<T>,
-    newChildren: ItemInstance<T>[]
-  ) => void
-) => {
-  const numberOfDragItemsBeforeTarget = !target.childIndex
-    ? 0
-    : target.item
-        .getChildren()
-        .slice(0, target.childIndex)
-        .filter((child) => items.some((item) => item.getId() === child.getId()))
-        .length;
-
-  // TODO bulk sibling changes together
-  for (const item of items) {
-    const siblings = item.getParent()?.getChildren();
-    if (siblings) {
-      onChangeChildren(
-        item.getParent(),
-        siblings.filter((sibling) => sibling.getId() !== item.getId())
-      );
-    }
-  }
-
-  if (target.childIndex === null) {
-    onChangeChildren(target.item, [...target.item.getChildren(), ...items]);
-    items[0].getTree().rebuildTree();
-    return;
-  }
-
-  const oldChildren = target.item.getChildren();
-  const newChildren = [
-    ...oldChildren.slice(0, target.childIndex - numberOfDragItemsBeforeTarget),
-    ...items,
-    ...oldChildren.slice(target.childIndex - numberOfDragItemsBeforeTarget),
-  ];
-
-  onChangeChildren(target.item, newChildren);
-
-  items[0].getTree().rebuildTree();
-};
-
 export const poll = (fn: () => boolean, interval = 100, timeout = 1000) =>
   new Promise<void>((resolve) => {
     let clear: ReturnType<typeof setTimeout>;

package/tsconfig.json

@@ -2,6 +2,6 @@
   "extends": "../../tsconfig.json",
   "include": ["./src/**/*"],
   "compilerOptions": {
-    "outDir": "lib/cjs"
+    "outDir": "lib/esm"
   }
 }

package/lib/cjs/data-adapters/nested-data-adapter.d.ts

@@ -1,9 +0,0 @@
-import { DataAdapterConfig } from "./types";
-interface NestedDataAdapterProps<T> {
-    rootItem: T;
-    getItemId: (item: T) => string;
-    getChildren: (item: T) => T[] | undefined;
-    changeChildren?: (item: T, children: T[]) => void;
-}
-export declare const nestedDataAdapter: <T = any>(props: NestedDataAdapterProps<T>) => DataAdapterConfig<T>;
-export {};

package/lib/cjs/data-adapters/nested-data-adapter.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nestedDataAdapter = void 0;
-const utils_1 = require("../utils");
-const createItemMap = (props, item, map = {}) => {
-    var _a;
-    map[props.getItemId(item)] = item;
-    (_a = props.getChildren(item)) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
-        createItemMap(props, child, map);
-    });
-    return map;
-};
-const nestedDataAdapter = (props) => {
-    const itemMap = createItemMap(props, props.rootItem);
-    return {
-        rootItemId: props.getItemId(props.rootItem),
-        dataLoader: {
-            getItem: (itemId) => itemMap[itemId],
-            getChildren: (itemId) => { var _a, _b; return (_b = (_a = props.getChildren(itemMap[itemId])) === null || _a === void 0 ? void 0 : _a.map(props.getItemId)) !== null && _b !== void 0 ? _b : []; },
-        },
-        onDrop: (items, target) => {
-            if (!props.changeChildren) {
-                return;
-            }
-            (0, utils_1.performItemsMove)(items, target, (item, newChildren) => {
-                var _a;
-                (_a = props.changeChildren) === null || _a === void 0 ? void 0 : _a.call(props, item.getItemData(), newChildren.map((child) => child.getItemData()));
-            });
-        },
-    };
-};
-exports.nestedDataAdapter = nestedDataAdapter;