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

package/dist/row-data-source-server/range-tree/range-tree.d.ts

@@ -3,21 +3,21 @@ import type { TreeParent, TreeRoot } from "../async-tree/+types.async-tree";
  * Represents a flattened range with start/end row indices and an associated path.
  */
 export type FlattenedRange = {
-    /** Starting row index (inclusive) */
-    rowStart: number;
-    /** Ending row index (exclusive) */
-    rowEnd: number;
-    /** Path identifier for this range */
-    parent: TreeParent<any, any> | TreeRoot<any, any>;
+  /** Starting row index (inclusive) */
+  rowStart: number;
+  /** Ending row index (exclusive) */
+  rowEnd: number;
+  /** Path identifier for this range */
+  parent: TreeParent<any, any> | TreeRoot<any, any>;
 };
 /**
  * Represents a node in a range tree, containing a range and its nested child ranges.
  */
 export interface RangeNode {
-    /** The range associated with this node */
-    range: FlattenedRange;
-    /** Child nodes representing nested ranges within this range */
-    children: RangeNode[];
+  /** The range associated with this node */
+  range: FlattenedRange;
+  /** Child nodes representing nested ranges within this range */
+  children: RangeNode[];
 }
 /**
  * A tree structure for efficient nested range operations.
@@ -45,22 +45,22 @@ export interface RangeNode {
  * ```
  */
 export declare class RangeTree {
-    /** Root node of the range tree */
-    root: RangeNode;
-    /**
-     * Creates a new range tree from an array of flattened ranges.
-     *
-     * @param ranges - Array of ranges to organize into a tree structure
-     */
-    constructor(ranges: FlattenedRange[]);
-    /**
-     * Finds all ranges that contain the specified row index.
-     *
-     * Traverses the tree from root to leaves, collecting all ranges that contain
-     * the target index. Returns ranges in order from outermost to innermost.
-     *
-     * @param index - Row index to search for
-     * @returns Array of ranges containing the index, ordered from outer to inner
-     */
-    findRangesForRowIndex(index: number): FlattenedRange[];
+  /** Root node of the range tree */
+  root: RangeNode;
+  /**
+   * Creates a new range tree from an array of flattened ranges.
+   *
+   * @param ranges - Array of ranges to organize into a tree structure
+   */
+  constructor(ranges: FlattenedRange[]);
+  /**
+   * Finds all ranges that contain the specified row index.
+   *
+   * Traverses the tree from root to leaves, collecting all ranges that contain
+   * the target index. Returns ranges in order from outermost to innermost.
+   *
+   * @param index - Row index to search for
+   * @returns Array of ranges containing the index, ordered from outer to inner
+   */
+  findRangesForRowIndex(index: number): FlattenedRange[];
 }

package/dist/row-data-source-server/range-tree/range-tree.js

@@ -24,44 +24,45 @@
  * ```
  */
 export class RangeTree {
-    /** Root node of the range tree */
-    root;
-    /**
-     * Creates a new range tree from an array of flattened ranges.
-     *
-     * @param ranges - Array of ranges to organize into a tree structure
-     */
-    constructor(ranges) {
-        const sortedRanges = ranges.toSorted((left, right) => left.rowStart - right.rowStart);
-        const root = { range: sortedRanges[0], children: [] };
-        for (let i = 1; i < sortedRanges.length; i++) {
-            insert(root, sortedRanges[i]);
-        }
-        this.root = root;
+  /** Root node of the range tree */
+  root;
+  /**
+   * Creates a new range tree from an array of flattened ranges.
+   *
+   * @param ranges - Array of ranges to organize into a tree structure
+   */
+  constructor(ranges) {
+    const sortedRanges = ranges.toSorted((left, right) => left.rowStart - right.rowStart);
+    const root = { range: sortedRanges[0], children: [] };
+    for (let i = 1; i < sortedRanges.length; i++) {
+      insert(root, sortedRanges[i]);
     }
-    /**
-     * Finds all ranges that contain the specified row index.
-     *
-     * Traverses the tree from root to leaves, collecting all ranges that contain
-     * the target index. Returns ranges in order from outermost to innermost.
-     *
-     * @param index - Row index to search for
-     * @returns Array of ranges containing the index, ordered from outer to inner
-     */
-    findRangesForRowIndex(index) {
-        const ranges = [];
-        let currentNode = this.root;
-        while (currentNode) {
-            if (index >= currentNode.range.rowStart && index < currentNode.range.rowEnd) {
-                ranges.push(currentNode.range);
-                currentNode = currentNode.children.find((child) => index >= child.range.rowStart && index < child.range.rowEnd);
-            }
-            else {
-                break;
-            }
-        }
-        return ranges;
+    this.root = root;
+  }
+  /**
+   * Finds all ranges that contain the specified row index.
+   *
+   * Traverses the tree from root to leaves, collecting all ranges that contain
+   * the target index. Returns ranges in order from outermost to innermost.
+   *
+   * @param index - Row index to search for
+   * @returns Array of ranges containing the index, ordered from outer to inner
+   */
+  findRangesForRowIndex(index) {
+    const ranges = [];
+    let currentNode = this.root;
+    while (currentNode) {
+      if (index >= currentNode.range.rowStart && index < currentNode.range.rowEnd) {
+        ranges.push(currentNode.range);
+        currentNode = currentNode.children.find(
+          (child) => index >= child.range.rowStart && index < child.range.rowEnd,
+        );
+      } else {
+        break;
+      }
     }
+    return ranges;
+  }
 }
 /**
  * Inserts a range into the appropriate position in the range tree.
@@ -73,18 +74,18 @@ export class RangeTree {
  * @param range - Range to insert into the tree
  */
 function insert(node, range) {
-    // Check each child to see if it contains this range
-    for (const child of node.children) {
-        if (containsRange(child.range, range)) {
-            insert(child, range);
-            return;
-        }
+  // Check each child to see if it contains this range
+  for (const child of node.children) {
+    if (containsRange(child.range, range)) {
+      insert(child, range);
+      return;
     }
-    // If we get here, this node is the parent
-    node.children.push({
-        range,
-        children: [],
-    });
+  }
+  // If we get here, this node is the parent
+  node.children.push({
+    range,
+    children: [],
+  });
 }
 /**
  * Determines if one range fully contains another range.
@@ -98,5 +99,5 @@ function insert(node, range) {
  * @returns true if outer fully contains inner, false otherwise
  */
 function containsRange(outer, inner) {
-    return outer.rowStart <= inner.rowStart && outer.rowEnd >= inner.rowEnd;
+  return outer.rowStart <= inner.rowStart && outer.rowEnd >= inner.rowEnd;
 }

package/dist/row-data-source-server/use-server-data-source.d.ts

@@ -1,3 +1,12 @@
 import type { RowDataSourceServer, RowDataSourceServerParams } from "../+types.js";
-export declare function makeServerDataSource<T>({ dataFetcher, dataColumnPivotFetcher, dataInFilterItemFetcher, cellUpdateHandler, cellUpdateOptimistically, blockSize, }: RowDataSourceServerParams<T>): RowDataSourceServer<T>;
-export declare function useServerDataSource<T>(p: RowDataSourceServerParams<T>): RowDataSourceServer<T>;
+export declare function makeServerDataSource<T>({
+  dataFetcher,
+  dataColumnPivotFetcher,
+  dataInFilterItemFetcher,
+  cellUpdateHandler,
+  cellUpdateOptimistically,
+  blockSize,
+}: RowDataSourceServerParams<T>): RowDataSourceServer<T>;
+export declare function useServerDataSource<T>(
+  p: RowDataSourceServerParams<T>,
+): RowDataSourceServer<T>;