@lotics/ui 2.6.1 → 3.0.0

package/src/grid/helpers.ts

@@ -1,205 +0,0 @@
-export function isNumberString(value: string): boolean {
-  if (isNaN(Number(value.trim()))) {
-    return false;
-  }
-
-  return true;
-}
-
-export function isObject(o: unknown): o is Record<string, unknown> {
-  if (typeof o === "object") {
-    return (
-      (o === null || Array.isArray(o) || typeof o == "function" || o.constructor === Date) === false
-    );
-  }
-
-  return false;
-}
-
-export function sum(numbers: number[]): number {
-  return numbers.reduce((previousValue, currentValue) => previousValue + currentValue, 0);
-}
-
-export function maxBy<T>(a: T[], getValue: (item: T) => number): number {
-  if (a.length === 0) {
-    return -Infinity;
-  }
-
-  let maxVal = getValue(a[0]);
-  for (let i = 1; i < a.length; i++) {
-    const val = getValue(a[i]);
-    if (val > maxVal) {
-      maxVal = val;
-    }
-  }
-  return maxVal;
-}
-
-export function sumBy<T>(a: T[], getValue: (item: T) => number): number {
-  let total = 0;
-  for (let i = 0; i < a.length; i++) {
-    total += getValue(a[i]);
-  }
-  return total;
-}
-
-export function max(...args: number[]): number {
-  return Math.max(...args);
-}
-
-export function min(...args: number[]): number {
-  return Math.min(...args);
-}
-
-export function isEqual(a: unknown, b: unknown): boolean {
-  if (a === b) {
-    return true;
-  }
-
-  if (isArray(a) && isArray(b)) {
-    return isArrayEqual(a, b);
-  }
-
-  if (isObject(a) && isObject(b)) {
-    return isObjectEqual(a, b);
-  }
-
-  return a !== a && b !== b;
-}
-
-function isArrayEqual<T>(a: T[], b: T[]): boolean {
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  for (let i = 0; i < a.length; i++) {
-    const itemA = a[i];
-    const itemB = b[i];
-
-    if (isEqual(itemA, itemB) === false) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function isObjectEqual(a: Record<string, unknown>, b: Record<string, unknown>): boolean {
-  if (a.constructor !== b.constructor) {
-    return false;
-  }
-
-  if (a.valueOf !== Object.prototype.valueOf) {
-    return a.valueOf() === b.valueOf();
-  }
-
-  if (a.toString !== Object.prototype.toString) {
-    return a.toString() === b.toString();
-  }
-
-  const keys = Object.keys(a);
-  const length = keys.length;
-  if (length !== Object.keys(b).length) {
-    return false;
-  }
-
-  for (let i = length; i-- !== 0; ) {
-    if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
-      return false;
-    }
-  }
-
-  for (let i = length; i-- !== 0; ) {
-    const key = keys[i];
-
-    const subA = a[key];
-    const subB = b[key];
-
-    if (!isEqual(subA, subB)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function isEmpty<T extends Record<string, unknown>>(data: T): boolean;
-export function isEmpty<T>(data: T[]): boolean;
-export function isEmpty(data: unknown[] | Record<string, unknown>): boolean {
-  if (isArray(data)) {
-    return data.length === 0;
-  }
-
-  return Object.keys(data).length === 0;
-}
-
-/**
- * Returns array of values found in left and right array.
- * Other values not intersected by, will be taken from left array.
- *
- * If `merge` is true, objects will be merged, with the objects from right array overriding the other array objects.
- */
-export function intersectBy<T, K>(
-  a: T[],
-  b: K[],
-  getValue: (item: T | K) => string | number,
-  merge = false,
-): T[] {
-  const bMap: { [key: string]: K } = {};
-
-  for (let i = 0; i < b.length; i++) {
-    const itemB = b[i];
-    const val = getValue(itemB);
-    bMap[val] = itemB;
-  }
-
-  const result: T[] = [];
-
-  for (let i = 0; i < a.length; i++) {
-    const itemA = a[i];
-    const val = getValue(itemA);
-    const itemB = bMap[val];
-
-    if (itemB !== undefined) {
-      if (merge) {
-        result.push({ ...itemA, ...itemB });
-      } else {
-        result.push(itemA);
-      }
-    }
-  }
-
-  return result;
-}
-
-/** Returns array of values in left array that are not in the right array */
-export function differenceBy<T, K>(
-  a: T[],
-  b: K[],
-  getValue: (item: T | K) => string | number,
-): T[] {
-  const bMap: { [key: string]: K } = {};
-
-  for (let i = 0; i < b.length; i++) {
-    const itemB = b[i];
-    const val = getValue(itemB);
-    bMap[val] = itemB;
-  }
-
-  const result: T[] = [];
-
-  for (let i = 0; i < a.length; i++) {
-    const itemA = a[i];
-    const val = getValue(itemA);
-
-    if (bMap[val] === undefined) {
-      result.push(itemA);
-    }
-  }
-
-  return result;
-}
-
-export function isArray<T>(arg: unknown): arg is T[] {
-  return Array.isArray(arg);
-}

package/src/grid/layout.test.ts

@@ -1,515 +0,0 @@
-import { getColumns, getRows, GridGroup, GridRow, GridColumn, groupPathToKey } from "./layout";
-
-test("getColumns - basic columns", () => {
-  const result = getColumns([100, 200, 100, 200, 100, 200]);
-
-  const expected: GridColumn[] = [
-    { column: 0, width: 100, x: 0 },
-    { column: 1, width: 200, x: 100 },
-    { column: 2, width: 100, x: 300 },
-    { column: 3, width: 200, x: 400 },
-    { column: 4, width: 100, x: 600 },
-    { column: 5, width: 200, x: 700 },
-  ];
-
-  expect(result).toEqual(expected);
-});
-
-test("getRows - single flat group", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "row_group",
-      rowCount: 2,
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, null);
-
-  const expected: GridRow[] = [
-    {
-      type: "row",
-      height: 40,
-      y: 0,
-      rowPath: [0, 0],
-    },
-    {
-      type: "row",
-      height: 40,
-      y: 40,
-      rowPath: [0, 1],
-    },
-  ];
-
-  expect(rows).toEqual(expected);
-});
-
-test("getRows - nested with leaf rows", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "group",
-      children: [
-        {
-          type: "row_group",
-          rowCount: 2,
-        },
-      ],
-    },
-    {
-      type: "group",
-      children: [
-        {
-          type: "row_group",
-          rowCount: 2,
-        },
-        {
-          type: "row_group",
-          rowCount: 2,
-        },
-      ],
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, null);
-
-  const expected: GridRow[] = [
-    {
-      type: "group_heading",
-      height: 40,
-      y: 0,
-      groupPath: [0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 40,
-      groupPath: [0],
-    },
-    {
-      type: "group_heading",
-      height: 40,
-      y: 80,
-      groupPath: [0, 0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 120,
-      groupPath: [0, 0],
-    },
-    {
-      type: "row",
-      height: 40,
-      y: 160,
-      rowPath: [0, 0, 0],
-    },
-    {
-      type: "row",
-      height: 40,
-      y: 200,
-      rowPath: [0, 0, 1],
-    },
-    { type: "spacer", height: 72, y: 240 },
-    {
-      type: "group_heading",
-      height: 40,
-      y: 312,
-      groupPath: [1],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 352,
-      groupPath: [1],
-    },
-    {
-      type: "group_heading",
-      height: 40,
-      y: 392,
-      groupPath: [1, 0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 432,
-      groupPath: [1, 0],
-    },
-    {
-      type: "row",
-      height: 40,
-      y: 472,
-      rowPath: [1, 0, 0],
-    },
-    {
-      type: "row",
-      height: 40,
-      y: 512,
-      rowPath: [1, 0, 1],
-    },
-    {
-      type: "group_heading",
-      height: 40,
-      y: 552,
-      groupPath: [1, 1],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 592,
-      groupPath: [1, 1],
-    },
-    {
-      type: "row",
-      height: 40,
-      y: 632,
-      rowPath: [1, 1, 0],
-    },
-    {
-      type: "row",
-      height: 40,
-      y: 672,
-      rowPath: [1, 1, 1],
-    },
-    { type: "spacer", height: 72, y: 712 },
-  ];
-
-  expect(rows).toEqual(expected);
-});
-
-test("getRows - nested with empty leaf rows", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "group",
-      children: [
-        {
-          type: "row_group",
-          rowCount: 0,
-        },
-      ],
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, null);
-
-  const expected: GridRow[] = [
-    {
-      type: "group_heading",
-      height: 40,
-      y: 0,
-      groupPath: [0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 40,
-      groupPath: [0],
-    },
-    {
-      type: "group_heading",
-      height: 40,
-      y: 80,
-      groupPath: [0, 0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 120,
-      groupPath: [0, 0],
-    },
-    { type: "spacer", height: 72, y: 160 },
-  ];
-
-  expect(rows).toEqual(expected);
-});
-
-test("getRows - nested with collapsed ancestor", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "group",
-      children: [
-        {
-          type: "row_group",
-          rowCount: 1,
-        },
-      ],
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, [groupPathToKey([0])]);
-
-  // Group summary is always shown even when collapsed
-  const expected: GridRow[] = [
-    {
-      type: "group_heading",
-      height: 40,
-      y: 0,
-      groupPath: [0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 40,
-      groupPath: [0],
-    },
-    { type: "spacer", height: 72, y: 80 },
-  ];
-
-  expect(rows).toEqual(expected);
-});
-
-test("getRows - nested collapsed child", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "group",
-      children: [
-        {
-          type: "row_group",
-          rowCount: 5,
-        },
-      ],
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, [groupPathToKey([0, 0])]);
-
-  // Group summary is always shown even when collapsed
-  const expected: GridRow[] = [
-    {
-      type: "group_heading",
-      height: 40,
-      y: 0,
-      groupPath: [0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 40,
-      groupPath: [0],
-    },
-    {
-      type: "group_heading",
-      height: 40,
-      y: 80,
-      groupPath: [0, 0],
-    },
-    {
-      type: "group_summary",
-      height: 40,
-      y: 120,
-      groupPath: [0, 0],
-    },
-    { type: "spacer", height: 72, y: 160 },
-  ];
-
-  expect(rows).toEqual(expected);
-});
-
-test("getColumns - with offset", () => {
-  const result = getColumns([100, 200, 100], 3);
-
-  const expected: GridColumn[] = [
-    { column: 3, width: 100, x: 0 },
-    { column: 4, width: 200, x: 100 },
-    { column: 5, width: 100, x: 300 },
-  ];
-
-  expect(result).toEqual(expected);
-});
-
-test("getColumns - empty columns", () => {
-  const result = getColumns([]);
-
-  expect(result).toEqual([]);
-});
-
-test("getColumns - single column", () => {
-  const result = getColumns([150]);
-
-  const expected: GridColumn[] = [{ column: 0, width: 150, x: 0 }];
-
-  expect(result).toEqual(expected);
-});
-
-test("getRows - multiple top-level groups", () => {
-  const groups: GridGroup[] = [
-    { type: "row_group", rowCount: 1 },
-    { type: "row_group", rowCount: 1 },
-    { type: "row_group", rowCount: 1 },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, null);
-
-  expect(rows).toHaveLength(12); // 3 headings + 3 summaries + 3 rows + 3 spacers
-  expect(rows.filter((r) => r.type === "group_heading")).toHaveLength(3);
-  expect(rows.filter((r) => r.type === "group_summary")).toHaveLength(3);
-  expect(rows.filter((r) => r.type === "row")).toHaveLength(3);
-  expect(rows.filter((r) => r.type === "spacer")).toHaveLength(3);
-});
-
-test("getRows - deeply nested groups", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "group",
-      children: [
-        {
-          type: "group",
-          children: [
-            {
-              type: "group",
-              children: [
-                {
-                  type: "row_group",
-                  rowCount: 1,
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, null);
-
-  const expected: GridRow[] = [
-    { type: "group_heading", height: 40, y: 0, groupPath: [0] },
-    { type: "group_summary", height: 40, y: 40, groupPath: [0] },
-    { type: "group_heading", height: 40, y: 80, groupPath: [0, 0] },
-    { type: "group_summary", height: 40, y: 120, groupPath: [0, 0] },
-    { type: "group_heading", height: 40, y: 160, groupPath: [0, 0, 0] },
-    { type: "group_summary", height: 40, y: 200, groupPath: [0, 0, 0] },
-    { type: "group_heading", height: 40, y: 240, groupPath: [0, 0, 0, 0] },
-    { type: "group_summary", height: 40, y: 280, groupPath: [0, 0, 0, 0] },
-    { type: "row", height: 40, y: 320, rowPath: [0, 0, 0, 0, 0] },
-    { type: "spacer", height: 72, y: 360 },
-  ];
-
-  expect(rows).toEqual(expected);
-});
-
-test("getRows - multiple collapsed groups", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "group",
-      children: [{ type: "row_group", rowCount: 2 }],
-    },
-    {
-      type: "group",
-      children: [{ type: "row_group", rowCount: 2 }],
-    },
-    {
-      type: "group",
-      children: [{ type: "row_group", rowCount: 2 }],
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, [groupPathToKey([0]), groupPathToKey([2])]);
-
-  // Groups 0 and 2 are collapsed, group 1 is expanded
-  // Group summary rows are always shown even when collapsed
-  expect(rows.filter((r) => r.type === "row")).toHaveLength(2); // Only from group 1
-  expect(rows.filter((r) => r.type === "group_heading")).toHaveLength(4); // [0], [1], [1,0], [2]
-  expect(rows.filter((r) => r.type === "group_summary")).toHaveLength(4); // [0], [1], [1,0], [2] (all groups have summaries)
-  expect(rows.filter((r) => r.type === "spacer")).toHaveLength(3);
-});
-
-test("getRows - empty groups array", () => {
-  const rows = getRows([], 40, 40, 40, 72, null);
-
-  expect(rows).toEqual([]);
-});
-
-test("getRows - default spacerHeight emits a spacer after each top-level group", () => {
-  const groups: GridGroup[] = [
-    { type: "row_group", rowCount: 1 },
-    { type: "row_group", rowCount: 1 },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 56, null);
-
-  const expected: GridRow[] = [
-    { type: "group_heading", height: 40, y: 0, groupPath: [0] },
-    { type: "group_summary", height: 40, y: 40, groupPath: [0] },
-    { type: "row", height: 40, y: 80, rowPath: [0, 0] },
-    { type: "spacer", height: 56, y: 120 },
-    { type: "group_heading", height: 40, y: 176, groupPath: [1] },
-    { type: "group_summary", height: 40, y: 216, groupPath: [1] },
-    { type: "row", height: 40, y: 256, rowPath: [1, 0] },
-    { type: "spacer", height: 56, y: 296 },
-  ];
-
-  expect(rows).toEqual(expected);
-});
-
-test("getRows - spacerHeight 0 emits no spacer descriptor", () => {
-  const groups: GridGroup[] = [
-    { type: "row_group", rowCount: 1 },
-    { type: "row_group", rowCount: 1 },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 0, null);
-
-  const expected: GridRow[] = [
-    { type: "group_heading", height: 40, y: 0, groupPath: [0] },
-    { type: "group_summary", height: 40, y: 40, groupPath: [0] },
-    { type: "row", height: 40, y: 80, rowPath: [0, 0] },
-    { type: "group_heading", height: 40, y: 120, groupPath: [1] },
-    { type: "group_summary", height: 40, y: 160, groupPath: [1] },
-    { type: "row", height: 40, y: 200, rowPath: [1, 0] },
-  ];
-
-  expect(rows).toEqual(expected);
-  expect(rows.some((r) => r.type === "spacer")).toBe(false);
-});
-
-test("getRows - spacerHeight 0 with collapsed, single, and zero groups", () => {
-  // Collapsed top-level group: heading + summary only, no spacer
-  const collapsed = getRows(
-    [{ type: "group", children: [{ type: "row_group", rowCount: 3 }] }],
-    40,
-    40,
-    40,
-    0,
-    [groupPathToKey([0])],
-  );
-  expect(collapsed).toEqual([
-    { type: "group_heading", height: 40, y: 0, groupPath: [0] },
-    { type: "group_summary", height: 40, y: 40, groupPath: [0] },
-  ]);
-
-  // Single top-level group: no trailing spacer
-  const single = getRows([{ type: "row_group", rowCount: 2 }], 40, 40, 40, 0, null);
-  expect(single).toEqual([
-    { type: "row", height: 40, y: 0, rowPath: [0, 0] },
-    { type: "row", height: 40, y: 40, rowPath: [0, 1] },
-  ]);
-
-  // Zero groups: empty layout
-  expect(getRows([], 40, 40, 40, 0, null)).toEqual([]);
-});
-
-test("getRows - collapsed parent hides all descendants", () => {
-  const groups: GridGroup[] = [
-    {
-      type: "group",
-      children: [
-        {
-          type: "group",
-          children: [
-            {
-              type: "row_group",
-              rowCount: 5,
-            },
-          ],
-        },
-      ],
-    },
-  ];
-
-  const rows = getRows(groups, 40, 40, 40, 72, [groupPathToKey([0])]);
-
-  // Top-level group heading, summary (always shown), and spacer should appear
-  expect(rows).toHaveLength(3);
-  expect(rows[0].type).toBe("group_heading");
-  expect(rows[1].type).toBe("group_summary");
-  expect(rows[2].type).toBe("spacer");
-});