@infinite-table/infinite-react 0.5.1 → 0.5.2

package/src/utils/groupAndPivot/types.ts

@@ -1,10 +0,0 @@
-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

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

package/src/utils/mathIntersection.ts

@@ -1,21 +0,0 @@
-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

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

package/src/utils/minified.js

@@ -1,6 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,92 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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);
-  }
-}