pixel-react 1.10.15 → 1.10.16

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

@@ -1,153 +0,0 @@
-import * as Matrix from '../matrix';
-import { Point } from '../point';
-import { CellBase, CreateFormulaParser } from '../types';
-import * as Formula from './formula';
-import { PointGraph } from './point-graph';
-import { PointSet } from './point-set';
-
-export class Model<Cell extends CellBase> {
-  readonly data!: Matrix.Matrix<Cell>;
-  readonly evaluatedData!: Matrix.Matrix<Cell>;
-  readonly referenceGraph!: PointGraph;
-  readonly createFormulaParser!: CreateFormulaParser;
-
-  constructor(
-    createFormulaParser: CreateFormulaParser,
-    data: Matrix.Matrix<Cell>,
-    referenceGraph?: PointGraph,
-    evaluatedData?: Matrix.Matrix<Cell>
-  ) {
-    this.createFormulaParser = createFormulaParser;
-    this.data = data;
-    this.referenceGraph = referenceGraph || createReferenceGraph();
-    this.evaluatedData =
-      evaluatedData || createEvaluatedData(data, this.referenceGraph);
-  }
-}
-
-export function updateCellValue<Cell extends CellBase>(
-  model: Model<Cell>,
-  point: Point,
-  cell: Cell
-): Model<Cell> {
-  const nextData = Matrix.set(point, cell, model.data);
-  const nextReferenceGraph = Formula.isFormulaValue(cell.value)
-    ? updateReferenceGraph(model.referenceGraph)
-    : model.referenceGraph;
-
-  const nextEvaluatedData = evaluateCell(
-    model.evaluatedData,
-    nextData,
-    nextReferenceGraph,
-    point,
-    cell
-  );
-  return new Model(
-    model.createFormulaParser,
-    nextData,
-    nextReferenceGraph,
-    nextEvaluatedData
-  );
-}
-
-function updateReferenceGraph(referenceGraph: PointGraph): PointGraph {
-  return referenceGraph;
-}
-
-function evaluateCell<Cell extends CellBase>(
-  prevEvaluatedData: Matrix.Matrix<Cell>,
-  data: Matrix.Matrix<Cell>,
-  referenceGraph: PointGraph,
-  point: Point,
-  cell: Cell
-): Matrix.Matrix<Cell> {
-  if (referenceGraph.hasCircularDependency(point)) {
-    let visited = PointSet.from([point]);
-    let nextEvaluatedData = Matrix.set(
-      point,
-      { ...cell, value: 'TODO' }, // TODO For Formula Evaluation
-      prevEvaluatedData
-    );
-    for (const referrer of referenceGraph.getBackwardsRecursive(point)) {
-      if (visited.has(referrer)) {
-        break;
-      }
-      visited = visited.add(referrer);
-      const referrerCell = Matrix.get(referrer, data);
-      if (!referrerCell) {
-        continue;
-      }
-      nextEvaluatedData = Matrix.set(
-        referrer,
-        { ...referrerCell, value: 'TODO' }, // TODO For Formula Evaluation
-        nextEvaluatedData
-      );
-    }
-    return nextEvaluatedData;
-  }
-
-  let nextEvaluatedData = prevEvaluatedData;
-
-  const evaluatedValue = Formula.isFormulaValue(cell.value)
-    ? getFormulaComputedValue()
-    : cell.value;
-
-  const evaluatedCell = { ...cell, value: evaluatedValue };
-
-  nextEvaluatedData = Matrix.set(point, evaluatedCell, nextEvaluatedData);
-
-  // for every formula cell that references the cell re-evaluate (recursive)
-  for (const referrer of referenceGraph.getBackwardsRecursive(point)) {
-    const referrerCell = Matrix.get(referrer, data);
-    if (!referrerCell) {
-      continue;
-    }
-    const evaluatedValue = Formula.isFormulaValue(referrerCell.value)
-      ? getFormulaComputedValue()
-      : referrerCell.value;
-    const evaluatedCell = { ...referrerCell, value: evaluatedValue };
-    nextEvaluatedData = Matrix.set(referrer, evaluatedCell, nextEvaluatedData);
-  }
-
-  return nextEvaluatedData;
-}
-
-export function createReferenceGraph(): PointGraph {
-  const entries: Array<[Point, PointSet]> = [];
-
-  return PointGraph.from(entries);
-}
-
-export function createEvaluatedData<Cell extends CellBase>(
-  data: Matrix.Matrix<Cell>,
-  referenceGraph: PointGraph
-): Matrix.Matrix<Cell> {
-  let evaluatedData = data;
-
-  // Iterate over the points in the reference graph, starting from the leaves
-  for (const point of referenceGraph.traverseBFSBackwards()) {
-    // Get the cell at the current point in the data Matrix
-    const cell = Matrix.get(point, data);
-    if (!cell) {
-      continue;
-    }
-
-    // If the cell is a formula cell, evaluate it
-    if (Formula.isFormulaValue(cell.value)) {
-      const evaluatedValue = getFormulaComputedValue();
-      evaluatedData = Matrix.set(
-        point,
-        { ...cell, value: evaluatedValue },
-        evaluatedData
-      );
-    }
-  }
-
-  return evaluatedData;
-}
-
-/** Get the computed value of a formula cell */
-//TODO Function need to be Evaluate
-export function getFormulaComputedValue() {
-  return 'TODO'; // TODO For Formula Evaluation
-}

package/src/components/Excel/ExcelFile/ExcelFileComponents/engine/formula.ts

@@ -1,32 +0,0 @@
-import * as Matrix from '../matrix';
-import { CellBase } from '../types';
-
-export const FORMULA_VALUE_PREFIX = '=';
-
-/** Returns whether given value is a formula */
-export function isFormulaValue(value: unknown): value is string {
-  return (
-    typeof value === 'string' &&
-    value.startsWith(FORMULA_VALUE_PREFIX) &&
-    value.length > 1
-  );
-}
-
-/** Extracts formula from value  */
-export function extractFormula(value: string): string {
-  return value.slice(1);
-}
-
-export function createFormulaParser(
-  data: Matrix.Matrix<CellBase>,
-) {
-  return data
-}
-
-export function evaluate() {
-  try {
-    return "";
-  } catch (error) {
-    throw error;
-  }
-}

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

@@ -1,2 +0,0 @@
-export { Model, updateCellValue } from './engine';
-export { createFormulaParser } from './formula';

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

@@ -1,152 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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';