@infinite-table/infinite-react 0.4.13 → 0.5.1

package/src/utils/groupAndPivot/types.ts

@@ -0,0 +1,10 @@
+import { InfiniteTableGroupColumnBase } from '../../components/InfiniteTable/types';
+import { KeyOfNoSymbol } from '../../components/InfiniteTable/types/Utility';
+
+export type GroupKeyType<T extends any = any> = T; //string | number | symbol | null | undefined;
+
+export type GroupBy<DataType, KeyType> = {
+  field: KeyOfNoSymbol<DataType>;
+  toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+  column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
+};

package/src/utils/join.ts

@@ -0,0 +1,4 @@
+const join = (...args: (string | number | void | null)[]): string =>
+  args.filter((x) => !!`${x}`).join(' ');
+
+export { join };

package/src/utils/mathIntersection.ts

@@ -0,0 +1,21 @@
+export function arrayIntersection<T>(...arrays: T[][]): T[] {
+  if (!arrays.length) {
+    return [] as T[];
+  }
+  const map = new Map();
+  arrays.forEach((arr) => {
+    for (let i = 0, len = arr.length; i < len; i++) {
+      const item = arr[i];
+      const count = map.get(item) ?? 0;
+
+      map.set(item, count + 1);
+    }
+
+    return map;
+  });
+
+  const len = arrays.length;
+  return arrays[0].filter((x: T) => {
+    return map.get(x) === len;
+  });
+}

package/src/utils/minified.d.ts

@@ -0,0 +1,2 @@
+declare const minified: boolean;
+export default minified;

package/src/utils/minified.js

@@ -0,0 +1,6 @@
+function checkMinified(arg) {
+  /* this is a simple comment */
+}
+
+export default checkMinified.toString() !=
+  'function checkMinified(arg) { /* this is a simple comment */ }';

package/src/utils/multisort/index.ts

@@ -0,0 +1,151 @@
+import TYPES from './sortTypes';
+
+export type SortDir = 1 | -1;
+
+export type MultisortInfo<T> = {
+  /**
+   * The sorting direction
+   */
+  dir: SortDir;
+
+  /**
+   * for now 'string' and 'number' are known types, meaning they have
+   * sort functions already implemented
+   */
+  type?: string;
+
+  fn?: (a: any, b: any) => number;
+
+  /**
+   * a property whose value to use for sorting on the array items
+   */
+  field?: keyof T;
+
+  /**
+   * or a function to retrieve the item value to use for sorting
+   */
+  valueGetter?: (item: T) => any;
+};
+
+export type MultisortInfoAllowMultipleFields<T> = Omit<
+  MultisortInfo<T>,
+  'field'
+> & {
+  field?: keyof T | (keyof T)[];
+};
+
+export interface MultisortFn<T> {
+  (sortInfo: MultisortInfo<T>[], array: T[]): T[];
+  knownTypes: {
+    [key: string]: (first: T, second: T) => number;
+  };
+}
+
+export const multisort = <T>(
+  sortInfo: MultisortInfoAllowMultipleFields<T>[],
+  array: T[],
+  get?: (item: any) => T,
+): T[] => {
+  const plainSortInfo = sortInfo
+    .map((sortInfo) => {
+      if (Array.isArray(sortInfo.field)) {
+        return sortInfo.field.map((field) => {
+          return { ...sortInfo, field } as MultisortInfo<T>;
+        });
+      }
+
+      return sortInfo as MultisortInfo<T>;
+    })
+    .flat();
+
+  array.sort(getMultisortFunction<T>(plainSortInfo, get));
+
+  return array;
+};
+
+multisort.knownTypes = TYPES;
+
+const getSingleSortFunction = <T>(info: MultisortInfo<T>) => {
+  if (!info) {
+    return;
+  }
+
+  const field = info.field;
+  const valueGetter = info.valueGetter;
+  const dir = info.dir < 0 ? -1 : info.dir > 0 ? 1 : 0;
+
+  if (!dir) {
+    return;
+  }
+
+  let fn = info.fn;
+
+  if (!fn && info.type) {
+    fn = multisort.knownTypes[info.type];
+    if (!fn) {
+      console.warn(
+        `Unknown sort type "${info.type}" - please pass one of ${Object.keys(
+          multisort.knownTypes,
+        ).join(', ')}`,
+      );
+    }
+  }
+
+  if (!fn) {
+    fn = TYPES.string;
+  }
+
+  return (first: T, second: T) => {
+    const a = valueGetter ? valueGetter(first) : field ? first[field] : first;
+    const b = valueGetter
+      ? valueGetter(second)
+      : field
+      ? second[field]
+      : second;
+
+    return dir * fn!(a, b);
+  };
+};
+
+const getSortFunctions = <T>(sortInfo: MultisortInfo<T>[]) => {
+  return sortInfo
+    .map(getSingleSortFunction)
+    .filter((fn) => fn instanceof Function);
+};
+
+const getMultisortFunction = <T>(
+  sortInfo: MultisortInfo<T>[],
+  get?: (item: any) => T,
+) => {
+  const fns = getSortFunctions<T>(sortInfo);
+
+  return (first: T, second: T): number => {
+    if (get) {
+      first = get(first);
+      second = get(second);
+    }
+
+    let result = 0;
+    let i = 0;
+    let fn;
+
+    const len = fns.length;
+
+    for (; i < len; i++) {
+      fn = fns[i];
+      if (!fn) {
+        continue;
+      }
+
+      result = fn(first, second);
+
+      if (result !== 0) {
+        return result;
+      }
+    }
+
+    return result;
+  };
+};
+
+export { getMultisortFunction, getSortFunctions };

package/src/utils/multisort/sortTypes.ts

@@ -0,0 +1,25 @@
+export const numberComparator = function (
+  first: number,
+  second: number,
+): number {
+  return first - second;
+};
+
+export const stringComparator = function (
+  first: string,
+  second: string,
+): number {
+  first = `${first}`;
+  second = `${second}`;
+
+  return first.localeCompare(second);
+};
+
+export const defaultSortTypes: {
+  [key: string]: (first: any, second: any) => number;
+} = {
+  number: numberComparator,
+  string: stringComparator,
+};
+
+export default defaultSortTypes;

package/src/utils/notes-status.md

@@ -0,0 +1,92 @@
+# Row status:
+
+1. inspired by react-query?
+
+- https://react-query.tanstack.com/guides/queries
+- familiar for react devs
+
+2. HTTP status codes? https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+
+- too much?
+
+# Row vs Cell Status vs Column Status
+
+- should we support independent cell status or just derive from row status?
+- column status?
+- group status?
+
+# Error status
+
+- how to keep error info?
+  - per row: unnecessary overhead as most errors will be per row batch
+  - er batch: how to keep it in sync with the individual rows?
+
+# Retry/refetch info
+
+- do we even (intend to) support this?
+- if yes, do we want to keep track of it (ex. refetching, 3. try, etc)?
+
+# add statusin rowInfo object or in some state map?
+
+- support for:
+  - lazy loaded normal row
+  - lazy loaded group (children) rows
+
+// batched lazy loading
+
+// per batch
+RowInfo.ts:
+status: not_loaded
+directChildrenStatus: not_loaded
+allChildrenStatus: not_loaded
+
+    RowInfo.ts:
+        status: loading
+        directChildrenStatus: not_loaded
+        allChildrenStatus: not_loaded
+
+    RowInfo.ts:
+       status: available
+       directChildrenStatus: not_loaded
+       allChildrenStatus: not_loaded
+
+// stable viewport
+
+$$
+expand
+
+RowInfo.ts:
+   status: available
+   directChildrenStatus: loading
+   allChildrenStatus: not_loaded
+
+// stable viewport
+
+RowInfo.ts:
+   status: available
+   directChildrenStatus: available
+   allChildrenStatus: not_loaded
+
+    // 1. child Row Info
+   RowInfo.ts:
+       status: available
+       addDirectChildrenStatus: not_loaded
+       allChildrenStatus: not_loaded
+
+
+// type status =
+'available' |  // rowInfo.data !== null
+'loading' |    // status === 'loading'
+'not_loaded' | // rowInfo.data === null
+'error'        // rowInfo.errorInfo !== null
+
+Available status:
+   data available
+   all direct children data available
+   all children data available
+Loading status:
+
+
+$$
+
+// differentiate between no_data & loading_Data??

package/src/utils/pageGeometry/ConvexPoly.ts

@@ -0,0 +1,34 @@
+import { Point, PointCoords } from './Point';
+
+import { PolyWithPoints } from './PolyWithPoints';
+import { ArrayWithAtLeast3 } from './types';
+
+export class ConvexPoly extends PolyWithPoints {
+  points!: ArrayWithAtLeast3<Point>;
+
+  static clone(points: ArrayWithAtLeast3<PointCoords>) {
+    return new ConvexPoly(points);
+  }
+
+  constructor(points: ArrayWithAtLeast3<PointCoords>) {
+    super();
+    this.points = points.map(Point.clone) as ArrayWithAtLeast3<Point>;
+  }
+
+  getPoints() {
+    return this.points as ArrayWithAtLeast3<PointCoords>;
+  }
+
+  shift(
+    shiftOptions:
+      | { top: number }
+      | { top: number; left: number }
+      | { left: number },
+  ) {
+    this.points.forEach((p) => {
+      p.shift(shiftOptions);
+    });
+
+    return this;
+  }
+}

package/src/utils/pageGeometry/Point.ts

@@ -0,0 +1,51 @@
+export type PointCoords = {
+  top: number;
+  left: number;
+};
+export class Point {
+  top: PointCoords['top'] = 0;
+  left: PointCoords['left'] = 0;
+
+  static clone(point: PointCoords) {
+    return new Point(point);
+  }
+
+  static from(point: PointCoords) {
+    return new Point(point);
+  }
+
+  constructor(point: PointCoords) {
+    this.left = point.left;
+    this.top = point.top;
+  }
+
+  shift(
+    shiftOptions:
+      | { top: number }
+      | { top: number; left: number }
+      | { left: number },
+  ) {
+    if ((shiftOptions as { top: number }).top != null) {
+      this.top += (shiftOptions as { top: number }).top;
+    }
+    if ((shiftOptions as { left: number }).left != null) {
+      this.left += (shiftOptions as { left: number }).left;
+    }
+    return this;
+  }
+
+  getDistanceToPoint(point: PointCoords) {
+    const shiftTop = point.top - this.top;
+    const shiftLeft = point.left - this.left;
+
+    return {
+      top: shiftTop,
+      left: shiftLeft,
+    };
+  }
+}
+
+export const originPoint: PointCoords = {
+  left: 0,
+  top: 0,
+};

package/src/utils/pageGeometry/PolyWithPoints.ts

@@ -0,0 +1,52 @@
+import { PointCoords } from './Point';
+import { polyContainsPoint } from './polyContainsPoint';
+import { ArrayWithAtLeast3 } from './types';
+
+export abstract class PolyWithPoints {
+  abstract getPoints(): ArrayWithAtLeast3<PointCoords>;
+
+  abstract shift(
+    shiftOptions:
+      | { top: number }
+      | { top: number; left: number }
+      | { left: number },
+  ): PolyWithPoints;
+
+  containsPoint(point: PointCoords): boolean {
+    return polyContainsPoint(this.getPoints(), point);
+  }
+  contains(poly: PolyWithPoints): boolean {
+    const points = poly.getPoints();
+
+    for (let i = 0, len = points.length; i < len; i++) {
+      if (!this.containsPoint(points[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+  intersects(r: PolyWithPoints): boolean {
+    return this.privateIntersects(r, false);
+  }
+
+  privateIntersects(r: PolyWithPoints, skipOtherCheck: boolean): boolean {
+    const pointsOfR = r.getPoints();
+    for (let i = 0, len = pointsOfR.length; i < len; i++) {
+      if (this.containsPoint(pointsOfR[i])) {
+        return true;
+      }
+    }
+    if (skipOtherCheck) {
+      return false;
+    }
+    // there is another case, when we have 2 rectangles, r1, and r2
+    // and r2 is fully inside r1 - intersects should treat this case as well
+
+    // calling r2.intersects(r1) should return true
+    // but the above is not enough for this
+
+    // so we execute the reverse as well
+    return r.privateIntersects(this, true);
+  }
+}

package/src/utils/pageGeometry/Rectangle.ts

@@ -0,0 +1,98 @@
+import { ConvexPoly } from './ConvexPoly';
+import { Point, PointCoords } from './Point';
+import { PolyWithPoints } from './PolyWithPoints';
+
+type CoordsWithSize = {
+  width: number;
+  height: number;
+  left: number;
+  top: number;
+};
+type CoordsNoSize = {
+  right: number;
+  bottom: number;
+  left: number;
+  top: number;
+};
+
+export type RectangleCoords = CoordsWithSize | CoordsNoSize;
+export class Rectangle extends PolyWithPoints {
+  top: number = 0;
+  left: number = 0;
+
+  width: number = 0;
+  height: number = 0;
+
+  static fromDOMRect(rect: DOMRect) {
+    return new Rectangle(rect);
+  }
+
+  static clone(rect: DOMRect | Rectangle | RectangleCoords) {
+    return new Rectangle(rect);
+  }
+
+  static from(rect: DOMRect | Rectangle | RectangleCoords) {
+    return Rectangle.clone(rect);
+  }
+
+  constructor(coordsAndSize: RectangleCoords) {
+    super();
+    if (!coordsAndSize) {
+      debugger;
+    }
+    this.top = coordsAndSize.top;
+    this.left = coordsAndSize.left;
+
+    if (typeof (coordsAndSize as CoordsWithSize).width === 'number') {
+      this.width = (coordsAndSize as CoordsWithSize).width;
+      this.height = (coordsAndSize as CoordsWithSize).height;
+    } else {
+      this.width = (coordsAndSize as CoordsNoSize).right - coordsAndSize.left;
+      this.height = (coordsAndSize as CoordsNoSize).bottom - coordsAndSize.top;
+    }
+  }
+
+  containsPoint(p: PointCoords) {
+    return new ConvexPoly(this.getPoints()).containsPoint(p);
+  }
+
+  getTopLeft() {
+    return { left: this.left, top: this.top };
+  }
+
+  getTopRight() {
+    return { left: this.left + this.width, top: this.top };
+  }
+
+  getBottomLeft() {
+    return { left: this.left, top: this.top + this.height };
+  }
+
+  getBottomRight() {
+    return { left: this.left + this.width, top: this.top + this.height };
+  }
+
+  getPoints() {
+    return [
+      this.getTopLeft(),
+      this.getTopRight(),
+      this.getBottomLeft(),
+      this.getBottomRight(),
+    ].map(Point.from) as [Point, Point, Point, Point];
+  }
+
+  shift(
+    shiftOptions:
+      | { top: number }
+      | { top: number; left: number }
+      | { left: number },
+  ) {
+    if ((shiftOptions as { top: number }).top != null) {
+      this.top += (shiftOptions as { top: number }).top;
+    }
+    if ((shiftOptions as { left: number }).left != null) {
+      this.left += (shiftOptions as { left: number }).left;
+    }
+    return this;
+  }
+}

package/src/utils/pageGeometry/Triangle.ts

@@ -0,0 +1,16 @@
+import { ConvexPoly } from './ConvexPoly';
+import { PointCoords } from './Point';
+import { ArrayWith3 } from './types';
+
+type PointCoordsTimes3 = ArrayWith3<PointCoords>;
+
+export class Triangle extends ConvexPoly {
+  // uncommenting this here breaks our tests - WHAT????
+  // it's just narrowing down the type of the points member variable
+  // - this should not introduce any change in behavior!!! however, TS is crazy about this one
+  // points!: PointTimes3;
+
+  constructor(points: PointCoordsTimes3) {
+    super(points.slice(0, 3) as PointCoordsTimes3);
+  }
+}