@1771technologies/lytenyte-pro 1.0.0-beta.11 → 1.0.0-beta.12

package/dist/tree-view/virtualized/make-virtual-tree.js

@@ -1,90 +1,84 @@
 export function makeVirtualTree(paths, nodeToIndex, itemHeight, nonAdjacentPathTrees) {
-    const root = [];
-    const lookup = new Map();
-    for (const [rawPath, node] of paths) {
-        const path = typeof rawPath === "string" ? [] : rawPath;
-        if (nonAdjacentPathTrees)
-            path.pop();
-        const joinPath = path.join("#");
-        if (node.kind === "branch") {
-            const rowIndex = nodeToIndex.get(node);
-            const parentIndex = node.parent.kind === "root" ? 0 : nodeToIndex.get(node.parent);
-            const posinset = rowIndex - parentIndex + 1;
-            const setSize = node.parent.children.size;
-            const branchNode = {
-                kind: "branch",
-                path: joinPath,
-                branch: node,
-                children: [],
-                rowIndex,
-                attrs: {
-                    style: {
-                        position: "absolute",
-                        height: itemHeight,
-                        width: "100%",
-                        boxSizing: "border-box",
-                        top: 0,
-                        left: 0,
-                        transform: `translate3d(0px, ${(posinset - 1) * itemHeight}px, 0px)`,
-                    },
-                    "data-ln-row-index": rowIndex,
-                    "aria-posinset": posinset,
-                    "aria-setsize": setSize,
-                },
-            };
-            lookup.set(joinPath, branchNode);
-            if (path.length === 0) {
-                root.push(branchNode);
-            }
-            else {
-                const parentPath = path.slice(0, -1).join("#");
-                const parent = lookup.get(parentPath);
-                if (parent) {
-                    parent.children.push(branchNode);
-                }
-                else {
-                    root.push(branchNode); // fallback
-                }
-            }
+  const root = [];
+  const lookup = new Map();
+  for (const [rawPath, node] of paths) {
+    const path = typeof rawPath === "string" ? [] : rawPath;
+    if (nonAdjacentPathTrees) path.pop();
+    const joinPath = path.join("#");
+    if (node.kind === "branch") {
+      const rowIndex = nodeToIndex.get(node);
+      const parentIndex = node.parent.kind === "root" ? 0 : nodeToIndex.get(node.parent);
+      const posinset = rowIndex - parentIndex + 1;
+      const setSize = node.parent.children.size;
+      const branchNode = {
+        kind: "branch",
+        path: joinPath,
+        branch: node,
+        children: [],
+        rowIndex,
+        attrs: {
+          style: {
+            position: "absolute",
+            height: itemHeight,
+            width: "100%",
+            boxSizing: "border-box",
+            top: 0,
+            left: 0,
+            transform: `translate3d(0px, ${(posinset - 1) * itemHeight}px, 0px)`,
+          },
+          "data-ln-row-index": rowIndex,
+          "aria-posinset": posinset,
+          "aria-setsize": setSize,
+        },
+      };
+      lookup.set(joinPath, branchNode);
+      if (path.length === 0) {
+        root.push(branchNode);
+      } else {
+        const parentPath = path.slice(0, -1).join("#");
+        const parent = lookup.get(parentPath);
+        if (parent) {
+          parent.children.push(branchNode);
+        } else {
+          root.push(branchNode); // fallback
         }
-        else {
-            const rowIndex = nodeToIndex.get(node);
-            const parentIndex = node.parent.kind === "root" ? 0 : nodeToIndex.get(node.parent);
-            const posinset = rowIndex - parentIndex + 1;
-            const setSize = node.parent.children.size;
-            const leafNode = {
-                kind: "leaf",
-                leaf: node,
-                rowIndex,
-                attrs: {
-                    style: {
-                        position: "absolute",
-                        height: itemHeight,
-                        boxSizing: "border-box",
-                        width: "100%",
-                        top: 0,
-                        left: 0,
-                        transform: `translate3d(0px, ${(posinset - 1) * itemHeight}px, 0px)`,
-                    },
-                    "data-ln-row-index": rowIndex,
-                    "aria-posinset": posinset,
-                    "aria-setsize": setSize,
-                },
-            };
-            if (path.length === 0) {
-                root.push(leafNode); // top-level leaf
-            }
-            else {
-                const parentPath = path.join("#");
-                const parent = lookup.get(parentPath);
-                if (parent) {
-                    parent.children.push(leafNode);
-                }
-                else {
-                    root.push(leafNode); // fallback
-                }
-            }
+      }
+    } else {
+      const rowIndex = nodeToIndex.get(node);
+      const parentIndex = node.parent.kind === "root" ? 0 : nodeToIndex.get(node.parent);
+      const posinset = rowIndex - parentIndex + 1;
+      const setSize = node.parent.children.size;
+      const leafNode = {
+        kind: "leaf",
+        leaf: node,
+        rowIndex,
+        attrs: {
+          style: {
+            position: "absolute",
+            height: itemHeight,
+            boxSizing: "border-box",
+            width: "100%",
+            top: 0,
+            left: 0,
+            transform: `translate3d(0px, ${(posinset - 1) * itemHeight}px, 0px)`,
+          },
+          "data-ln-row-index": rowIndex,
+          "aria-posinset": posinset,
+          "aria-setsize": setSize,
+        },
+      };
+      if (path.length === 0) {
+        root.push(leafNode); // top-level leaf
+      } else {
+        const parentPath = path.join("#");
+        const parent = lookup.get(parentPath);
+        if (parent) {
+          parent.children.push(leafNode);
+        } else {
+          root.push(leafNode); // fallback
         }
+      }
     }
-    return root;
+  }
+  return root;
 }

package/dist/tree-view/virtualized/use-flattened-tree.d.ts

@@ -1,9 +1,18 @@
-import { type PathBranch, type PathLeaf, type PathProvidedItem } from "@1771technologies/lytenyte-shared";
-export declare function useFlattenedTree<T extends PathProvidedItem>(paths: T[], expansions: Record<string, boolean>, expansionDefault: boolean, nonAdjacentPathTrees?: boolean): {
-    flat: (PathBranch<T> | PathLeaf<T>)[];
-    nodeToIndex: Map<PathBranch<T> | PathLeaf<T>, number>;
-    indexToId: Map<number, string>;
-    allIds: Set<string>;
-    idToNode: Map<string, PathBranch<T> | PathLeaf<T>>;
-    root: import("@1771technologies/lytenyte-shared").PathRoot<T>;
+import {
+  type PathBranch,
+  type PathLeaf,
+  type PathProvidedItem,
+} from "@1771technologies/lytenyte-shared";
+export declare function useFlattenedTree<T extends PathProvidedItem>(
+  paths: T[],
+  expansions: Record<string, boolean>,
+  expansionDefault: boolean,
+  nonAdjacentPathTrees?: boolean,
+): {
+  flat: (PathBranch<T> | PathLeaf<T>)[];
+  nodeToIndex: Map<PathBranch<T> | PathLeaf<T>, number>;
+  indexToId: Map<number, string>;
+  allIds: Set<string>;
+  idToNode: Map<string, PathBranch<T> | PathLeaf<T>>;
+  root: import("@1771technologies/lytenyte-shared").PathRoot<T>;
 };

package/dist/tree-view/virtualized/use-flattened-tree.js

@@ -1,36 +1,35 @@
-import { computePathTree, } from "@1771technologies/lytenyte-shared";
+import { computePathTree } from "@1771technologies/lytenyte-shared";
 import { useMemo } from "react";
 export function useFlattenedTree(paths, expansions, expansionDefault, nonAdjacentPathTrees) {
-    const { flat, nodeToIndex, indexToId, allIds, idToNode, root } = useMemo(() => {
-        const root = computePathTree(paths, undefined, nonAdjacentPathTrees);
-        const flat = [];
-        const nodeToIndex = new Map();
-        const stack = [...root.children.values()];
-        const allIds = new Set();
-        const indexToId = new Map();
-        const idToNode = new Map();
-        let index = 0;
-        while (stack.length) {
-            const item = stack.shift();
-            if (item.kind === "leaf") {
-                flat.push(item);
-            }
-            else {
-                flat.push(item);
-                const isExpanded = expansions[item.id] ?? expansionDefault;
-                if (isExpanded) {
-                    const children = [...item.children.values()];
-                    stack.unshift(...children);
-                }
-            }
-            const id = item.kind === "branch" ? item.data.idOccurrence : item.data.id;
-            allIds.add(id);
-            indexToId.set(index, id);
-            nodeToIndex.set(item, index);
-            idToNode.set(id, item);
-            index++;
+  const { flat, nodeToIndex, indexToId, allIds, idToNode, root } = useMemo(() => {
+    const root = computePathTree(paths, undefined, nonAdjacentPathTrees);
+    const flat = [];
+    const nodeToIndex = new Map();
+    const stack = [...root.children.values()];
+    const allIds = new Set();
+    const indexToId = new Map();
+    const idToNode = new Map();
+    let index = 0;
+    while (stack.length) {
+      const item = stack.shift();
+      if (item.kind === "leaf") {
+        flat.push(item);
+      } else {
+        flat.push(item);
+        const isExpanded = expansions[item.id] ?? expansionDefault;
+        if (isExpanded) {
+          const children = [...item.children.values()];
+          stack.unshift(...children);
         }
-        return { flat, nodeToIndex, indexToId, allIds, idToNode, root };
-    }, [expansionDefault, expansions, nonAdjacentPathTrees, paths]);
+      }
+      const id = item.kind === "branch" ? item.data.idOccurrence : item.data.id;
+      allIds.add(id);
+      indexToId.set(index, id);
+      nodeToIndex.set(item, index);
+      idToNode.set(id, item);
+      index++;
+    }
     return { flat, nodeToIndex, indexToId, allIds, idToNode, root };
+  }, [expansionDefault, expansions, nonAdjacentPathTrees, paths]);
+  return { flat, nodeToIndex, indexToId, allIds, idToNode, root };
 }

package/dist/tree-view/virtualized/use-row-start-and-end.d.ts

@@ -1,2 +1,7 @@
 import type { RectReadOnly } from "@1771technologies/lytenyte-react-hooks";
-export declare function useRowStartAndEnd(panel: HTMLElement | null | undefined, itemHeight: number, bounds: RectReadOnly, size: number): number[];
+export declare function useRowStartAndEnd(
+  panel: HTMLElement | null | undefined,
+  itemHeight: number,
+  bounds: RectReadOnly,
+  size: number,
+): number[];

package/dist/tree-view/virtualized/use-row-start-and-end.js

@@ -1,27 +1,25 @@
 import { clamp } from "@1771technologies/lytenyte-js-utils";
 import { useEffect, useMemo, useState } from "react";
 export function useRowStartAndEnd(panel, itemHeight, bounds, size) {
-    const [startOffset, setStartOffset] = useState(0);
-    const [rowStart, rowEnd] = useMemo(() => {
-        if (!panel)
-            return [0, 0];
-        const start = startOffset;
-        const end = start + Math.ceil(bounds.height / itemHeight) + 1;
-        return [clamp(0, start - 3, size), clamp(0, end + 3, size)];
-    }, [bounds.height, itemHeight, panel, size, startOffset]);
-    useEffect(() => {
-        if (!panel)
-            return;
-        const handleViewChange = () => {
-            const scrollTop = panel.scrollTop;
-            const start = Math.floor(scrollTop / itemHeight);
-            setStartOffset(start);
-        };
-        handleViewChange();
-        panel.addEventListener("scroll", handleViewChange);
-        return () => {
-            panel.removeEventListener("scroll", handleViewChange);
-        };
-    }, [itemHeight, panel]);
-    return [rowStart, rowEnd];
+  const [startOffset, setStartOffset] = useState(0);
+  const [rowStart, rowEnd] = useMemo(() => {
+    if (!panel) return [0, 0];
+    const start = startOffset;
+    const end = start + Math.ceil(bounds.height / itemHeight) + 1;
+    return [clamp(0, start - 3, size), clamp(0, end + 3, size)];
+  }, [bounds.height, itemHeight, panel, size, startOffset]);
+  useEffect(() => {
+    if (!panel) return;
+    const handleViewChange = () => {
+      const scrollTop = panel.scrollTop;
+      const start = Math.floor(scrollTop / itemHeight);
+      setStartOffset(start);
+    };
+    handleViewChange();
+    panel.addEventListener("scroll", handleViewChange);
+    return () => {
+      panel.removeEventListener("scroll", handleViewChange);
+    };
+  }, [itemHeight, panel]);
+  return [rowStart, rowEnd];
 }

package/dist/tree-view/virtualized/use-virtualized-tree.d.ts

@@ -2,21 +2,27 @@ import { type PathProvidedItem, type PathRoot } from "@1771technologies/lytenyte
 import { type JSX } from "react";
 import { type TreeVirtualItem } from "./make-virtual-tree.js";
 export interface VirtualizedTreeViewPathsArgs<T extends PathProvidedItem> {
-    readonly itemHeight: number;
-    readonly expansions: Record<string, boolean>;
-    readonly expansionDefault?: boolean;
-    readonly paths: T[];
-    readonly nonAdjacentPathTrees?: boolean;
+  readonly itemHeight: number;
+  readonly expansions: Record<string, boolean>;
+  readonly expansionDefault?: boolean;
+  readonly paths: T[];
+  readonly nonAdjacentPathTrees?: boolean;
 }
 export interface TreeReturn<T extends PathProvidedItem> {
-    readonly ref: (h: HTMLElement | null) => void;
-    readonly virtualTree: TreeVirtualItem<T>[];
-    readonly spacer: JSX.Element;
-    readonly rootProps: {
-        readonly getAllIds: () => Set<string>;
-        readonly getIdsBetweenNodes: (h: HTMLElement, r: HTMLElement) => string[];
-        readonly onFocusChange: (h: HTMLElement | null) => void;
-        readonly root: PathRoot<T>;
-    };
+  readonly ref: (h: HTMLElement | null) => void;
+  readonly virtualTree: TreeVirtualItem<T>[];
+  readonly spacer: JSX.Element;
+  readonly rootProps: {
+    readonly getAllIds: () => Set<string>;
+    readonly getIdsBetweenNodes: (h: HTMLElement, r: HTMLElement) => string[];
+    readonly onFocusChange: (h: HTMLElement | null) => void;
+    readonly root: PathRoot<T>;
+  };
 }
-export declare function useVirtualizedTree<T extends PathProvidedItem>({ itemHeight, expansions, expansionDefault, nonAdjacentPathTrees, paths, }: VirtualizedTreeViewPathsArgs<T>): TreeReturn<T>;
+export declare function useVirtualizedTree<T extends PathProvidedItem>({
+  itemHeight,
+  expansions,
+  expansionDefault,
+  nonAdjacentPathTrees,
+  paths,
+}: VirtualizedTreeViewPathsArgs<T>): TreeReturn<T>;

package/dist/tree-view/virtualized/use-virtualized-tree.js

@@ -7,94 +7,107 @@ import { makeVirtualTree } from "./make-virtual-tree.js";
 import { useFlattenedTree } from "./use-flattened-tree.js";
 import { useRowStartAndEnd } from "./use-row-start-and-end.js";
 import { getTreeNodeId } from "../utils/get-tree-node-id.js";
-export function useVirtualizedTree({ itemHeight, expansions, expansionDefault = false, nonAdjacentPathTrees, paths, }) {
-    const [ref, bounds, _, panel] = useMeasure({ scroll: true });
-    const { flat, nodeToIndex, indexToId, allIds, idToNode, root } = useFlattenedTree(paths, expansions, expansionDefault, nonAdjacentPathTrees);
-    const size = useMemo(() => flat.length, [flat.length]);
-    const [rowStart, rowEnd] = useRowStartAndEnd(panel, itemHeight, bounds, size);
-    const [focused, setFocused] = useState(null);
-    const virtualTree = useMemo(() => {
-        const items = flat.slice(rowStart, rowEnd);
-        if (!items.length)
-            return [];
-        // Ensure that the parent nodes of the current tree in view are added as well. This ensure that
-        // the nodes are always visible.
-        while (items[0].parent.kind !== "root") {
-            items.unshift(items[0].parent);
-        }
-        // Ensure that the first node is always in the list of tree nodes so the home key works fine.
-        if (rowStart !== 0 && items[0] !== flat[0])
-            items.unshift(flat[0]);
-        // Ensure the last node is always in the list of nodes present.
-        if (rowEnd !== flat.length) {
-            const endItems = [flat.at(-1)];
-            while (endItems[0].parent.kind !== "root" && endItems[0].parent !== items.at(-1)) {
-                endItems.unshift(endItems[0].parent);
-            }
-            items.push(...endItems);
-        }
-        // Finally we need to ensure the focused node is present. We add the node before and after
-        // the current node - so that the next and previous node are selectable.
-        if (focused && idToNode.has(focused)) {
-            const node = idToNode.get(focused);
-            const index = nodeToIndex.get(node);
-            const nextId = indexToId.get(index + 1);
-            const prevId = indexToId.get(index - 1);
-            const next = idToNode.get(nextId);
-            const prev = idToNode.get(prevId);
-            if (!items.includes(node)) {
-                const firstIndexGreater = items.findIndex((c) => nodeToIndex.get(c) > index);
-                items.splice(firstIndexGreater, 0, node);
-            }
-            if (next && !items.includes(next)) {
-                const firstIndexGreater = items.findIndex((c) => nodeToIndex.get(c) > index + 1);
-                items.splice(firstIndexGreater, 0, next);
-            }
-            if (prev && !items.includes(prev)) {
-                const firstIndexGreater = items.findIndex((c) => nodeToIndex.get(c) > index - 1);
-                items.splice(firstIndexGreater, 0, prev);
-            }
-        }
-        const subtreePaths = buildVirtualTreePartial(items);
-        const subtree = makeVirtualTree(subtreePaths, nodeToIndex, itemHeight, nonAdjacentPathTrees ?? false);
-        return subtree;
-    }, [
-        flat,
-        focused,
-        idToNode,
-        indexToId,
-        itemHeight,
-        nodeToIndex,
-        nonAdjacentPathTrees,
-        rowEnd,
-        rowStart,
-    ]);
-    const spacer = _jsx("div", { style: { height: size * itemHeight, width: 0 } });
-    const onFocusChange = useEvent((el) => {
-        setFocused(el ? getTreeNodeId(el) : null);
-    });
-    const getAllIds = useEvent(() => allIds);
-    const getIdsBetweenNodes = useEvent((left, right) => {
-        const leftIndex = Number.parseInt(left.getAttribute("data-ln-row-index"));
-        const rightIndex = Number.parseInt(right.getAttribute("data-ln-row-index"));
-        const [start, end] = leftIndex < rightIndex ? [leftIndex, rightIndex] : [rightIndex, leftIndex];
-        if (start === end)
-            return [indexToId.get(start)];
-        const ids = [];
-        for (let i = start; i <= end; i++) {
-            ids.push(indexToId.get(i));
-        }
-        return ids;
-    });
-    return {
-        ref,
-        virtualTree,
-        spacer,
-        rootProps: {
-            getAllIds,
-            getIdsBetweenNodes,
-            onFocusChange,
-            root,
-        },
-    };
+export function useVirtualizedTree({
+  itemHeight,
+  expansions,
+  expansionDefault = false,
+  nonAdjacentPathTrees,
+  paths,
+}) {
+  const [ref, bounds, _, panel] = useMeasure({ scroll: true });
+  const { flat, nodeToIndex, indexToId, allIds, idToNode, root } = useFlattenedTree(
+    paths,
+    expansions,
+    expansionDefault,
+    nonAdjacentPathTrees,
+  );
+  const size = useMemo(() => flat.length, [flat.length]);
+  const [rowStart, rowEnd] = useRowStartAndEnd(panel, itemHeight, bounds, size);
+  const [focused, setFocused] = useState(null);
+  const virtualTree = useMemo(() => {
+    const items = flat.slice(rowStart, rowEnd);
+    if (!items.length) return [];
+    // Ensure that the parent nodes of the current tree in view are added as well. This ensure that
+    // the nodes are always visible.
+    while (items[0].parent.kind !== "root") {
+      items.unshift(items[0].parent);
+    }
+    // Ensure that the first node is always in the list of tree nodes so the home key works fine.
+    if (rowStart !== 0 && items[0] !== flat[0]) items.unshift(flat[0]);
+    // Ensure the last node is always in the list of nodes present.
+    if (rowEnd !== flat.length) {
+      const endItems = [flat.at(-1)];
+      while (endItems[0].parent.kind !== "root" && endItems[0].parent !== items.at(-1)) {
+        endItems.unshift(endItems[0].parent);
+      }
+      items.push(...endItems);
+    }
+    // Finally we need to ensure the focused node is present. We add the node before and after
+    // the current node - so that the next and previous node are selectable.
+    if (focused && idToNode.has(focused)) {
+      const node = idToNode.get(focused);
+      const index = nodeToIndex.get(node);
+      const nextId = indexToId.get(index + 1);
+      const prevId = indexToId.get(index - 1);
+      const next = idToNode.get(nextId);
+      const prev = idToNode.get(prevId);
+      if (!items.includes(node)) {
+        const firstIndexGreater = items.findIndex((c) => nodeToIndex.get(c) > index);
+        items.splice(firstIndexGreater, 0, node);
+      }
+      if (next && !items.includes(next)) {
+        const firstIndexGreater = items.findIndex((c) => nodeToIndex.get(c) > index + 1);
+        items.splice(firstIndexGreater, 0, next);
+      }
+      if (prev && !items.includes(prev)) {
+        const firstIndexGreater = items.findIndex((c) => nodeToIndex.get(c) > index - 1);
+        items.splice(firstIndexGreater, 0, prev);
+      }
+    }
+    const subtreePaths = buildVirtualTreePartial(items);
+    const subtree = makeVirtualTree(
+      subtreePaths,
+      nodeToIndex,
+      itemHeight,
+      nonAdjacentPathTrees ?? false,
+    );
+    return subtree;
+  }, [
+    flat,
+    focused,
+    idToNode,
+    indexToId,
+    itemHeight,
+    nodeToIndex,
+    nonAdjacentPathTrees,
+    rowEnd,
+    rowStart,
+  ]);
+  const spacer = _jsx("div", { style: { height: size * itemHeight, width: 0 } });
+  const onFocusChange = useEvent((el) => {
+    setFocused(el ? getTreeNodeId(el) : null);
+  });
+  const getAllIds = useEvent(() => allIds);
+  const getIdsBetweenNodes = useEvent((left, right) => {
+    const leftIndex = Number.parseInt(left.getAttribute("data-ln-row-index"));
+    const rightIndex = Number.parseInt(right.getAttribute("data-ln-row-index"));
+    const [start, end] = leftIndex < rightIndex ? [leftIndex, rightIndex] : [rightIndex, leftIndex];
+    if (start === end) return [indexToId.get(start)];
+    const ids = [];
+    for (let i = start; i <= end; i++) {
+      ids.push(indexToId.get(i));
+    }
+    return ids;
+  });
+  return {
+    ref,
+    virtualTree,
+    spacer,
+    rootProps: {
+      getAllIds,
+      getIdsBetweenNodes,
+      onFocusChange,
+      root,
+    },
+  };
 }

package/dist/utils/cycle-sorts.js

@@ -1,16 +1,14 @@
 export function cycleSorts(grid, column) {
-    const current = grid.api.sortForColumn(column.id);
-    if (current) {
-        if (current.sort.isDescending)
-            grid.state.sortModel.set([]);
-        else
-            grid.state.sortModel.set([
-                { columnId: column.id, sort: { kind: "string" }, isDescending: true },
-            ]);
-    }
-    else {
-        grid.state.sortModel.set([
-            { columnId: column.id, sort: { kind: "string" }, isDescending: false },
-        ]);
-    }
+  const current = grid.api.sortForColumn(column.id);
+  if (current) {
+    if (current.sort.isDescending) grid.state.sortModel.set([]);
+    else
+      grid.state.sortModel.set([
+        { columnId: column.id, sort: { kind: "string" }, isDescending: true },
+      ]);
+  } else {
+    grid.state.sortModel.set([
+      { columnId: column.id, sort: { kind: "string" }, isDescending: false },
+    ]);
+  }
 }

package/dist/viewport/begin-editing.d.ts

@@ -1,5 +1,9 @@
 import type { Grid } from "../+types";
 import type { InternalAtoms } from "../state/+types";
-export declare function beginEditing<T>(grid: Grid<T> & {
+export declare function beginEditing<T>(
+  grid: Grid<T> & {
     internal: InternalAtoms;
-}, activator?: "single" | "double-click", init?: any): void;
+  },
+  activator?: "single" | "double-click",
+  init?: any,
+): void;