react-arborist 3.10.4 → 3.10.5

package/dist/main/interfaces/tree-api.d.ts

@@ -149,6 +149,19 @@ export declare class TreeApi<T> {
     get matchFn(): (node: NodeApi<T>) => boolean;
     accessChildren(data: T): readonly T[] | null;
     accessId(data: T): string;
+    /**
+     * Resolve an identifier to a node id. Public methods accept an id string, a
+     * NodeApi, or the raw row data; this is the one place that turns any of those
+     * into the string id used internally. Raw data is run through the configured
+     * `idAccessor` so a custom accessor (e.g. `uuid`) is honored everywhere, not
+     * just where nodes were built. A NodeApi already carries its accessor-derived
+     * `id`, so it is used directly rather than re-accessed (the accessor reads the
+     * underlying data, which a NodeApi does not expose under that key). Unlike
+     * `accessId`, an unresolved id comes back as `undefined` rather than throwing,
+     * preserving the previous behavior of the `id`-only lookup.
+     */
+    identify(identity: string | IdObj | T): string;
+    identifyNull(identity: Identity | T): string | null;
     get firstNode(): NodeApi<T>;
     get lastNode(): NodeApi<T>;
     get focusedNode(): NodeApi<T> | null;
@@ -158,7 +171,7 @@ export declare class TreeApi<T> {
     get(id: string | null): NodeApi<T> | null;
     at(index: number): NodeApi<T> | null;
     nodesBetween(startId: string | null, endId: string | null): NodeApi<T>[];
-    indexOf(id: Identity): number | null;
+    indexOf(id: Identity | T): number | null;
     get editingId(): string | null;
     createInternal(): Promise<void>;
     createLeaf(): Promise<void>;
@@ -167,36 +180,36 @@ export declare class TreeApi<T> {
         parentId?: null | string;
         index?: null | number;
     }): Promise<void>;
-    delete(node: Identity | string[] | IdObj[]): Promise<void>;
-    edit(node: string | IdObj): Promise<EditResult>;
-    submit(identity: Identity, value: string): Promise<void>;
+    delete(node: Identity | T | (string | IdObj | T)[]): Promise<void>;
+    edit(node: string | IdObj | T): Promise<EditResult>;
+    submit(identity: Identity | T, value: string): Promise<void>;
     reset(): void;
-    activate(id: Identity): void;
+    activate(id: Identity | T): void;
     private resolveEdit;
     get selectedIds(): Set<string>;
     get selectedNodes(): NodeApi<T>[];
-    focus(node: Identity, opts?: {
+    focus(node: Identity | T, opts?: {
         scroll?: boolean;
     }): void;
     pageUp(): void;
     pageDown(): void;
-    select(node: Identity, opts?: {
+    select(node: Identity | T, opts?: {
         align?: Align;
         focus?: boolean;
     }): void;
-    deselect(node: Identity): void;
-    selectMulti(identity: Identity, opts?: {
+    deselect(node: Identity | T): void;
+    selectMulti(identity: Identity | T, opts?: {
         align?: Align;
         focus?: boolean;
     }): void;
-    selectContiguous(identity: Identity): void;
+    selectContiguous(identity: Identity | T): void;
     deselectAll(): void;
     selectAll(): void;
     private filterSelectableNodes;
     setSelection(args: {
-        ids: (IdObj | string)[] | null;
-        anchor: Identity;
-        mostRecent: Identity;
+        ids: (IdObj | string | T)[] | null;
+        anchor: Identity | T;
+        mostRecent: Identity | T;
     }): void;
     get cursorParentId(): string | null;
     get cursorOverFolder(): boolean;
@@ -208,14 +221,14 @@ export declare class TreeApi<T> {
     drop(): void;
     hideCursor(): void;
     showCursor(cursor: Cursor): void;
-    open(identity: Identity, redraw?: boolean): void;
-    close(identity: Identity, redraw?: boolean): void;
-    toggle(identity: Identity): void;
-    openParents(identity: Identity): void;
+    open(identity: Identity | T, redraw?: boolean): void;
+    close(identity: Identity | T, redraw?: boolean): void;
+    toggle(identity: Identity | T): void;
+    openParents(identity: Identity | T): void;
     openSiblings(node: NodeApi<T>): void;
     openAll(): void;
     closeAll(): void;
-    scrollTo(identity: Identity, align?: Align): Promise<void> | undefined;
+    scrollTo(identity: Identity | T, align?: Align): Promise<void> | undefined;
     get isEditing(): boolean;
     get isFiltered(): boolean;
     get hasFocus(): boolean;
@@ -228,10 +241,10 @@ export declare class TreeApi<T> {
     isDraggable(data: T): boolean;
     isSelectable(data: T): boolean;
     private isActionPossible;
-    isDragging(node: Identity): boolean;
+    isDragging(node: Identity | T): boolean;
     isFocused(id: string): boolean;
     isMatch(node: NodeApi<T>): boolean;
-    willReceiveDrop(node: Identity): boolean;
+    willReceiveDrop(node: Identity | T): boolean;
     onFocus(): void;
     onBlur(): void;
     onItemsRendered(args: ListOnItemsRenderedProps): void;

package/dist/main/interfaces/tree-api.js

@@ -37,6 +37,7 @@ const utils = __importStar(require("../utils"));
 const default_cursor_1 = require("../components/default-cursor");
 const default_row_1 = require("../components/default-row");
 const default_node_1 = require("../components/default-node");
+const node_api_1 = require("./node-api");
 const edit_slice_1 = require("../state/edit-slice");
 const focus_slice_1 = require("../state/focus-slice");
 const create_root_1 = require("../data/create-root");
@@ -47,7 +48,7 @@ const default_drag_preview_1 = require("../components/default-drag-preview");
 const default_container_1 = require("../components/default-container");
 const create_list_1 = require("../data/create-list");
 const create_index_1 = require("../data/create-index");
-const { safeRun, identify, identifyNull } = utils;
+const { safeRun } = utils;
 class TreeApi {
     constructor(store, props, list, listEl) {
         this.store = store;
@@ -189,6 +190,30 @@ class TreeApi {
             throw new Error("Data must contain an 'id' property or props.idAccessor must return a string");
         return id;
     }
+    /**
+     * Resolve an identifier to a node id. Public methods accept an id string, a
+     * NodeApi, or the raw row data; this is the one place that turns any of those
+     * into the string id used internally. Raw data is run through the configured
+     * `idAccessor` so a custom accessor (e.g. `uuid`) is honored everywhere, not
+     * just where nodes were built. A NodeApi already carries its accessor-derived
+     * `id`, so it is used directly rather than re-accessed (the accessor reads the
+     * underlying data, which a NodeApi does not expose under that key). Unlike
+     * `accessId`, an unresolved id comes back as `undefined` rather than throwing,
+     * preserving the previous behavior of the `id`-only lookup.
+     */
+    identify(identity) {
+        if (typeof identity === "string")
+            return identity;
+        if (identity instanceof node_api_1.NodeApi)
+            return identity.id;
+        const get = this.props.idAccessor || "id";
+        return utils.access(identity, get);
+    }
+    identifyNull(identity) {
+        if (identity === null || identity === undefined)
+            return null;
+        return this.identify(identity);
+    }
     /* Node Access */
     get firstNode() {
         var _a;
@@ -244,7 +269,7 @@ class TreeApi {
         return this.visibleNodes.slice(start, end + 1);
     }
     indexOf(id) {
-        const key = utils.identifyNull(id);
+        const key = this.identifyNull(id);
         if (!key)
             return null;
         return this.idToIndex[key];
@@ -287,7 +312,7 @@ class TreeApi {
             if (!node)
                 return;
             const idents = Array.isArray(node) ? node : [node];
-            const ids = idents.map(identify);
+            const ids = idents.map((i) => this.identify(i));
             const nodes = ids.map((id) => this.get(id)).filter((n) => !!n);
             /* Guard against Math.min(...[]) === Infinity when no ids resolve to nodes. */
             const fromIndex = nodes.length ? Math.min(...nodes.map((n) => { var _a; return (_a = n.rowIndex) !== null && _a !== void 0 ? _a : 0; })) : 0;
@@ -297,7 +322,7 @@ class TreeApi {
     }
     edit(node) {
         var _a, _b;
-        const id = identify(node);
+        const id = this.identify(node);
         this.resolveEdit({ cancelled: true });
         this.scrollTo(id);
         this.dispatch((0, edit_slice_1.edit)(id));
@@ -311,7 +336,7 @@ class TreeApi {
             var _a, _b;
             if (!identity)
                 return;
-            const id = identify(identity);
+            const id = this.identify(identity);
             yield safeRun(this.props.onRename, {
                 id,
                 name: value,
@@ -330,7 +355,7 @@ class TreeApi {
         setTimeout(() => this.onFocus()); // Return focus to element;
     }
     activate(id) {
-        const node = this.get(identifyNull(id));
+        const node = this.get(this.identifyNull(id));
         if (!node)
             return;
         safeRun(this.props.onActivate, node);
@@ -364,7 +389,7 @@ class TreeApi {
             this.select(node);
         }
         else {
-            this.dispatch((0, focus_slice_1.focus)(identify(node)));
+            this.dispatch((0, focus_slice_1.focus)(this.identify(node)));
             if (opts.scroll !== false)
                 this.scrollTo(node);
             if (this.focusedNode)
@@ -404,7 +429,7 @@ class TreeApi {
         if (!node)
             return;
         const changeFocus = opts.focus !== false;
-        const id = identify(node);
+        const id = this.identify(node);
         if (changeFocus)
             this.dispatch((0, focus_slice_1.focus)(id));
         if ((_a = this.get(id)) === null || _a === void 0 ? void 0 : _a.isSelectable) {
@@ -422,12 +447,12 @@ class TreeApi {
     deselect(node) {
         if (!node)
             return;
-        const id = identify(node);
+        const id = this.identify(node);
         this.dispatch(selection_slice_1.actions.remove(id));
         safeRun(this.props.onSelect, this.selectedNodes);
     }
     selectMulti(identity, opts = {}) {
-        const node = this.get(identifyNull(identity));
+        const node = this.get(this.identifyNull(identity));
         if (!node)
             return;
         const changeFocus = opts.focus !== false;
@@ -448,11 +473,11 @@ class TreeApi {
         var _a;
         if (!identity)
             return;
-        const id = identify(identity);
+        const id = this.identify(identity);
         this.dispatch((0, focus_slice_1.focus)(id));
         if ((_a = this.get(id)) === null || _a === void 0 ? void 0 : _a.isSelectable) {
             const { anchor, mostRecent } = this.state.nodes.selection;
-            const selectableNodes = this.filterSelectableNodes(this.nodesBetween(anchor, identifyNull(id)));
+            const selectableNodes = this.filterSelectableNodes(this.nodesBetween(anchor, this.identifyNull(id)));
             this.dispatch(selection_slice_1.actions.remove(this.nodesBetween(anchor, mostRecent)));
             this.dispatch(selection_slice_1.actions.add(selectableNodes));
             this.dispatch(selection_slice_1.actions.mostRecent(id));
@@ -481,14 +506,14 @@ class TreeApi {
     }
     filterSelectableNodes(nodes) {
         return nodes
-            .map((n) => this.get(identify(n)))
+            .map((n) => this.get(this.identify(n)))
             .filter((n) => !!n && n.isSelectable);
     }
     setSelection(args) {
         var _a;
-        const ids = new Set((_a = args.ids) === null || _a === void 0 ? void 0 : _a.map(identify));
-        const anchor = identifyNull(args.anchor);
-        const mostRecent = identifyNull(args.mostRecent);
+        const ids = new Set((_a = args.ids) === null || _a === void 0 ? void 0 : _a.map((i) => this.identify(i)));
+        const anchor = this.identifyNull(args.anchor);
+        const mostRecent = this.identifyNull(args.mostRecent);
         this.dispatch(selection_slice_1.actions.set({ ids, anchor, mostRecent }));
         safeRun(this.props.onSelect, this.selectedNodes);
     }
@@ -571,7 +596,7 @@ class TreeApi {
     /* Visibility */
     open(identity, redraw = true) {
         var _a, _b;
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         if (this.isOpen(id))
@@ -583,7 +608,7 @@ class TreeApi {
     }
     close(identity, redraw = true) {
         var _a, _b;
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         if (!this.isOpen(id))
@@ -594,13 +619,13 @@ class TreeApi {
         safeRun(this.props.onToggle, id);
     }
     toggle(identity) {
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         return this.isOpen(id) ? this.close(id) : this.open(id);
     }
     openParents(identity) {
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         const node = utils.dfs(this.root, id);
@@ -648,7 +673,7 @@ class TreeApi {
     scrollTo(identity, align = "smart") {
         if (!identity)
             return;
-        const id = identify(identity);
+        const id = this.identify(identity);
         this.openParents(id);
         return utils
             .waitFor(() => id in this.idToIndex)
@@ -715,7 +740,7 @@ class TreeApi {
         return !utils.access(data, disabler);
     }
     isDragging(node) {
-        const id = identifyNull(node);
+        const id = this.identifyNull(node);
         if (!id)
             return false;
         return this.state.nodes.drag.id === id;
@@ -727,7 +752,7 @@ class TreeApi {
         return this.matchFn(node);
     }
     willReceiveDrop(node) {
-        const id = identifyNull(node);
+        const id = this.identifyNull(node);
         if (!id)
             return false;
         const { destinationParentId, destinationIndex } = this.state.nodes.drag;

package/dist/main/interfaces/tree-api.test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const redux_1 = require("redux");
 const root_reducer_1 = require("../state/root-reducer");
@@ -38,6 +47,45 @@ describe("tree.drop() fires onMove (#313)", () => {
         expect(onMove).toHaveBeenCalledWith(expect.objectContaining({ parentId: "folder", index: 0 }));
     });
 });
+describe("custom idAccessor is honored when methods receive raw data (#347)", () => {
+    const uuidData = [{ uuid: "a" }, { uuid: "b" }, { uuid: "c" }];
+    test("select(data) resolves the id through idAccessor", () => {
+        const onSelect = jest.fn();
+        const api = setupApi({ data: uuidData, idAccessor: "uuid", onSelect });
+        api.select(uuidData[1]);
+        expect(api.selectedIds.has("b")).toBe(true);
+        expect(api.selectedNodes.map((n) => n.id)).toEqual(["b"]);
+    });
+    test("focus(data) resolves the id through idAccessor", () => {
+        var _a;
+        const api = setupApi({ data: uuidData, idAccessor: "uuid" });
+        api.focus(uuidData[2]);
+        expect((_a = api.focusedNode) === null || _a === void 0 ? void 0 : _a.id).toBe("c");
+    });
+    test("delete(data) passes the accessor-derived id to onDelete", () => {
+        const onDelete = jest.fn();
+        const api = setupApi({ data: uuidData, idAccessor: "uuid", onDelete });
+        api.delete(uuidData[0]);
+        expect(onDelete).toHaveBeenCalledWith(expect.objectContaining({ ids: ["a"] }));
+    });
+    test("create() focuses the new node by its accessor-derived id", () => __awaiter(void 0, void 0, void 0, function* () {
+        // create() passes the raw row data returned by onCreate straight to
+        // focus/edit/select; before the fix these read `.id` and lost the node.
+        const onCreate = () => ({ uuid: "new" });
+        const api = setupApi({ data: uuidData, idAccessor: "uuid", onCreate });
+        yield api.create();
+        expect(api.state.nodes.focus.id).toBe("new");
+    }));
+    test("a function idAccessor is honored too", () => {
+        const fnData = [{ meta: { key: "x" } }, { meta: { key: "y" } }];
+        const api = setupApi({
+            data: fnData,
+            idAccessor: (d) => d.meta.key,
+        });
+        api.select(fnData[1]);
+        expect(api.selectedIds.has("y")).toBe(true);
+    });
+});
 test("rowHeight defaults to 24", () => {
     const api = setupApi({});
     expect(api.rowHeight).toBe(24);

package/dist/main/types/handlers.d.ts

@@ -5,7 +5,7 @@ export type CreateHandler<T> = (args: {
     parentNode: NodeApi<T> | null;
     index: number;
     type: "internal" | "leaf";
-}) => (IdObj | null) | Promise<IdObj | null>;
+}) => (T | IdObj | null) | Promise<T | IdObj | null>;
 export type MoveHandler<T> = (args: {
     dragIds: string[];
     dragNodes: NodeApi<T>[];

package/dist/module/interfaces/tree-api.d.ts

@@ -149,6 +149,19 @@ export declare class TreeApi<T> {
     get matchFn(): (node: NodeApi<T>) => boolean;
     accessChildren(data: T): readonly T[] | null;
     accessId(data: T): string;
+    /**
+     * Resolve an identifier to a node id. Public methods accept an id string, a
+     * NodeApi, or the raw row data; this is the one place that turns any of those
+     * into the string id used internally. Raw data is run through the configured
+     * `idAccessor` so a custom accessor (e.g. `uuid`) is honored everywhere, not
+     * just where nodes were built. A NodeApi already carries its accessor-derived
+     * `id`, so it is used directly rather than re-accessed (the accessor reads the
+     * underlying data, which a NodeApi does not expose under that key). Unlike
+     * `accessId`, an unresolved id comes back as `undefined` rather than throwing,
+     * preserving the previous behavior of the `id`-only lookup.
+     */
+    identify(identity: string | IdObj | T): string;
+    identifyNull(identity: Identity | T): string | null;
     get firstNode(): NodeApi<T>;
     get lastNode(): NodeApi<T>;
     get focusedNode(): NodeApi<T> | null;
@@ -158,7 +171,7 @@ export declare class TreeApi<T> {
     get(id: string | null): NodeApi<T> | null;
     at(index: number): NodeApi<T> | null;
     nodesBetween(startId: string | null, endId: string | null): NodeApi<T>[];
-    indexOf(id: Identity): number | null;
+    indexOf(id: Identity | T): number | null;
     get editingId(): string | null;
     createInternal(): Promise<void>;
     createLeaf(): Promise<void>;
@@ -167,36 +180,36 @@ export declare class TreeApi<T> {
         parentId?: null | string;
         index?: null | number;
     }): Promise<void>;
-    delete(node: Identity | string[] | IdObj[]): Promise<void>;
-    edit(node: string | IdObj): Promise<EditResult>;
-    submit(identity: Identity, value: string): Promise<void>;
+    delete(node: Identity | T | (string | IdObj | T)[]): Promise<void>;
+    edit(node: string | IdObj | T): Promise<EditResult>;
+    submit(identity: Identity | T, value: string): Promise<void>;
     reset(): void;
-    activate(id: Identity): void;
+    activate(id: Identity | T): void;
     private resolveEdit;
     get selectedIds(): Set<string>;
     get selectedNodes(): NodeApi<T>[];
-    focus(node: Identity, opts?: {
+    focus(node: Identity | T, opts?: {
         scroll?: boolean;
     }): void;
     pageUp(): void;
     pageDown(): void;
-    select(node: Identity, opts?: {
+    select(node: Identity | T, opts?: {
         align?: Align;
         focus?: boolean;
     }): void;
-    deselect(node: Identity): void;
-    selectMulti(identity: Identity, opts?: {
+    deselect(node: Identity | T): void;
+    selectMulti(identity: Identity | T, opts?: {
         align?: Align;
         focus?: boolean;
     }): void;
-    selectContiguous(identity: Identity): void;
+    selectContiguous(identity: Identity | T): void;
     deselectAll(): void;
     selectAll(): void;
     private filterSelectableNodes;
     setSelection(args: {
-        ids: (IdObj | string)[] | null;
-        anchor: Identity;
-        mostRecent: Identity;
+        ids: (IdObj | string | T)[] | null;
+        anchor: Identity | T;
+        mostRecent: Identity | T;
     }): void;
     get cursorParentId(): string | null;
     get cursorOverFolder(): boolean;
@@ -208,14 +221,14 @@ export declare class TreeApi<T> {
     drop(): void;
     hideCursor(): void;
     showCursor(cursor: Cursor): void;
-    open(identity: Identity, redraw?: boolean): void;
-    close(identity: Identity, redraw?: boolean): void;
-    toggle(identity: Identity): void;
-    openParents(identity: Identity): void;
+    open(identity: Identity | T, redraw?: boolean): void;
+    close(identity: Identity | T, redraw?: boolean): void;
+    toggle(identity: Identity | T): void;
+    openParents(identity: Identity | T): void;
     openSiblings(node: NodeApi<T>): void;
     openAll(): void;
     closeAll(): void;
-    scrollTo(identity: Identity, align?: Align): Promise<void> | undefined;
+    scrollTo(identity: Identity | T, align?: Align): Promise<void> | undefined;
     get isEditing(): boolean;
     get isFiltered(): boolean;
     get hasFocus(): boolean;
@@ -228,10 +241,10 @@ export declare class TreeApi<T> {
     isDraggable(data: T): boolean;
     isSelectable(data: T): boolean;
     private isActionPossible;
-    isDragging(node: Identity): boolean;
+    isDragging(node: Identity | T): boolean;
     isFocused(id: string): boolean;
     isMatch(node: NodeApi<T>): boolean;
-    willReceiveDrop(node: Identity): boolean;
+    willReceiveDrop(node: Identity | T): boolean;
     onFocus(): void;
     onBlur(): void;
     onItemsRendered(args: ListOnItemsRenderedProps): void;

package/dist/module/interfaces/tree-api.js

@@ -11,6 +11,7 @@ import * as utils from "../utils";
 import { DefaultCursor } from "../components/default-cursor";
 import { DefaultRow } from "../components/default-row";
 import { DefaultNode } from "../components/default-node";
+import { NodeApi } from "./node-api";
 import { edit } from "../state/edit-slice";
 import { focus, treeBlur } from "../state/focus-slice";
 import { createRoot, ROOT_ID } from "../data/create-root";
@@ -21,7 +22,7 @@ import { DefaultDragPreview } from "../components/default-drag-preview";
 import { DefaultContainer } from "../components/default-container";
 import { createList } from "../data/create-list";
 import { createIndex } from "../data/create-index";
-const { safeRun, identify, identifyNull } = utils;
+const { safeRun } = utils;
 export class TreeApi {
     constructor(store, props, list, listEl) {
         this.store = store;
@@ -163,6 +164,30 @@ export class TreeApi {
             throw new Error("Data must contain an 'id' property or props.idAccessor must return a string");
         return id;
     }
+    /**
+     * Resolve an identifier to a node id. Public methods accept an id string, a
+     * NodeApi, or the raw row data; this is the one place that turns any of those
+     * into the string id used internally. Raw data is run through the configured
+     * `idAccessor` so a custom accessor (e.g. `uuid`) is honored everywhere, not
+     * just where nodes were built. A NodeApi already carries its accessor-derived
+     * `id`, so it is used directly rather than re-accessed (the accessor reads the
+     * underlying data, which a NodeApi does not expose under that key). Unlike
+     * `accessId`, an unresolved id comes back as `undefined` rather than throwing,
+     * preserving the previous behavior of the `id`-only lookup.
+     */
+    identify(identity) {
+        if (typeof identity === "string")
+            return identity;
+        if (identity instanceof NodeApi)
+            return identity.id;
+        const get = this.props.idAccessor || "id";
+        return utils.access(identity, get);
+    }
+    identifyNull(identity) {
+        if (identity === null || identity === undefined)
+            return null;
+        return this.identify(identity);
+    }
     /* Node Access */
     get firstNode() {
         var _a;
@@ -218,7 +243,7 @@ export class TreeApi {
         return this.visibleNodes.slice(start, end + 1);
     }
     indexOf(id) {
-        const key = utils.identifyNull(id);
+        const key = this.identifyNull(id);
         if (!key)
             return null;
         return this.idToIndex[key];
@@ -261,7 +286,7 @@ export class TreeApi {
             if (!node)
                 return;
             const idents = Array.isArray(node) ? node : [node];
-            const ids = idents.map(identify);
+            const ids = idents.map((i) => this.identify(i));
             const nodes = ids.map((id) => this.get(id)).filter((n) => !!n);
             /* Guard against Math.min(...[]) === Infinity when no ids resolve to nodes. */
             const fromIndex = nodes.length ? Math.min(...nodes.map((n) => { var _a; return (_a = n.rowIndex) !== null && _a !== void 0 ? _a : 0; })) : 0;
@@ -271,7 +296,7 @@ export class TreeApi {
     }
     edit(node) {
         var _a, _b;
-        const id = identify(node);
+        const id = this.identify(node);
         this.resolveEdit({ cancelled: true });
         this.scrollTo(id);
         this.dispatch(edit(id));
@@ -285,7 +310,7 @@ export class TreeApi {
             var _a, _b;
             if (!identity)
                 return;
-            const id = identify(identity);
+            const id = this.identify(identity);
             yield safeRun(this.props.onRename, {
                 id,
                 name: value,
@@ -304,7 +329,7 @@ export class TreeApi {
         setTimeout(() => this.onFocus()); // Return focus to element;
     }
     activate(id) {
-        const node = this.get(identifyNull(id));
+        const node = this.get(this.identifyNull(id));
         if (!node)
             return;
         safeRun(this.props.onActivate, node);
@@ -338,7 +363,7 @@ export class TreeApi {
             this.select(node);
         }
         else {
-            this.dispatch(focus(identify(node)));
+            this.dispatch(focus(this.identify(node)));
             if (opts.scroll !== false)
                 this.scrollTo(node);
             if (this.focusedNode)
@@ -378,7 +403,7 @@ export class TreeApi {
         if (!node)
             return;
         const changeFocus = opts.focus !== false;
-        const id = identify(node);
+        const id = this.identify(node);
         if (changeFocus)
             this.dispatch(focus(id));
         if ((_a = this.get(id)) === null || _a === void 0 ? void 0 : _a.isSelectable) {
@@ -396,12 +421,12 @@ export class TreeApi {
     deselect(node) {
         if (!node)
             return;
-        const id = identify(node);
+        const id = this.identify(node);
         this.dispatch(selection.remove(id));
         safeRun(this.props.onSelect, this.selectedNodes);
     }
     selectMulti(identity, opts = {}) {
-        const node = this.get(identifyNull(identity));
+        const node = this.get(this.identifyNull(identity));
         if (!node)
             return;
         const changeFocus = opts.focus !== false;
@@ -422,11 +447,11 @@ export class TreeApi {
         var _a;
         if (!identity)
             return;
-        const id = identify(identity);
+        const id = this.identify(identity);
         this.dispatch(focus(id));
         if ((_a = this.get(id)) === null || _a === void 0 ? void 0 : _a.isSelectable) {
             const { anchor, mostRecent } = this.state.nodes.selection;
-            const selectableNodes = this.filterSelectableNodes(this.nodesBetween(anchor, identifyNull(id)));
+            const selectableNodes = this.filterSelectableNodes(this.nodesBetween(anchor, this.identifyNull(id)));
             this.dispatch(selection.remove(this.nodesBetween(anchor, mostRecent)));
             this.dispatch(selection.add(selectableNodes));
             this.dispatch(selection.mostRecent(id));
@@ -455,14 +480,14 @@ export class TreeApi {
     }
     filterSelectableNodes(nodes) {
         return nodes
-            .map((n) => this.get(identify(n)))
+            .map((n) => this.get(this.identify(n)))
             .filter((n) => !!n && n.isSelectable);
     }
     setSelection(args) {
         var _a;
-        const ids = new Set((_a = args.ids) === null || _a === void 0 ? void 0 : _a.map(identify));
-        const anchor = identifyNull(args.anchor);
-        const mostRecent = identifyNull(args.mostRecent);
+        const ids = new Set((_a = args.ids) === null || _a === void 0 ? void 0 : _a.map((i) => this.identify(i)));
+        const anchor = this.identifyNull(args.anchor);
+        const mostRecent = this.identifyNull(args.mostRecent);
         this.dispatch(selection.set({ ids, anchor, mostRecent }));
         safeRun(this.props.onSelect, this.selectedNodes);
     }
@@ -545,7 +570,7 @@ export class TreeApi {
     /* Visibility */
     open(identity, redraw = true) {
         var _a, _b;
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         if (this.isOpen(id))
@@ -557,7 +582,7 @@ export class TreeApi {
     }
     close(identity, redraw = true) {
         var _a, _b;
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         if (!this.isOpen(id))
@@ -568,13 +593,13 @@ export class TreeApi {
         safeRun(this.props.onToggle, id);
     }
     toggle(identity) {
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         return this.isOpen(id) ? this.close(id) : this.open(id);
     }
     openParents(identity) {
-        const id = identifyNull(identity);
+        const id = this.identifyNull(identity);
         if (!id)
             return;
         const node = utils.dfs(this.root, id);
@@ -622,7 +647,7 @@ export class TreeApi {
     scrollTo(identity, align = "smart") {
         if (!identity)
             return;
-        const id = identify(identity);
+        const id = this.identify(identity);
         this.openParents(id);
         return utils
             .waitFor(() => id in this.idToIndex)
@@ -689,7 +714,7 @@ export class TreeApi {
         return !utils.access(data, disabler);
     }
     isDragging(node) {
-        const id = identifyNull(node);
+        const id = this.identifyNull(node);
         if (!id)
             return false;
         return this.state.nodes.drag.id === id;
@@ -701,7 +726,7 @@ export class TreeApi {
         return this.matchFn(node);
     }
     willReceiveDrop(node) {
-        const id = identifyNull(node);
+        const id = this.identifyNull(node);
         if (!id)
             return false;
         const { destinationParentId, destinationIndex } = this.state.nodes.drag;

package/dist/module/interfaces/tree-api.test.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { createStore } from "redux";
 import { rootReducer } from "../state/root-reducer";
 import { actions as dnd } from "../state/dnd-slice";
@@ -36,6 +45,45 @@ describe("tree.drop() fires onMove (#313)", () => {
         expect(onMove).toHaveBeenCalledWith(expect.objectContaining({ parentId: "folder", index: 0 }));
     });
 });
+describe("custom idAccessor is honored when methods receive raw data (#347)", () => {
+    const uuidData = [{ uuid: "a" }, { uuid: "b" }, { uuid: "c" }];
+    test("select(data) resolves the id through idAccessor", () => {
+        const onSelect = jest.fn();
+        const api = setupApi({ data: uuidData, idAccessor: "uuid", onSelect });
+        api.select(uuidData[1]);
+        expect(api.selectedIds.has("b")).toBe(true);
+        expect(api.selectedNodes.map((n) => n.id)).toEqual(["b"]);
+    });
+    test("focus(data) resolves the id through idAccessor", () => {
+        var _a;
+        const api = setupApi({ data: uuidData, idAccessor: "uuid" });
+        api.focus(uuidData[2]);
+        expect((_a = api.focusedNode) === null || _a === void 0 ? void 0 : _a.id).toBe("c");
+    });
+    test("delete(data) passes the accessor-derived id to onDelete", () => {
+        const onDelete = jest.fn();
+        const api = setupApi({ data: uuidData, idAccessor: "uuid", onDelete });
+        api.delete(uuidData[0]);
+        expect(onDelete).toHaveBeenCalledWith(expect.objectContaining({ ids: ["a"] }));
+    });
+    test("create() focuses the new node by its accessor-derived id", () => __awaiter(void 0, void 0, void 0, function* () {
+        // create() passes the raw row data returned by onCreate straight to
+        // focus/edit/select; before the fix these read `.id` and lost the node.
+        const onCreate = () => ({ uuid: "new" });
+        const api = setupApi({ data: uuidData, idAccessor: "uuid", onCreate });
+        yield api.create();
+        expect(api.state.nodes.focus.id).toBe("new");
+    }));
+    test("a function idAccessor is honored too", () => {
+        const fnData = [{ meta: { key: "x" } }, { meta: { key: "y" } }];
+        const api = setupApi({
+            data: fnData,
+            idAccessor: (d) => d.meta.key,
+        });
+        api.select(fnData[1]);
+        expect(api.selectedIds.has("y")).toBe(true);
+    });
+});
 test("rowHeight defaults to 24", () => {
     const api = setupApi({});
     expect(api.rowHeight).toBe(24);

package/dist/module/types/handlers.d.ts

@@ -5,7 +5,7 @@ export type CreateHandler<T> = (args: {
     parentNode: NodeApi<T> | null;
     index: number;
     type: "internal" | "leaf";
-}) => (IdObj | null) | Promise<IdObj | null>;
+}) => (T | IdObj | null) | Promise<T | IdObj | null>;
 export type MoveHandler<T> = (args: {
     dragIds: string[];
     dragNodes: NodeApi<T>[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-arborist",
-  "version": "3.10.4",
+  "version": "3.10.5",
   "keywords": [
     "arborist",
     "dnd",

package/src/interfaces/tree-api.test.ts

@@ -47,6 +47,52 @@ describe("tree.drop() fires onMove (#313)", () => {
   });
 });
 
+describe("custom idAccessor is honored when methods receive raw data (#347)", () => {
+  const uuidData = [{ uuid: "a" }, { uuid: "b" }, { uuid: "c" }];
+
+  test("select(data) resolves the id through idAccessor", () => {
+    const onSelect = jest.fn();
+    const api = setupApi({ data: uuidData, idAccessor: "uuid", onSelect });
+    api.select(uuidData[1]);
+    expect(api.selectedIds.has("b")).toBe(true);
+    expect(api.selectedNodes.map((n) => n.id)).toEqual(["b"]);
+  });
+
+  test("focus(data) resolves the id through idAccessor", () => {
+    const api = setupApi({ data: uuidData, idAccessor: "uuid" });
+    api.focus(uuidData[2]);
+    expect(api.focusedNode?.id).toBe("c");
+  });
+
+  test("delete(data) passes the accessor-derived id to onDelete", () => {
+    const onDelete = jest.fn();
+    const api = setupApi({ data: uuidData, idAccessor: "uuid", onDelete });
+    api.delete(uuidData[0]);
+    expect(onDelete).toHaveBeenCalledWith(
+      expect.objectContaining({ ids: ["a"] }),
+    );
+  });
+
+  test("create() focuses the new node by its accessor-derived id", async () => {
+    // create() passes the raw row data returned by onCreate straight to
+    // focus/edit/select; before the fix these read `.id` and lost the node.
+    const onCreate = () => ({ uuid: "new" });
+    const api = setupApi({ data: uuidData, idAccessor: "uuid", onCreate });
+    await api.create();
+    expect(api.state.nodes.focus.id).toBe("new");
+  });
+
+  test("a function idAccessor is honored too", () => {
+    const fnData = [{ meta: { key: "x" } }, { meta: { key: "y" } }];
+    const api = setupApi({
+      data: fnData,
+      idAccessor: (d: any) => d.meta.key,
+    });
+    api.select(fnData[1]);
+    expect(api.selectedIds.has("y")).toBe(true);
+  });
+});
+
 test("rowHeight defaults to 24", () => {
   const api = setupApi({});
   expect(api.rowHeight).toBe(24);

package/src/interfaces/tree-api.ts

@@ -22,7 +22,7 @@ import { Store } from "redux";
 import { createList } from "../data/create-list";
 import { createIndex } from "../data/create-index";
 
-const { safeRun, identify, identifyNull } = utils;
+const { safeRun } = utils;
 export class TreeApi<T> {
   static editPromise: null | ((args: EditResult) => void);
   root: NodeApi<T>;
@@ -187,6 +187,29 @@ export class TreeApi<T> {
     return id;
   }
 
+  /**
+   * Resolve an identifier to a node id. Public methods accept an id string, a
+   * NodeApi, or the raw row data; this is the one place that turns any of those
+   * into the string id used internally. Raw data is run through the configured
+   * `idAccessor` so a custom accessor (e.g. `uuid`) is honored everywhere, not
+   * just where nodes were built. A NodeApi already carries its accessor-derived
+   * `id`, so it is used directly rather than re-accessed (the accessor reads the
+   * underlying data, which a NodeApi does not expose under that key). Unlike
+   * `accessId`, an unresolved id comes back as `undefined` rather than throwing,
+   * preserving the previous behavior of the `id`-only lookup.
+   */
+  identify(identity: string | IdObj | T): string {
+    if (typeof identity === "string") return identity;
+    if (identity instanceof NodeApi) return identity.id;
+    const get = this.props.idAccessor || "id";
+    return utils.access<string>(identity, get);
+  }
+
+  identifyNull(identity: Identity | T): string | null {
+    if (identity === null || identity === undefined) return null;
+    return this.identify(identity);
+  }
+
   /* Node Access */
 
   get firstNode() {
@@ -237,8 +260,8 @@ export class TreeApi<T> {
     return this.visibleNodes.slice(start, end + 1);
   }
 
-  indexOf(id: Identity) {
-    const key = utils.identifyNull(id);
+  indexOf(id: Identity | T) {
+    const key = this.identifyNull(id);
     if (!key) return null;
     return this.idToIndex[key];
   }
@@ -284,10 +307,10 @@ export class TreeApi<T> {
     }
   }
 
-  async delete(node: Identity | string[] | IdObj[]) {
+  async delete(node: Identity | T | (string | IdObj | T)[]) {
     if (!node) return;
     const idents = Array.isArray(node) ? node : [node];
-    const ids = idents.map(identify);
+    const ids = idents.map((i) => this.identify(i));
     const nodes = ids.map((id) => this.get(id)!).filter((n) => !!n);
     /* Guard against Math.min(...[]) === Infinity when no ids resolve to nodes. */
     const fromIndex = nodes.length ? Math.min(...nodes.map((n) => n.rowIndex ?? 0)) : 0;
@@ -295,8 +318,8 @@ export class TreeApi<T> {
     this.redrawList(fromIndex);
   }
 
-  edit(node: string | IdObj): Promise<EditResult> {
-    const id = identify(node);
+  edit(node: string | IdObj | T): Promise<EditResult> {
+    const id = this.identify(node);
     this.resolveEdit({ cancelled: true });
     this.scrollTo(id);
     this.dispatch(edit(id));
@@ -306,9 +329,9 @@ export class TreeApi<T> {
     });
   }
 
-  async submit(identity: Identity, value: string) {
+  async submit(identity: Identity | T, value: string) {
     if (!identity) return;
-    const id = identify(identity);
+    const id = this.identify(identity);
     await safeRun(this.props.onRename, {
       id,
       name: value,
@@ -327,8 +350,8 @@ export class TreeApi<T> {
     setTimeout(() => this.onFocus()); // Return focus to element;
   }
 
-  activate(id: Identity) {
-    const node = this.get(identifyNull(id));
+  activate(id: Identity | T) {
+    const node = this.get(this.identifyNull(id));
     if (!node) return;
     safeRun(this.props.onActivate, node);
   }
@@ -354,7 +377,7 @@ export class TreeApi<T> {
     return nodes;
   }
 
-  focus(node: Identity, opts: { scroll?: boolean } = {}) {
+  focus(node: Identity | T, opts: { scroll?: boolean } = {}) {
     if (!node) return;
     /* Focus is responsible for scrolling, while selection is
      * responsible for focus. If selectionFollowsFocus, then
@@ -362,7 +385,7 @@ export class TreeApi<T> {
     if (this.props.selectionFollowsFocus) {
       this.select(node);
     } else {
-      this.dispatch(focus(identify(node)));
+      this.dispatch(focus(this.identify(node)));
       if (opts.scroll !== false) this.scrollTo(node);
       if (this.focusedNode) safeRun(this.props.onFocus, this.focusedNode);
     }
@@ -394,10 +417,10 @@ export class TreeApi<T> {
     this.focus(this.at(index));
   }
 
-  select(node: Identity, opts: { align?: Align; focus?: boolean } = {}) {
+  select(node: Identity | T, opts: { align?: Align; focus?: boolean } = {}) {
     if (!node) return;
     const changeFocus = opts.focus !== false;
-    const id = identify(node);
+    const id = this.identify(node);
     if (changeFocus) this.dispatch(focus(id));
     if (this.get(id)?.isSelectable) {
       this.setSelection({
@@ -412,15 +435,15 @@ export class TreeApi<T> {
     }
   }
 
-  deselect(node: Identity) {
+  deselect(node: Identity | T) {
     if (!node) return;
-    const id = identify(node);
+    const id = this.identify(node);
     this.dispatch(selection.remove(id));
     safeRun(this.props.onSelect, this.selectedNodes);
   }
 
-  selectMulti(identity: Identity, opts: { align?: Align; focus?: boolean } = {}) {
-    const node = this.get(identifyNull(identity));
+  selectMulti(identity: Identity | T, opts: { align?: Align; focus?: boolean } = {}) {
+    const node = this.get(this.identifyNull(identity));
     if (!node) return;
     const changeFocus = opts.focus !== false;
     if (changeFocus) this.dispatch(focus(node.id));
@@ -436,14 +459,14 @@ export class TreeApi<T> {
     safeRun(this.props.onSelect, this.selectedNodes);
   }
 
-  selectContiguous(identity: Identity) {
+  selectContiguous(identity: Identity | T) {
     if (!identity) return;
-    const id = identify(identity);
+    const id = this.identify(identity);
     this.dispatch(focus(id));
     if (this.get(id)?.isSelectable) {
       const { anchor, mostRecent } = this.state.nodes.selection;
       const selectableNodes = this.filterSelectableNodes(
-        this.nodesBetween(anchor, identifyNull(id)),
+        this.nodesBetween(anchor, this.identifyNull(id)),
       );
       this.dispatch(selection.remove(this.nodesBetween(anchor, mostRecent)));
       this.dispatch(selection.add(selectableNodes));
@@ -473,14 +496,18 @@ export class TreeApi<T> {
 
   private filterSelectableNodes(nodes: (IdObj | string)[]) {
     return nodes
-      .map((n) => this.get(identify(n)))
+      .map((n) => this.get(this.identify(n)))
       .filter((n): n is NodeApi<T> => !!n && n.isSelectable);
   }
 
-  setSelection(args: { ids: (IdObj | string)[] | null; anchor: Identity; mostRecent: Identity }) {
-    const ids = new Set(args.ids?.map(identify));
-    const anchor = identifyNull(args.anchor);
-    const mostRecent = identifyNull(args.mostRecent);
+  setSelection(args: {
+    ids: (IdObj | string | T)[] | null;
+    anchor: Identity | T;
+    mostRecent: Identity | T;
+  }) {
+    const ids = new Set(args.ids?.map((i) => this.identify(i)));
+    const anchor = this.identifyNull(args.anchor);
+    const mostRecent = this.identifyNull(args.mostRecent);
     this.dispatch(selection.set({ ids, anchor, mostRecent }));
     safeRun(this.props.onSelect, this.selectedNodes);
   }
@@ -568,8 +595,8 @@ export class TreeApi<T> {
 
   /* Visibility */
 
-  open(identity: Identity, redraw: boolean = true) {
-    const id = identifyNull(identity);
+  open(identity: Identity | T, redraw: boolean = true) {
+    const id = this.identifyNull(identity);
     if (!id) return;
     if (this.isOpen(id)) return;
     this.dispatch(visibility.open(id, this.isFiltered));
@@ -577,8 +604,8 @@ export class TreeApi<T> {
     safeRun(this.props.onToggle, id);
   }
 
-  close(identity: Identity, redraw: boolean = true) {
-    const id = identifyNull(identity);
+  close(identity: Identity | T, redraw: boolean = true) {
+    const id = this.identifyNull(identity);
     if (!id) return;
     if (!this.isOpen(id)) return;
     this.dispatch(visibility.close(id, this.isFiltered));
@@ -586,14 +613,14 @@ export class TreeApi<T> {
     safeRun(this.props.onToggle, id);
   }
 
-  toggle(identity: Identity) {
-    const id = identifyNull(identity);
+  toggle(identity: Identity | T) {
+    const id = this.identifyNull(identity);
     if (!id) return;
     return this.isOpen(id) ? this.close(id) : this.open(id);
   }
 
-  openParents(identity: Identity) {
-    const id = identifyNull(identity);
+  openParents(identity: Identity | T) {
+    const id = this.identifyNull(identity);
     if (!id) return;
     const node = utils.dfs(this.root, id);
     let parent = node?.parent;
@@ -638,9 +665,9 @@ export class TreeApi<T> {
 
   /* Scrolling */
 
-  scrollTo(identity: Identity, align: Align = "smart") {
+  scrollTo(identity: Identity | T, align: Align = "smart") {
     if (!identity) return;
-    const id = identify(identity);
+    const id = this.identify(identity);
     this.openParents(id);
     return utils
       .waitFor(() => id in this.idToIndex)
@@ -712,8 +739,8 @@ export class TreeApi<T> {
     return !utils.access(data, disabler);
   }
 
-  isDragging(node: Identity) {
-    const id = identifyNull(node);
+  isDragging(node: Identity | T) {
+    const id = this.identifyNull(node);
     if (!id) return false;
     return this.state.nodes.drag.id === id;
   }
@@ -726,8 +753,8 @@ export class TreeApi<T> {
     return this.matchFn(node);
   }
 
-  willReceiveDrop(node: Identity) {
-    const id = identifyNull(node);
+  willReceiveDrop(node: Identity | T) {
+    const id = this.identifyNull(node);
     if (!id) return false;
     const { destinationParentId, destinationIndex } = this.state.nodes.drag;
     return id === destinationParentId && destinationIndex === null;

package/src/types/handlers.ts

@@ -1,12 +1,14 @@
 import { NodeApi } from "../interfaces/node-api";
 import { IdObj } from "./utils";
 
+// Returns the newly created row data, whose id is read via idAccessor. `IdObj`
+// is kept for back-compat with handlers that return a bare `{ id }` (#347).
 export type CreateHandler<T> = (args: {
   parentId: string | null;
   parentNode: NodeApi<T> | null;
   index: number;
   type: "internal" | "leaf";
-}) => (IdObj | null) | Promise<IdObj | null>;
+}) => (T | IdObj | null) | Promise<T | IdObj | null>;
 
 export type MoveHandler<T> = (args: {
   dragIds: string[];