pixel-react 1.6.5 → 1.6.6

package/src/components/Excel/ExcelFile/ExcelFileComponents/engine/point-graph.ts

@@ -1,152 +1,152 @@
-import { Point } from '../point';
-import * as pointHash from './point-hash';
-import { PointSet } from './point-set';
-
-/**
- * Immutable directed graph of points, where each point can have multiple
- * edges to other points.
- */
-export class PointGraph {
-  private constructor(private forwards = new Map<string, PointSet>()) {}
-
-  /** Creates a new PointGraph instance from an array-like or iterable object */
-  static from(pairs: Iterable<[Point, PointSet]>): PointGraph {
-    const forwards = new Map<string, PointSet>();
-    for (const [node, edges] of pairs) {
-      forwards.set(pointHash.toString(node), edges);
-    }
-    return new PointGraph(forwards);
-  }
-
-  set(node: Point, edges: PointSet): PointGraph {
-    const newGraph = new PointGraph(new Map(this.forwards));
-    if (edges.size === 0) {
-      newGraph.forwards.delete(pointHash.toString(node));
-      return newGraph;
-    }
-    newGraph.forwards.set(pointHash.toString(node), edges);
-    return newGraph;
-  }
-
-  get(node: Point): PointSet {
-    return this.forwards.get(pointHash.toString(node)) || PointSet.from([]);
-  }
-
-  getBackwards(node: Point): PointSet {
-    let result = PointSet.from([]);
-    for (const [key, value] of this.forwards) {
-      if (value.has(node)) {
-        result = result.add(pointHash.fromString(key));
-      }
-    }
-    return result;
-  }
-
-  getBackwardsRecursive(
-    node: Point,
-    visited: PointSet = PointSet.from([])
-  ): PointSet {
-    let result = this.getBackwards(node);
-    let newVisited = visited;
-    for (const point of result) {
-      if (newVisited.has(point)) {
-        continue;
-      }
-      newVisited = newVisited.add(point);
-      result = result.union(this.getBackwardsRecursive(point, newVisited));
-    }
-    return result;
-  }
-
-  hasCircularDependency(startPoint: Point): boolean {
-    let visited = PointSet.from([]);
-    const stack: Point[] = [startPoint];
-
-    while (stack.length > 0) {
-      const current = stack.pop();
-      if (!current) {
-        continue;
-      }
-
-      if (visited.has(current)) {
-        return true;
-      }
-
-      visited = visited.add(current);
-
-      const dependents = this.get(current);
-
-      if (!dependents) {
-        continue;
-      }
-
-      for (const dependent of dependents) {
-        stack.push(dependent);
-      }
-    }
-
-    return false;
-  }
-
-  *[Symbol.iterator](): Iterator<[Point, PointSet]> {
-    const visitedHashes = new Set<string>();
-    for (const [key, values] of this.forwards) {
-      const point = pointHash.fromString(key);
-      visitedHashes.add(key);
-      yield [point, values];
-
-      for (const value of values) {
-        const hash = pointHash.toString(value);
-        if (!visitedHashes.has(hash) && !this.forwards.has(hash)) {
-          visitedHashes.add(hash);
-          yield [value, PointSet.from([])];
-        }
-      }
-    }
-  }
-
-  /** Get the points in the graph in a breadth-first order */
-  *traverseBFSBackwards(): Generator<Point> {
-    // Create a Set to store the points that have been visited
-    let visited = PointSet.from([]);
-
-    // Create a queue to store the points that still need to be visited
-    const queue: Point[] = [];
-
-    // Iterate over all the points and add the ones with no dependencies to the queue
-    for (const [point, values] of this) {
-      if (values.size === 0) {
-        visited = visited.add(point);
-        queue.push(point);
-      }
-    }
-
-    // While there are points in the queue, remove the first one and yield it
-    while (queue.length > 0) {
-      const point = queue.shift();
-      if (!point) {
-        continue;
-      }
-      yield point;
-
-      // Get the set of points that depend on the current point
-      const dependents = this.getBackwards(point);
-
-      // If there are no dependents, skip to the next iteration
-      if (dependents.size === 0) {
-        continue;
-      }
-
-      // Otherwise, add the dependents to the queue if they have not yet been visited
-      for (const dependent of dependents) {
-        if (
-          !visited.has(dependent) &&
-          this.get(dependent).difference(visited).size === 0
-        ) {
-          queue.push(dependent);
-          visited = visited.add(dependent);
-        }
-      }
-    }
-  }
-}
+import { Point } from '../point';
+import * as pointHash from './point-hash';
+import { PointSet } from './point-set';
+
+/**
+ * Immutable directed graph of points, where each point can have multiple
+ * edges to other points.
+ */
+export class PointGraph {
+  private constructor(private forwards = new Map<string, PointSet>()) {}
+
+  /** Creates a new PointGraph instance from an array-like or iterable object */
+  static from(pairs: Iterable<[Point, PointSet]>): PointGraph {
+    const forwards = new Map<string, PointSet>();
+    for (const [node, edges] of pairs) {
+      forwards.set(pointHash.toString(node), edges);
+    }
+    return new PointGraph(forwards);
+  }
+
+  set(node: Point, edges: PointSet): PointGraph {
+    const newGraph = new PointGraph(new Map(this.forwards));
+    if (edges.size === 0) {
+      newGraph.forwards.delete(pointHash.toString(node));
+      return newGraph;
+    }
+    newGraph.forwards.set(pointHash.toString(node), edges);
+    return newGraph;
+  }
+
+  get(node: Point): PointSet {
+    return this.forwards.get(pointHash.toString(node)) || PointSet.from([]);
+  }
+
+  getBackwards(node: Point): PointSet {
+    let result = PointSet.from([]);
+    for (const [key, value] of this.forwards) {
+      if (value.has(node)) {
+        result = result.add(pointHash.fromString(key));
+      }
+    }
+    return result;
+  }
+
+  getBackwardsRecursive(
+    node: Point,
+    visited: PointSet = PointSet.from([])
+  ): PointSet {
+    let result = this.getBackwards(node);
+    let newVisited = visited;
+    for (const point of result) {
+      if (newVisited.has(point)) {
+        continue;
+      }
+      newVisited = newVisited.add(point);
+      result = result.union(this.getBackwardsRecursive(point, newVisited));
+    }
+    return result;
+  }
+
+  hasCircularDependency(startPoint: Point): boolean {
+    let visited = PointSet.from([]);
+    const stack: Point[] = [startPoint];
+
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (!current) {
+        continue;
+      }
+
+      if (visited.has(current)) {
+        return true;
+      }
+
+      visited = visited.add(current);
+
+      const dependents = this.get(current);
+
+      if (!dependents) {
+        continue;
+      }
+
+      for (const dependent of dependents) {
+        stack.push(dependent);
+      }
+    }
+
+    return false;
+  }
+
+  *[Symbol.iterator](): Iterator<[Point, PointSet]> {
+    const visitedHashes = new Set<string>();
+    for (const [key, values] of this.forwards) {
+      const point = pointHash.fromString(key);
+      visitedHashes.add(key);
+      yield [point, values];
+
+      for (const value of values) {
+        const hash = pointHash.toString(value);
+        if (!visitedHashes.has(hash) && !this.forwards.has(hash)) {
+          visitedHashes.add(hash);
+          yield [value, PointSet.from([])];
+        }
+      }
+    }
+  }
+
+  /** Get the points in the graph in a breadth-first order */
+  *traverseBFSBackwards(): Generator<Point> {
+    // Create a Set to store the points that have been visited
+    let visited = PointSet.from([]);
+
+    // Create a queue to store the points that still need to be visited
+    const queue: Point[] = [];
+
+    // Iterate over all the points and add the ones with no dependencies to the queue
+    for (const [point, values] of this) {
+      if (values.size === 0) {
+        visited = visited.add(point);
+        queue.push(point);
+      }
+    }
+
+    // While there are points in the queue, remove the first one and yield it
+    while (queue.length > 0) {
+      const point = queue.shift();
+      if (!point) {
+        continue;
+      }
+      yield point;
+
+      // Get the set of points that depend on the current point
+      const dependents = this.getBackwards(point);
+
+      // If there are no dependents, skip to the next iteration
+      if (dependents.size === 0) {
+        continue;
+      }
+
+      // Otherwise, add the dependents to the queue if they have not yet been visited
+      for (const dependent of dependents) {
+        if (
+          !visited.has(dependent) &&
+          this.get(dependent).difference(visited).size === 0
+        ) {
+          queue.push(dependent);
+          visited = visited.add(dependent);
+        }
+      }
+    }
+  }
+}

package/src/components/Excel/ExcelFile/ExcelFileComponents/engine/point-hash.ts

@@ -1,10 +1,10 @@
-import { Point } from '../point';
-
-export function toString(point: Point): string {
-  return `${point.row},${point.column}`;
-}
-
-export function fromString(point: string): Point {
-  const [row, column] = point.split(',');
-  return { row: Number(row), column: Number(column) };
-}
+import { Point } from '../point';
+
+export function toString(point: Point): string {
+  return `${point.row},${point.column}`;
+}
+
+export function fromString(point: string): Point {
+  const [row, column] = point.split(',');
+  return { row: Number(row), column: Number(column) };
+}

package/src/components/Excel/ExcelFile/ExcelFileComponents/engine/point-set.ts

@@ -1,69 +1,69 @@
-import * as Point from '../point';
-import * as pointHash from './point-hash';
-
-/**
- * Immutable Set like interface of points
- */
-export class PointSet {
-  private constructor(private set: Set<string>) {}
-
-  /** Creates a new PointSet instance from an array-like or iterable object */
-  static from(points: Iterable<Point.Point>): PointSet {
-    const set = new Set<string>();
-    for (const point of points) {
-      set.add(pointHash.toString(point));
-    }
-    return new PointSet(set);
-  }
-
-  /** Returns a boolean asserting whether an point is present with the given value in the Set object or not */
-  has(point: Point.Point): boolean {
-    return this.set.has(pointHash.toString(point));
-  }
-
-  /** Returns the number of points in a PointSet object */
-  get size(): number {
-    return this.set.size;
-  }
-
-  /** Add the given point to given set */
-  add(point: Point.Point): PointSet {
-    const newSet = new Set(this.set);
-    newSet.add(pointHash.toString(point));
-    return new PointSet(newSet);
-  }
-
-  /** Remove the given point from the given set */
-  delete(point: Point.Point): PointSet {
-    const newSet = new Set(this.set);
-    if (!newSet.delete(pointHash.toString(point))) {
-      return this;
-    }
-    return new PointSet(newSet);
-  }
-
-  /** Returns a new PointSet with points common to the set and other */
-  difference(other: PointSet): PointSet {
-    let newSet = this as PointSet;
-    for (const point of other) {
-      newSet = newSet.delete(point);
-    }
-    return newSet;
-  }
-
-  /** Returns a new PointSet with all points in both sets */
-  union(other: PointSet): PointSet {
-    let newSet = this as PointSet;
-    for (const point of other) {
-      newSet = newSet.add(point);
-    }
-    return newSet;
-  }
-
-  /** Creates an iterator of points in the set */
-  *[Symbol.iterator](): Iterator<Point.Point> {
-    for (const value of this.set) {
-      yield pointHash.fromString(value);
-    }
-  }
-}
+import * as Point from '../point';
+import * as pointHash from './point-hash';
+
+/**
+ * Immutable Set like interface of points
+ */
+export class PointSet {
+  private constructor(private set: Set<string>) {}
+
+  /** Creates a new PointSet instance from an array-like or iterable object */
+  static from(points: Iterable<Point.Point>): PointSet {
+    const set = new Set<string>();
+    for (const point of points) {
+      set.add(pointHash.toString(point));
+    }
+    return new PointSet(set);
+  }
+
+  /** Returns a boolean asserting whether an point is present with the given value in the Set object or not */
+  has(point: Point.Point): boolean {
+    return this.set.has(pointHash.toString(point));
+  }
+
+  /** Returns the number of points in a PointSet object */
+  get size(): number {
+    return this.set.size;
+  }
+
+  /** Add the given point to given set */
+  add(point: Point.Point): PointSet {
+    const newSet = new Set(this.set);
+    newSet.add(pointHash.toString(point));
+    return new PointSet(newSet);
+  }
+
+  /** Remove the given point from the given set */
+  delete(point: Point.Point): PointSet {
+    const newSet = new Set(this.set);
+    if (!newSet.delete(pointHash.toString(point))) {
+      return this;
+    }
+    return new PointSet(newSet);
+  }
+
+  /** Returns a new PointSet with points common to the set and other */
+  difference(other: PointSet): PointSet {
+    let newSet = this as PointSet;
+    for (const point of other) {
+      newSet = newSet.delete(point);
+    }
+    return newSet;
+  }
+
+  /** Returns a new PointSet with all points in both sets */
+  union(other: PointSet): PointSet {
+    let newSet = this as PointSet;
+    for (const point of other) {
+      newSet = newSet.add(point);
+    }
+    return newSet;
+  }
+
+  /** Creates an iterator of points in the set */
+  *[Symbol.iterator](): Iterator<Point.Point> {
+    for (const value of this.set) {
+      yield pointHash.fromString(value);
+    }
+  }
+}

package/src/components/Excel/ExcelFile/ExcelFileComponents/index.ts

@@ -1,49 +1,49 @@
-import Spreadsheet from './Spreadsheet';
-import DataEditor from './DataEditor';
-import DataViewer from './DataViewer';
-
-export default Spreadsheet;
-export { Spreadsheet, DataEditor, DataViewer };
-export type { Props } from './Spreadsheet';
-export { createEmpty as createEmptyMatrix } from './matrix';
-export type { Matrix } from './matrix';
-export {
-  Selection,
-  EmptySelection,
-  EntireAxisSelection,
-  EntireColumnsSelection,
-  EntireRowsSelection,
-  EntireSelection,
-  EntireWorksheetSelection,
-  InvalidIndexError,
-  RangeSelection,
-} from './selection';
-export { PointRange } from './point-range';
-export type { Point } from './point';
-export type {
-  CellBase,
-  CellDescriptor,
-  Mode,
-  Dimensions,
-  CellChange,
-  CellComponentProps,
-  CellComponent,
-  DataViewerProps,
-  DataViewerComponent,
-  DataEditorProps,
-  DataEditorComponent,
-  ColumnIndicatorComponent,
-  ColumnIndicatorProps,
-  RowIndicatorComponent,
-  RowIndicatorProps,
-  CornerIndicatorComponent,
-  CornerIndicatorProps,
-  RowComponent,
-  RowProps,
-  TableComponent,
-  TableProps,
-  HeaderRowProps,
-  HeaderRowComponent,
-} from './types';
-
-export { createFormulaParser, Model } from './engine';
+import Spreadsheet from './Spreadsheet';
+import DataEditor from './DataEditor';
+import DataViewer from './DataViewer';
+
+export default Spreadsheet;
+export { Spreadsheet, DataEditor, DataViewer };
+export type { Props } from './Spreadsheet';
+export { createEmpty as createEmptyMatrix } from './matrix';
+export type { Matrix } from './matrix';
+export {
+  Selection,
+  EmptySelection,
+  EntireAxisSelection,
+  EntireColumnsSelection,
+  EntireRowsSelection,
+  EntireSelection,
+  EntireWorksheetSelection,
+  InvalidIndexError,
+  RangeSelection,
+} from './selection';
+export { PointRange } from './point-range';
+export type { Point } from './point';
+export type {
+  CellBase,
+  CellDescriptor,
+  Mode,
+  Dimensions,
+  CellChange,
+  CellComponentProps,
+  CellComponent,
+  DataViewerProps,
+  DataViewerComponent,
+  DataEditorProps,
+  DataEditorComponent,
+  ColumnIndicatorComponent,
+  ColumnIndicatorProps,
+  RowIndicatorComponent,
+  RowIndicatorProps,
+  CornerIndicatorComponent,
+  CornerIndicatorProps,
+  RowComponent,
+  RowProps,
+  TableComponent,
+  TableProps,
+  HeaderRowProps,
+  HeaderRowComponent,
+} from './types';
+
+export { createFormulaParser, Model } from './engine';