react-arborist 3.2.0 → 3.3.1-0

package/dist/main/state/dnd-slice.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = exports.actions = void 0;
+const initial_1 = require("./initial");
+/* Actions */
+exports.actions = {
+    cursor(cursor) {
+        return { type: "DND_CURSOR", cursor };
+    },
+    dragStart(id, dragIds) {
+        return { type: "DND_DRAG_START", id, dragIds };
+    },
+    dragEnd() {
+        return { type: "DND_DRAG_END" };
+    },
+    hovering(parentId, index) {
+        return { type: "DND_HOVERING", parentId, index };
+    },
+};
+/* Reducer */
+function reducer(state = (0, initial_1.initialState)()["dnd"], action) {
+    switch (action.type) {
+        case "DND_CURSOR":
+            return Object.assign(Object.assign({}, state), { cursor: action.cursor });
+        case "DND_DRAG_START":
+            return Object.assign(Object.assign({}, state), { dragId: action.id, dragIds: action.dragIds });
+        case "DND_DRAG_END":
+            return (0, initial_1.initialState)()["dnd"];
+        case "DND_HOVERING":
+            return Object.assign(Object.assign({}, state), { parentId: action.parentId, index: action.index });
+        default:
+            return state;
+    }
+}
+exports.reducer = reducer;

package/dist/{state → main/state}/drag-slice.d.ts

@@ -1,7 +1,9 @@
 import { ActionTypes } from "../types/utils";
 import { actions as dnd } from "./dnd-slice";
-export declare type DragSlice = {
+export type DragSlice = {
     id: string | null;
-    idWillReceiveDrop: string | null;
+    selectedIds: string[];
+    destinationParentId: string | null;
+    destinationIndex: number | null;
 };
 export declare function reducer(state: DragSlice | undefined, action: ActionTypes<typeof dnd>): DragSlice;

package/dist/main/state/drag-slice.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = void 0;
+const initial_1 = require("./initial");
+/* Reducer */
+function reducer(state = (0, initial_1.initialState)().nodes.drag, action) {
+    switch (action.type) {
+        case "DND_DRAG_START":
+            return Object.assign(Object.assign({}, state), { id: action.id, selectedIds: action.dragIds });
+        case "DND_DRAG_END":
+            return Object.assign(Object.assign({}, state), { id: null, destinationParentId: null, destinationIndex: null, selectedIds: [] });
+        case "DND_HOVERING":
+            if (action.parentId !== state.destinationParentId ||
+                action.index != state.destinationIndex) {
+                return Object.assign(Object.assign({}, state), { destinationParentId: action.parentId, destinationIndex: action.index });
+            }
+            else {
+                return state;
+            }
+        default:
+            return state;
+    }
+}
+exports.reducer = reducer;

package/dist/{state → main/state}/edit-slice.d.ts

@@ -1,4 +1,4 @@
-export declare type EditState = {
+export type EditState = {
     id: string | null;
 };
 export declare function edit(id: string | null): {

package/dist/main/state/edit-slice.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = exports.edit = void 0;
+/* Actions */
+function edit(id) {
+    return { type: "EDIT", id };
+}
+exports.edit = edit;
+/* Reducer */
+function reducer(state = { id: null }, action) {
+    if (action.type === "EDIT") {
+        return Object.assign(Object.assign({}, state), { id: action.id });
+    }
+    else {
+        return state;
+    }
+}
+exports.reducer = reducer;

package/dist/{state → main/state}/focus-slice.d.ts

@@ -1,4 +1,4 @@
-export declare type FocusState = {
+export type FocusState = {
     id: string | null;
     treeFocused: boolean;
 };

package/dist/main/state/focus-slice.js

@@ -0,0 +1,26 @@
+"use strict";
+/* Types */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = exports.treeBlur = exports.focus = void 0;
+/* Actions */
+function focus(id) {
+    return { type: "FOCUS", id };
+}
+exports.focus = focus;
+function treeBlur() {
+    return { type: "TREE_BLUR" };
+}
+exports.treeBlur = treeBlur;
+/* Reducer */
+function reducer(state = { id: null, treeFocused: false }, action) {
+    if (action.type === "FOCUS") {
+        return Object.assign(Object.assign({}, state), { id: action.id, treeFocused: true });
+    }
+    else if (action.type === "TREE_BLUR") {
+        return Object.assign(Object.assign({}, state), { treeFocused: false });
+    }
+    else {
+        return state;
+    }
+}
+exports.reducer = reducer;

package/dist/main/state/initial.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialState = void 0;
+const initialState = (props) => {
+    var _a;
+    return ({
+        nodes: {
+            // Changes together
+            open: { filtered: {}, unfiltered: (_a = props === null || props === void 0 ? void 0 : props.initialOpenState) !== null && _a !== void 0 ? _a : {} },
+            focus: { id: null, treeFocused: false },
+            edit: { id: null },
+            drag: {
+                id: null,
+                selectedIds: [],
+                destinationParentId: null,
+                destinationIndex: null,
+            },
+            selection: { ids: new Set(), anchor: null, mostRecent: null },
+        },
+        dnd: {
+            cursor: { type: "none" },
+            dragId: null,
+            dragIds: [],
+            parentId: null,
+            index: -1,
+        },
+    });
+};
+exports.initialState = initialState;

package/dist/{state → main/state}/open-slice.d.ts

@@ -1,8 +1,8 @@
 import { ActionTypes } from "../types/utils";
-export declare type OpenMap = {
+export type OpenMap = {
     [id: string]: boolean;
 };
-export declare type OpenSlice = {
+export type OpenSlice = {
     unfiltered: OpenMap;
     filtered: OpenMap;
 };

package/dist/main/state/open-slice.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = exports.actions = void 0;
+/* Actions */
+exports.actions = {
+    open(id, filtered) {
+        return { type: "VISIBILITY_OPEN", id, filtered };
+    },
+    close(id, filtered) {
+        return { type: "VISIBILITY_CLOSE", id, filtered };
+    },
+    toggle(id, filtered) {
+        return { type: "VISIBILITY_TOGGLE", id, filtered };
+    },
+    clear(filtered) {
+        return { type: "VISIBILITY_CLEAR", filtered };
+    },
+};
+/* Reducer */
+function openMapReducer(state = {}, action) {
+    if (action.type === "VISIBILITY_OPEN") {
+        return Object.assign(Object.assign({}, state), { [action.id]: true });
+    }
+    else if (action.type === "VISIBILITY_CLOSE") {
+        return Object.assign(Object.assign({}, state), { [action.id]: false });
+    }
+    else if (action.type === "VISIBILITY_TOGGLE") {
+        const prev = state[action.id];
+        return Object.assign(Object.assign({}, state), { [action.id]: !prev });
+    }
+    else if (action.type === "VISIBILITY_CLEAR") {
+        return {};
+    }
+    else {
+        return state;
+    }
+}
+function reducer(state = { filtered: {}, unfiltered: {} }, action) {
+    if (!action.type.startsWith("VISIBILITY"))
+        return state;
+    if (action.filtered) {
+        return Object.assign(Object.assign({}, state), { filtered: openMapReducer(state.filtered, action) });
+    }
+    else {
+        return Object.assign(Object.assign({}, state), { unfiltered: openMapReducer(state.unfiltered, action) });
+    }
+}
+exports.reducer = reducer;

package/dist/main/state/root-reducer.d.ts

@@ -0,0 +1,96 @@
+import { ActionFromReducer } from "redux";
+export declare const rootReducer: import("redux").Reducer<{
+    nodes: {
+        focus: import("./focus-slice").FocusState;
+        edit: import("./edit-slice").EditState;
+        open: import("./open-slice").OpenSlice;
+        selection: import("./selection-slice").SelectionState;
+        drag: import("./drag-slice").DragSlice;
+    };
+    dnd: import("./dnd-slice").DndState;
+}, {
+    type: "FOCUS";
+    id: string | null;
+} | {
+    readonly type: "TREE_BLUR";
+} | {
+    type: "EDIT";
+    id: string | null;
+} | import("../types/utils").ActionTypes<{
+    open(id: string, filtered: boolean): {
+        type: "VISIBILITY_OPEN";
+        id: string;
+        filtered: boolean;
+    };
+    close(id: string, filtered: boolean): {
+        type: "VISIBILITY_CLOSE";
+        id: string;
+        filtered: boolean;
+    };
+    toggle(id: string, filtered: boolean): {
+        type: "VISIBILITY_TOGGLE";
+        id: string;
+        filtered: boolean;
+    };
+    clear(filtered: boolean): {
+        type: "VISIBILITY_CLEAR";
+        filtered: boolean;
+    };
+}> | import("../types/utils").ActionTypes<{
+    clear: () => {
+        type: "SELECTION_CLEAR";
+    };
+    only: (id: string | import("../types/utils").IdObj) => {
+        type: "SELECTION_ONLY";
+        id: string;
+    };
+    add: (id: string | import("../types/utils").IdObj | string[] | import("../types/utils").IdObj[]) => {
+        type: "SELECTION_ADD";
+        ids: string[];
+    };
+    remove: (id: string | import("../types/utils").IdObj | string[] | import("../types/utils").IdObj[]) => {
+        type: "SELECTION_REMOVE";
+        ids: string[];
+    };
+    set: (args: {
+        ids: Set<string>;
+        anchor: string | null;
+        mostRecent: string | null;
+    }) => {
+        ids: Set<string>;
+        anchor: string | null;
+        mostRecent: string | null;
+        type: "SELECTION_SET";
+    };
+    mostRecent: (id: string | import("../types/utils").IdObj | null) => {
+        type: "SELECTION_MOST_RECENT";
+        id: string | null;
+    };
+    anchor: (id: string | import("../types/utils").IdObj | null) => {
+        type: "SELECTION_ANCHOR";
+        id: string | null;
+    };
+}> | import("../types/utils").ActionTypes<{
+    cursor(cursor: import("../dnd/compute-drop").Cursor): {
+        type: "DND_CURSOR";
+        cursor: import("../dnd/compute-drop").Cursor;
+    };
+    dragStart(id: string, dragIds: string[]): {
+        type: "DND_DRAG_START";
+        id: string;
+        dragIds: string[];
+    };
+    dragEnd(): {
+        type: "DND_DRAG_END";
+    };
+    hovering(parentId: string | null, index: number | null): {
+        type: "DND_HOVERING";
+        parentId: string | null;
+        index: number | null;
+    };
+}>, Partial<{
+    nodes: never;
+    dnd: never;
+}>>;
+export type RootState = ReturnType<typeof rootReducer>;
+export type Actions = ActionFromReducer<typeof rootReducer>;

package/dist/main/state/root-reducer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootReducer = void 0;
+const redux_1 = require("redux");
+const focus_slice_1 = require("./focus-slice");
+const edit_slice_1 = require("./edit-slice");
+const dnd_slice_1 = require("./dnd-slice");
+const selection_slice_1 = require("./selection-slice");
+const open_slice_1 = require("./open-slice");
+const drag_slice_1 = require("./drag-slice");
+exports.rootReducer = (0, redux_1.combineReducers)({
+    nodes: (0, redux_1.combineReducers)({
+        focus: focus_slice_1.reducer,
+        edit: edit_slice_1.reducer,
+        open: open_slice_1.reducer,
+        selection: selection_slice_1.reducer,
+        drag: drag_slice_1.reducer,
+    }),
+    dnd: dnd_slice_1.reducer,
+});

package/dist/{state → main/state}/selection-slice.d.ts

@@ -1,5 +1,5 @@
 import { ActionTypes, IdObj } from "../types/utils";
-export declare type SelectionState = {
+export type SelectionState = {
     ids: Set<string>;
     anchor: string | null;
     mostRecent: string | null;

package/dist/main/state/selection-slice.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = exports.actions = void 0;
+const utils_1 = require("../utils");
+const initial_1 = require("./initial");
+/* Actions */
+exports.actions = {
+    clear: () => ({ type: "SELECTION_CLEAR" }),
+    only: (id) => ({
+        type: "SELECTION_ONLY",
+        id: (0, utils_1.identify)(id),
+    }),
+    add: (id) => ({
+        type: "SELECTION_ADD",
+        ids: (Array.isArray(id) ? id : [id]).map(utils_1.identify),
+    }),
+    remove: (id) => ({
+        type: "SELECTION_REMOVE",
+        ids: (Array.isArray(id) ? id : [id]).map(utils_1.identify),
+    }),
+    set: (args) => (Object.assign({ type: "SELECTION_SET" }, args)),
+    mostRecent: (id) => ({
+        type: "SELECTION_MOST_RECENT",
+        id: id === null ? null : (0, utils_1.identify)(id),
+    }),
+    anchor: (id) => ({
+        type: "SELECTION_ANCHOR",
+        id: id === null ? null : (0, utils_1.identify)(id),
+    }),
+};
+/* Reducer */
+function reducer(state = (0, initial_1.initialState)()["nodes"]["selection"], action) {
+    const ids = state.ids;
+    switch (action.type) {
+        case "SELECTION_CLEAR":
+            return Object.assign(Object.assign({}, state), { ids: new Set() });
+        case "SELECTION_ONLY":
+            return Object.assign(Object.assign({}, state), { ids: new Set([action.id]) });
+        case "SELECTION_ADD":
+            if (action.ids.length === 0)
+                return state;
+            action.ids.forEach((id) => ids.add(id));
+            return Object.assign(Object.assign({}, state), { ids: new Set(ids) });
+        case "SELECTION_REMOVE":
+            if (action.ids.length === 0)
+                return state;
+            action.ids.forEach((id) => ids.delete(id));
+            return Object.assign(Object.assign({}, state), { ids: new Set(ids) });
+        case "SELECTION_SET":
+            return Object.assign(Object.assign({}, state), { ids: action.ids, mostRecent: action.mostRecent, anchor: action.anchor });
+        case "SELECTION_MOST_RECENT":
+            return Object.assign(Object.assign({}, state), { mostRecent: action.id });
+        case "SELECTION_ANCHOR":
+            return Object.assign(Object.assign({}, state), { anchor: action.id });
+        default:
+            return state;
+    }
+}
+exports.reducer = reducer;

package/dist/{types → main/types}/dnd.d.ts

@@ -1,8 +1,8 @@
-export declare type CursorLocation = {
+export type CursorLocation = {
     index: number | null;
     level: number | null;
     parentId: string | null;
 };
-export declare type DragItem = {
+export type DragItem = {
     id: string;
 };

package/dist/main/types/dnd.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{types → main/types}/handlers.d.ts

@@ -1,28 +1,28 @@
 import { NodeApi } from "../interfaces/node-api";
 import { IdObj } from "./utils";
-export declare type CreateHandler<T> = (args: {
+export type CreateHandler<T> = (args: {
     parentId: string | null;
     parentNode: NodeApi<T> | null;
     index: number;
     type: "internal" | "leaf";
 }) => (IdObj | null) | Promise<IdObj | null>;
-export declare type MoveHandler<T> = (args: {
+export type MoveHandler<T> = (args: {
     dragIds: string[];
     dragNodes: NodeApi<T>[];
     parentId: string | null;
     parentNode: NodeApi<T> | null;
     index: number;
 }) => void | Promise<void>;
-export declare type RenameHandler<T> = (args: {
+export type RenameHandler<T> = (args: {
     id: string;
     name: string;
     node: NodeApi<T>;
 }) => void | Promise<void>;
-export declare type DeleteHandler<T> = (args: {
+export type DeleteHandler<T> = (args: {
     ids: string[];
     nodes: NodeApi<T>[];
 }) => void | Promise<void>;
-export declare type EditResult = {
+export type EditResult = {
     cancelled: true;
 } | {
     cancelled: false;

package/dist/main/types/handlers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{types → main/types}/renderers.d.ts

@@ -2,27 +2,27 @@ import { CSSProperties, HTMLAttributes, ReactElement } from "react";
 import { NodeApi } from "../interfaces/node-api";
 import { TreeApi } from "../interfaces/tree-api";
 import { XYCoord } from "react-dnd";
-export declare type NodeRendererProps<T> = {
+export type NodeRendererProps<T> = {
     style: CSSProperties;
     node: NodeApi<T>;
     tree: TreeApi<T>;
     dragHandle?: (el: HTMLDivElement | null) => void;
     preview?: boolean;
 };
-export declare type RowRendererProps<T> = {
+export type RowRendererProps<T> = {
     node: NodeApi<T>;
     innerRef: (el: HTMLDivElement | null) => void;
     attrs: HTMLAttributes<any>;
     children: ReactElement;
 };
-export declare type DragPreviewProps = {
+export type DragPreviewProps = {
     offset: XYCoord | null;
     mouse: XYCoord | null;
     id: string | null;
     dragIds: string[];
     isDragging: boolean;
 };
-export declare type CursorProps = {
+export type CursorProps = {
     top: number;
     left: number;
     indent: number;

package/dist/main/types/renderers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+import { NodeApi } from "../interfaces/node-api";
+export type NodeState = typeof NodeApi.prototype["state"];

package/dist/main/types/state.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/main/types/tree-props.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{types → main/types}/utils.d.ts

@@ -3,15 +3,15 @@ import { NodeApi } from "../interfaces/node-api";
 export interface IdObj {
     id: string;
 }
-export declare type Identity = string | IdObj | null;
-export declare type BoolFunc<T> = (data: T) => boolean;
-export declare type ActionTypes<Actions extends {
+export type Identity = string | IdObj | null;
+export type BoolFunc<T> = (data: T) => boolean;
+export type ActionTypes<Actions extends {
     [name: string]: (...args: any[]) => AnyAction;
 }> = ReturnType<Actions[keyof Actions]>;
-export declare type SelectOptions = {
+export type SelectOptions = {
     multi?: boolean;
     contiguous?: boolean;
 };
-export declare type NodesById<T> = {
+export type NodesById<T> = {
     [id: string]: NodeApi<T>;
 };

package/dist/main/types/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{utils.d.ts → main/utils.d.ts}

@@ -5,9 +5,9 @@ export declare function bound(n: number, min: number, max: number): number;
 export declare function isItem(node: NodeApi<any> | null): boolean | null;
 export declare function isClosed(node: NodeApi<any> | null): boolean | null;
 /**
- * Is first param a decendent of the second param
+ * Is first param a descendant of the second param
  */
-export declare const isDecendent: (a: NodeApi<any>, b: NodeApi<any>) => boolean;
+export declare const isDescendant: (a: NodeApi<any>, b: NodeApi<any>) => boolean;
 export declare const indexOf: (node: NodeApi<any>) => number;
 export declare function noop(): void;
 export declare function dfs(node: NodeApi<any>, id: string): NodeApi<any> | null;