react-native-gtkx 0.3.0-alpha.1 → 0.4.0-alpha.2

package/dist/dnd/grid-order.d.ts

@@ -0,0 +1,45 @@
+import type { GridDimensions, GridOrientation, GridPosition, GridPositions, SortableData } from "./types";
+export declare const calculateGridPosition: (index: number, dimensions: GridDimensions, orientation: GridOrientation) => GridPosition;
+export declare const calculateIndexFromRowColumn: (row: number, column: number, dimensions: GridDimensions, orientation: GridOrientation) => number;
+/** `["a", "b"]` → `{ a: {index: 0, ...}, b: {index: 1, ...} }`. Upstream's
+ *  takes objects with an `id`; both shapes are accepted so no call site has
+ *  to convert. */
+export declare const listToGridObject: <T extends SortableData>(list: readonly (string | T)[], dimensions: GridDimensions, orientation: GridOrientation) => GridPositions;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const getGridCellFromCoordinates: (x: number, y: number, dimensions: GridDimensions, orientation: GridOrientation, totalItems: number) => {
+    row: number;
+    column: number;
+    index: number;
+};
+/**
+ * Resolves a TRACKED cell rect (`grid.tsx`'s `useGridSortable`: the cell's
+ * own top-left, `calculateGridPosition(fromIndex, ...)` plus the pointer's
+ * delta since the drag began — never a measured layout) onto the nearest
+ * cell, ROUNDING rather than flooring both axes.
+ *
+ * The 2-D sibling of `resolveTrackedIndex` in `order.ts` — see its comment
+ * for why rounding this exact quantity is mathematically the same as
+ * resolving by the dragged cell's own CENTRE against each slot's centre,
+ * regardless of `columnGap`/`rowGap`, rather than `getGridCellFromCoordinates`'s
+ * OWN top-left floor above (upstream's own behaviour, kept faithfully there
+ * — this is a DIFFERENT function, the mirror's own live reorder trigger, not
+ * a replacement for it).
+ */
+export declare const resolveTrackedGridIndex: (trackedX: number, trackedY: number, dimensions: GridDimensions, orientation: GridOrientation, totalItems: number) => number;
+/** Every id shifts by one slot between the dragged item's old and new index
+ *  (`Insert` strategy) — the same "make room" reorder `Sortable`'s own
+ *  `objectMove` does for a plain list, generalised to row/column. */
+export declare const reorderGridInsert: (positions: GridPositions, activeId: string, targetIndex: number, dimensions: GridDimensions, orientation: GridOrientation) => GridPositions;
+/** Only the two cells trade places — nobody else moves. */
+export declare const reorderGridSwap: (positions: GridPositions, activeId: string, targetId: string, dimensions: GridDimensions, orientation: GridOrientation) => GridPositions;
+export declare const calculateGridContentDimensions: (itemsCount: number, dimensions: GridDimensions, orientation: GridOrientation) => {
+    width: number;
+    height: number;
+};
+export declare const findItemIdAtIndex: (positions: GridPositions, index: number) => string | null;
+/** `GridPositions` → an order array sorted by `.index`, which is the
+ *  representation `SortableGrid`/`useGridSortableList` actually keep as
+ *  React state (see order-state.ts) — deriving it back from a `GridPositions`
+ *  map is what lets a reorder decision go through `reorderGridInsert` /
+ *  `reorderGridSwap` unchanged rather than a second, hand-rolled splice. */
+export declare const gridPositionsToOrder: (positions: GridPositions) => string[];

package/dist/dnd/grid-order.js

@@ -0,0 +1,151 @@
+const GRID_ORIENTATION_HORIZONTAL = "horizontal";
+export const calculateGridPosition = (index, dimensions, orientation) => {
+    const { columns = 3, rows = 3, itemWidth, itemHeight, rowGap = 0, columnGap = 0, } = dimensions;
+    let row;
+    let column;
+    if (orientation === GRID_ORIENTATION_HORIZONTAL) {
+        column = Math.floor(index / rows);
+        row = index % rows;
+    }
+    else {
+        row = Math.floor(index / columns);
+        column = index % columns;
+    }
+    const x = column * (itemWidth + columnGap);
+    const y = row * (itemHeight + rowGap);
+    return { index, row, column, x, y };
+};
+export const calculateIndexFromRowColumn = (row, column, dimensions, orientation) => {
+    const { columns = 3, rows = 3 } = dimensions;
+    return orientation === GRID_ORIENTATION_HORIZONTAL
+        ? column * rows + row
+        : row * columns + column;
+};
+/** `["a", "b"]` → `{ a: {index: 0, ...}, b: {index: 1, ...} }`. Upstream's
+ *  takes objects with an `id`; both shapes are accepted so no call site has
+ *  to convert. */
+export const listToGridObject = (list, dimensions, orientation) => {
+    const positions = {};
+    list.forEach((item, index) => {
+        const id = typeof item === "string" ? item : item.id;
+        positions[id] = calculateGridPosition(index, dimensions, orientation);
+    });
+    return positions;
+};
+export const clamp = (value, min, max) => Math.max(min, Math.min(value, max));
+export const getGridCellFromCoordinates = (x, y, dimensions, orientation, totalItems) => {
+    const { itemWidth, itemHeight, rowGap = 0, columnGap = 0 } = dimensions;
+    const column = Math.floor(x / (itemWidth + columnGap));
+    const row = Math.floor(y / (itemHeight + rowGap));
+    const index = calculateIndexFromRowColumn(row, column, dimensions, orientation);
+    const clampedIndex = clamp(index, 0, totalItems - 1);
+    const clampedPosition = calculateGridPosition(clampedIndex, dimensions, orientation);
+    return {
+        row: clampedPosition.row,
+        column: clampedPosition.column,
+        index: clampedIndex,
+    };
+};
+/**
+ * Resolves a TRACKED cell rect (`grid.tsx`'s `useGridSortable`: the cell's
+ * own top-left, `calculateGridPosition(fromIndex, ...)` plus the pointer's
+ * delta since the drag began — never a measured layout) onto the nearest
+ * cell, ROUNDING rather than flooring both axes.
+ *
+ * The 2-D sibling of `resolveTrackedIndex` in `order.ts` — see its comment
+ * for why rounding this exact quantity is mathematically the same as
+ * resolving by the dragged cell's own CENTRE against each slot's centre,
+ * regardless of `columnGap`/`rowGap`, rather than `getGridCellFromCoordinates`'s
+ * OWN top-left floor above (upstream's own behaviour, kept faithfully there
+ * — this is a DIFFERENT function, the mirror's own live reorder trigger, not
+ * a replacement for it).
+ */
+export const resolveTrackedGridIndex = (trackedX, trackedY, dimensions, orientation, totalItems) => {
+    const { itemWidth, itemHeight, rowGap = 0, columnGap = 0 } = dimensions;
+    const column = Math.round(trackedX / (itemWidth + columnGap));
+    const row = Math.round(trackedY / (itemHeight + rowGap));
+    const index = calculateIndexFromRowColumn(row, column, dimensions, orientation);
+    return clamp(index, 0, totalItems - 1);
+};
+/** Every id shifts by one slot between the dragged item's old and new index
+ *  (`Insert` strategy) — the same "make room" reorder `Sortable`'s own
+ *  `objectMove` does for a plain list, generalised to row/column. */
+export const reorderGridInsert = (positions, activeId, targetIndex, dimensions, orientation) => {
+    const newPositions = {};
+    const activePosition = positions[activeId];
+    if (!activePosition) {
+        return positions;
+    }
+    const fromIndex = activePosition.index;
+    if (fromIndex === targetIndex) {
+        return positions;
+    }
+    const movingUp = targetIndex < fromIndex;
+    for (const id in positions) {
+        const currentIndex = positions[id].index;
+        if (id === activeId) {
+            newPositions[id] = calculateGridPosition(targetIndex, dimensions, orientation);
+        }
+        else if (movingUp &&
+            currentIndex >= targetIndex &&
+            currentIndex < fromIndex) {
+            newPositions[id] = calculateGridPosition(currentIndex + 1, dimensions, orientation);
+        }
+        else if (!movingUp &&
+            currentIndex <= targetIndex &&
+            currentIndex > fromIndex) {
+            newPositions[id] = calculateGridPosition(currentIndex - 1, dimensions, orientation);
+        }
+        else {
+            newPositions[id] = positions[id];
+        }
+    }
+    return newPositions;
+};
+/* eslint-disable @typescript-eslint/no-unused-vars --
+   `dimensions`/`orientation` keep `reorderGridSwap` the same shape as
+   `reorderGridInsert`, which needs both to recompute a shifted cell's
+   row/column — a straight swap of two existing `GridPosition` objects needs
+   no arithmetic at all. */
+/** Only the two cells trade places — nobody else moves. */
+export const reorderGridSwap = (positions, activeId, targetId, dimensions, orientation) => {
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    const activePosition = positions[activeId];
+    const targetPosition = positions[targetId];
+    if (!activePosition || !targetPosition) {
+        return positions;
+    }
+    return {
+        ...positions,
+        [activeId]: targetPosition,
+        [targetId]: activePosition,
+    };
+};
+export const calculateGridContentDimensions = (itemsCount, dimensions, orientation) => {
+    const { columns = 3, rows = 3, itemWidth, itemHeight, rowGap = 0, columnGap = 0, } = dimensions;
+    if (orientation === GRID_ORIENTATION_HORIZONTAL) {
+        const totalColumns = Math.ceil(itemsCount / rows);
+        const width = totalColumns * itemWidth + (totalColumns - 1) * columnGap;
+        const height = rows * itemHeight + (rows - 1) * rowGap;
+        return { width, height };
+    }
+    const totalRows = Math.ceil(itemsCount / columns);
+    const width = columns * itemWidth + (columns - 1) * columnGap;
+    const height = totalRows * itemHeight + (totalRows - 1) * rowGap;
+    return { width, height };
+};
+export const findItemIdAtIndex = (positions, index) => {
+    for (const id in positions) {
+        if (positions[id].index === index) {
+            return id;
+        }
+    }
+    return null;
+};
+/** `GridPositions` → an order array sorted by `.index`, which is the
+ *  representation `SortableGrid`/`useGridSortableList` actually keep as
+ *  React state (see order-state.ts) — deriving it back from a `GridPositions`
+ *  map is what lets a reorder decision go through `reorderGridInsert` /
+ *  `reorderGridSwap` unchanged rather than a second, hand-rolled splice. */
+export const gridPositionsToOrder = (positions) => Object.keys(positions).sort((left, right) => positions[left].index - positions[right].index);
+//# sourceMappingURL=grid-order.js.map

package/dist/dnd/grid-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-order.js","sourceRoot":"","sources":["../../src/dnd/grid-order.ts"],"names":[],"mappings":"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","sourcesContent":["// The grid arithmetic, ported from upstream's `utils/gridCalculations`\n// (worklets there, plain functions here — same reasoning as order.ts) and\n// kept free of every GTK import, so the unit test project can exercise it\n// without a display.\n//\n// `getGridCellFromCoordinates` FLOORS both axes onto the cell whose top-left\n// corner is at or before the point — that is upstream's own behaviour\n// (`Math.floor(x / (itemWidth + columnGap))`), not a bug this port fixes. A\n// point one pixel into a cell resolves to that cell, one pixel before it to\n// the previous one; there is no \"nearest\" rounding anywhere in the original.\nimport type {\n  GridDimensions,\n  GridOrientation,\n  GridPosition,\n  GridPositions,\n  SortableData,\n} from \"./types\"\n\nconst GRID_ORIENTATION_HORIZONTAL = \"horizontal\"\n\nexport const calculateGridPosition = (\n  index: number,\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n): GridPosition => {\n  const {\n    columns = 3,\n    rows = 3,\n    itemWidth,\n    itemHeight,\n    rowGap = 0,\n    columnGap = 0,\n  } = dimensions\n  let row: number\n  let column: number\n  if ((orientation as string) === GRID_ORIENTATION_HORIZONTAL) {\n    column = Math.floor(index / rows)\n    row = index % rows\n  } else {\n    row = Math.floor(index / columns)\n    column = index % columns\n  }\n  const x = column * (itemWidth + columnGap)\n  const y = row * (itemHeight + rowGap)\n  return { index, row, column, x, y }\n}\n\nexport const calculateIndexFromRowColumn = (\n  row: number,\n  column: number,\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n): number => {\n  const { columns = 3, rows = 3 } = dimensions\n  return (orientation as string) === GRID_ORIENTATION_HORIZONTAL\n    ? column * rows + row\n    : row * columns + column\n}\n\n/** `[\"a\", \"b\"]` → `{ a: {index: 0, ...}, b: {index: 1, ...} }`. Upstream's\n *  takes objects with an `id`; both shapes are accepted so no call site has\n *  to convert. */\nexport const listToGridObject = <T extends SortableData>(\n  list: readonly (string | T)[],\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n): GridPositions => {\n  const positions: GridPositions = {}\n  list.forEach((item, index) => {\n    const id = typeof item === \"string\" ? item : item.id\n    positions[id] = calculateGridPosition(index, dimensions, orientation)\n  })\n  return positions\n}\n\nexport const clamp = (value: number, min: number, max: number): number =>\n  Math.max(min, Math.min(value, max))\n\nexport const getGridCellFromCoordinates = (\n  x: number,\n  y: number,\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n  totalItems: number,\n): { row: number; column: number; index: number } => {\n  const { itemWidth, itemHeight, rowGap = 0, columnGap = 0 } = dimensions\n  const column = Math.floor(x / (itemWidth + columnGap))\n  const row = Math.floor(y / (itemHeight + rowGap))\n  const index = calculateIndexFromRowColumn(\n    row,\n    column,\n    dimensions,\n    orientation,\n  )\n  const clampedIndex = clamp(index, 0, totalItems - 1)\n  const clampedPosition = calculateGridPosition(\n    clampedIndex,\n    dimensions,\n    orientation,\n  )\n  return {\n    row: clampedPosition.row,\n    column: clampedPosition.column,\n    index: clampedIndex,\n  }\n}\n\n/**\n * Resolves a TRACKED cell rect (`grid.tsx`'s `useGridSortable`: the cell's\n * own top-left, `calculateGridPosition(fromIndex, ...)` plus the pointer's\n * delta since the drag began — never a measured layout) onto the nearest\n * cell, ROUNDING rather than flooring both axes.\n *\n * The 2-D sibling of `resolveTrackedIndex` in `order.ts` — see its comment\n * for why rounding this exact quantity is mathematically the same as\n * resolving by the dragged cell's own CENTRE against each slot's centre,\n * regardless of `columnGap`/`rowGap`, rather than `getGridCellFromCoordinates`'s\n * OWN top-left floor above (upstream's own behaviour, kept faithfully there\n * — this is a DIFFERENT function, the mirror's own live reorder trigger, not\n * a replacement for it).\n */\nexport const resolveTrackedGridIndex = (\n  trackedX: number,\n  trackedY: number,\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n  totalItems: number,\n): number => {\n  const { itemWidth, itemHeight, rowGap = 0, columnGap = 0 } = dimensions\n  const column = Math.round(trackedX / (itemWidth + columnGap))\n  const row = Math.round(trackedY / (itemHeight + rowGap))\n  const index = calculateIndexFromRowColumn(\n    row,\n    column,\n    dimensions,\n    orientation,\n  )\n  return clamp(index, 0, totalItems - 1)\n}\n\n/** Every id shifts by one slot between the dragged item's old and new index\n *  (`Insert` strategy) — the same \"make room\" reorder `Sortable`'s own\n *  `objectMove` does for a plain list, generalised to row/column. */\nexport const reorderGridInsert = (\n  positions: GridPositions,\n  activeId: string,\n  targetIndex: number,\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n): GridPositions => {\n  const newPositions: GridPositions = {}\n  const activePosition = positions[activeId]\n  if (!activePosition) {\n    return positions\n  }\n  const fromIndex = activePosition.index\n  if (fromIndex === targetIndex) {\n    return positions\n  }\n  const movingUp = targetIndex < fromIndex\n  for (const id in positions) {\n    const currentIndex = positions[id]!.index\n    if (id === activeId) {\n      newPositions[id] = calculateGridPosition(\n        targetIndex,\n        dimensions,\n        orientation,\n      )\n    } else if (\n      movingUp &&\n      currentIndex >= targetIndex &&\n      currentIndex < fromIndex\n    ) {\n      newPositions[id] = calculateGridPosition(\n        currentIndex + 1,\n        dimensions,\n        orientation,\n      )\n    } else if (\n      !movingUp &&\n      currentIndex <= targetIndex &&\n      currentIndex > fromIndex\n    ) {\n      newPositions[id] = calculateGridPosition(\n        currentIndex - 1,\n        dimensions,\n        orientation,\n      )\n    } else {\n      newPositions[id] = positions[id]!\n    }\n  }\n  return newPositions\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars --\n   `dimensions`/`orientation` keep `reorderGridSwap` the same shape as\n   `reorderGridInsert`, which needs both to recompute a shifted cell's\n   row/column — a straight swap of two existing `GridPosition` objects needs\n   no arithmetic at all. */\n/** Only the two cells trade places — nobody else moves. */\nexport const reorderGridSwap = (\n  positions: GridPositions,\n  activeId: string,\n  targetId: string,\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n): GridPositions => {\n  /* eslint-enable @typescript-eslint/no-unused-vars */\n  const activePosition = positions[activeId]\n  const targetPosition = positions[targetId]\n  if (!activePosition || !targetPosition) {\n    return positions\n  }\n  return {\n    ...positions,\n    [activeId]: targetPosition,\n    [targetId]: activePosition,\n  }\n}\n\nexport const calculateGridContentDimensions = (\n  itemsCount: number,\n  dimensions: GridDimensions,\n  orientation: GridOrientation,\n): { width: number; height: number } => {\n  const {\n    columns = 3,\n    rows = 3,\n    itemWidth,\n    itemHeight,\n    rowGap = 0,\n    columnGap = 0,\n  } = dimensions\n  if ((orientation as string) === GRID_ORIENTATION_HORIZONTAL) {\n    const totalColumns = Math.ceil(itemsCount / rows)\n    const width = totalColumns * itemWidth + (totalColumns - 1) * columnGap\n    const height = rows * itemHeight + (rows - 1) * rowGap\n    return { width, height }\n  }\n  const totalRows = Math.ceil(itemsCount / columns)\n  const width = columns * itemWidth + (columns - 1) * columnGap\n  const height = totalRows * itemHeight + (totalRows - 1) * rowGap\n  return { width, height }\n}\n\nexport const findItemIdAtIndex = (\n  positions: GridPositions,\n  index: number,\n): string | null => {\n  for (const id in positions) {\n    if (positions[id]!.index === index) {\n      return id\n    }\n  }\n  return null\n}\n\n/** `GridPositions` → an order array sorted by `.index`, which is the\n *  representation `SortableGrid`/`useGridSortableList` actually keep as\n *  React state (see order-state.ts) — deriving it back from a `GridPositions`\n *  map is what lets a reorder decision go through `reorderGridInsert` /\n *  `reorderGridSwap` unchanged rather than a second, hand-rolled splice. */\nexport const gridPositionsToOrder = (positions: GridPositions): string[] =>\n  Object.keys(positions).sort(\n    (left, right) => positions[left]!.index - positions[right]!.index,\n  )\n"]}

package/dist/dnd/grid.d.ts

@@ -0,0 +1,44 @@
+import { type ReactNode } from "react";
+import { type SortableData, type SortableGridItemProps, type SortableGridProps, type UseGridSortableListOptions, type UseGridSortableListReturn, type UseGridSortableOptions, type UseGridSortableReturn } from "./types";
+export { calculateGridContentDimensions, calculateGridPosition, calculateIndexFromRowColumn, findItemIdAtIndex, getGridCellFromCoordinates, listToGridObject, reorderGridInsert, reorderGridSwap, } from "./grid-order";
+/**
+ * Owns the order of a sortable grid, for an app rendering its own container —
+ * the grid's counterpart of `useSortableList`. **The order half only**, same
+ * contract: rows still need to sit inside a `SortableGrid` for the drag
+ * wiring, which travels through context. No autoscroll wiring either, for
+ * the same reason `useSortableList` has none — this hook builds no
+ * `ScrollView` of its own.
+ */
+export declare const useGridSortableList: <TData extends SortableData>(options: UseGridSortableListOptions<TData>) => UseGridSortableListReturn<TData>;
+/**
+ * A grid whose cells reorder by dragging.
+ *
+ * ```tsx
+ * <SortableGrid
+ *   data={photos}
+ *   dimensions={{ columns: 3, itemWidth: 100, itemHeight: 100, columnGap: 8, rowGap: 8 }}
+ *   renderItem={({ item, id, ...rest }) => (
+ *     <SortableGridItem key={id} id={id} data={item} {...rest}>
+ *       <Image source={{ uri: item.uri }} style={{ flex: 1 }} />
+ *     </SortableGridItem>
+ *   )}
+ * />
+ * ```
+ *
+ * No list-level `onMove`/`onDragStart`/`onDrop`/`onDragging` — same as
+ * upstream's own `SortableGridProps`, which carries none either; wire them on
+ * each `SortableGridItem` instead.
+ */
+export declare const SortableGrid: <TData extends SortableData>({ data, renderItem, dimensions, orientation, strategy, style, contentContainerStyle, itemKeyExtractor, testID, }: SortableGridProps<TData>) => ReactNode;
+/**
+ * The reorder half of the module, as a hook, for a cell that owns its own
+ * view.
+ */
+export declare const useGridSortable: <TData>(options: UseGridSortableOptions<TData>) => UseGridSortableReturn;
+/** One cell of a {@link SortableGrid}. Both a drag source and a drop target:
+ *  the cell you drag onto is the position the dragged cell takes (or trades
+ *  with, under `GridStrategy.Swap`). */
+export declare const SortableGridItem: {
+    <TData>({ id, data, dimensions, children, style, animatedStyle, testID, onMove, onDragStart, onDrop, onDragging, }: SortableGridItemProps<TData>): ReactNode;
+    Handle: ({ children, style, testID, }: import("./types").DraggableHandleProps) => ReactNode;
+};