@1771technologies/lytenyte-pro 1.0.0-beta.36 → 1.0.0-beta.38

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,45 +24,44 @@
  * ```
  */
 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]);
+    /** 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;
     }
-    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;
-      }
+    /**
+     * 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;
     }
-    return ranges;
-  }
 }
 /**
  * Inserts a range into the appropriate position in the range tree.
@@ -74,18 +73,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.
@@ -99,5 +98,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,12 +1,3 @@
 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>;