@medusajs/loyalty-plugin 0.0.1

package/.medusa/server/src/admin/components/data-grid/hooks/use-data-grid-navigation.js

@@ -0,0 +1,81 @@
+import { useCallback } from "react";
+const useDataGridNavigation = ({
+  matrix,
+  anchor,
+  visibleColumns,
+  visibleRows,
+  columnVirtualizer,
+  rowVirtualizer,
+  setColumnVisibility,
+  flatColumns,
+  queryTool,
+  setSingleRange
+}) => {
+  const scrollToCoordinates = useCallback(
+    (coords, direction) => {
+      if (!anchor) {
+        return;
+      }
+      const { row, col } = coords;
+      const { row: anchorRow, col: anchorCol } = anchor;
+      const rowDirection = row >= anchorRow ? "down" : "up";
+      const colDirection = col >= anchorCol ? "right" : "left";
+      let toRow = rowDirection === "down" ? row + 1 : row - 1;
+      if (visibleRows[toRow] === void 0) {
+        toRow = row;
+      }
+      let toCol = colDirection === "right" ? col + 1 : col - 1;
+      if (visibleColumns[toCol] === void 0) {
+        toCol = col;
+      }
+      const scrollOptions = { align: "auto", behavior: "auto" };
+      if (direction === "horizontal" || direction === "both") {
+        columnVirtualizer.scrollToIndex(toCol, scrollOptions);
+      }
+      if (direction === "vertical" || direction === "both") {
+        rowVirtualizer.scrollToIndex(toRow, scrollOptions);
+      }
+    },
+    [anchor, columnVirtualizer, visibleRows, rowVirtualizer, visibleColumns]
+  );
+  const navigateToField = useCallback(
+    (field) => {
+      const coords = matrix.getCoordinatesByField(field);
+      if (!coords) {
+        return;
+      }
+      const column = flatColumns[coords.col];
+      setColumnVisibility((prev) => {
+        return {
+          ...prev,
+          [column.id]: true
+        };
+      });
+      requestAnimationFrame(() => {
+        scrollToCoordinates(coords, "both");
+        setSingleRange(coords);
+      });
+      requestAnimationFrame(() => {
+        const input = queryTool == null ? void 0 : queryTool.getInput(coords);
+        if (input) {
+          input.focus();
+        }
+      });
+    },
+    [
+      matrix,
+      flatColumns,
+      setColumnVisibility,
+      scrollToCoordinates,
+      setSingleRange,
+      queryTool
+    ]
+  );
+  return {
+    scrollToCoordinates,
+    navigateToField
+  };
+};
+export {
+  useDataGridNavigation
+};

package/.medusa/server/src/admin/components/data-grid/hooks/use-data-grid-query-tool.js

@@ -0,0 +1,14 @@
+import { useRef, useEffect } from "react";
+import { DataGridQueryTool } from "../models/data-grid-query-tool.js";
+const useDataGridQueryTool = (containerRef) => {
+  const queryToolRef = useRef(null);
+  useEffect(() => {
+    if (containerRef.current) {
+      queryToolRef.current = new DataGridQueryTool(containerRef.current);
+    }
+  }, [containerRef]);
+  return queryToolRef.current;
+};
+export {
+  useDataGridQueryTool
+};

package/.medusa/server/src/admin/components/data-grid/index.js

@@ -0,0 +1,8 @@
+import { DataGrid } from "./data-grid.js";
+import { createDataGridHelper } from "./helpers/create-data-grid-column-helper.js";
+import { createDataGridPriceColumns } from "./helpers/create-data-grid-price-columns.js";
+export {
+  DataGrid,
+  createDataGridHelper,
+  createDataGridPriceColumns
+};

package/.medusa/server/src/admin/components/data-grid/models/data-grid-bulk-update-command.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class DataGridBulkUpdateCommand {
+  constructor({ fields, prev, next, setter }) {
+    __publicField(this, "_fields");
+    __publicField(this, "_prev");
+    __publicField(this, "_next");
+    __publicField(this, "_setter");
+    this._fields = fields;
+    this._prev = prev;
+    this._next = next;
+    this._setter = setter;
+  }
+  execute(redo = false) {
+    this._setter(this._fields, this._next, redo);
+  }
+  undo() {
+    this._setter(this._fields, this._prev, true);
+  }
+  redo() {
+    this.execute(true);
+  }
+}
+export {
+  DataGridBulkUpdateCommand
+};

package/.medusa/server/src/admin/components/data-grid/models/data-grid-matrix.js

@@ -0,0 +1,296 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class DataGridMatrix {
+  constructor(data, columns, multiColumnSelection = false) {
+    __publicField(this, "multiColumnSelection");
+    __publicField(this, "cells");
+    __publicField(this, "rowAccessors", []);
+    __publicField(this, "columnAccessors", []);
+    this.multiColumnSelection = multiColumnSelection;
+    this.cells = this._populateCells(data, columns);
+    this.rowAccessors = this._computeRowAccessors();
+    this.columnAccessors = this._computeColumnAccessors();
+  }
+  _computeRowAccessors() {
+    return this.cells.map((_, rowIndex) => this.getRowAccessor(rowIndex));
+  }
+  _computeColumnAccessors() {
+    if (this.cells.length === 0) {
+      return [];
+    }
+    return this.cells[0].map((_, colIndex) => this.getColumnAccessor(colIndex));
+  }
+  getFirstNavigableCell() {
+    for (let row = 0; row < this.cells.length; row++) {
+      for (let col = 0; col < this.cells[0].length; col++) {
+        if (this.cells[row][col] !== null) {
+          return { row, col };
+        }
+      }
+    }
+    return null;
+  }
+  getFieldsInRow(row) {
+    const keys = [];
+    if (row < 0 || row >= this.cells.length) {
+      return keys;
+    }
+    this.cells[row].forEach((cell) => {
+      if (cell !== null) {
+        keys.push(cell.field);
+      }
+    });
+    return keys;
+  }
+  getFieldsInSelection(start, end) {
+    var _a;
+    const keys = [];
+    if (!start || !end) {
+      return keys;
+    }
+    if (!this.multiColumnSelection && start.col !== end.col) {
+      throw new Error(
+        "Selection must be in the same column when multiColumnSelection is disabled"
+      );
+    }
+    const startRow = Math.min(start.row, end.row);
+    const endRow = Math.max(start.row, end.row);
+    const startCol = this.multiColumnSelection ? Math.min(start.col, end.col) : start.col;
+    const endCol = this.multiColumnSelection ? Math.max(start.col, end.col) : start.col;
+    for (let row = startRow; row <= endRow; row++) {
+      for (let col = startCol; col <= endCol; col++) {
+        if (this._isValidPosition(row, col) && this.cells[row][col] !== null) {
+          keys.push((_a = this.cells[row][col]) == null ? void 0 : _a.field);
+        }
+      }
+    }
+    return keys;
+  }
+  getCellField(cell) {
+    var _a;
+    if (this._isValidPosition(cell.row, cell.col)) {
+      return ((_a = this.cells[cell.row][cell.col]) == null ? void 0 : _a.field) || null;
+    }
+    return null;
+  }
+  getCellType(cell) {
+    var _a;
+    if (this._isValidPosition(cell.row, cell.col)) {
+      return ((_a = this.cells[cell.row][cell.col]) == null ? void 0 : _a.type) || null;
+    }
+    return null;
+  }
+  getIsCellSelected(cell, start, end) {
+    if (!cell || !start || !end) {
+      return false;
+    }
+    if (!this.multiColumnSelection && start.col !== end.col) {
+      throw new Error(
+        "Selection must be in the same column when multiColumnSelection is disabled"
+      );
+    }
+    const startRow = Math.min(start.row, end.row);
+    const endRow = Math.max(start.row, end.row);
+    const startCol = this.multiColumnSelection ? Math.min(start.col, end.col) : start.col;
+    const endCol = this.multiColumnSelection ? Math.max(start.col, end.col) : start.col;
+    return cell.row >= startRow && cell.row <= endRow && cell.col >= startCol && cell.col <= endCol;
+  }
+  toggleColumn(col, enabled) {
+    if (col < 0 || col >= this.cells[0].length) {
+      return;
+    }
+    this.cells.forEach((row, index) => {
+      const cell = row[col];
+      if (cell) {
+        this.cells[index][col] = {
+          ...cell,
+          enabled
+        };
+      }
+    });
+  }
+  toggleRow(row, enabled) {
+    if (row < 0 || row >= this.cells.length) {
+      return;
+    }
+    this.cells[row].forEach((cell, index) => {
+      if (cell) {
+        this.cells[row][index] = {
+          ...cell,
+          enabled
+        };
+      }
+    });
+  }
+  getCoordinatesByField(field) {
+    if (this.rowAccessors.length === 1) {
+      const col = this.columnAccessors.indexOf(field);
+      if (col === -1) {
+        return null;
+      }
+      return { row: 0, col };
+    }
+    for (let row = 0; row < this.rowAccessors.length; row++) {
+      const rowAccessor = this.rowAccessors[row];
+      if (rowAccessor === null) {
+        continue;
+      }
+      if (!field.startsWith(rowAccessor)) {
+        continue;
+      }
+      for (let column = 0; column < this.columnAccessors.length; column++) {
+        const columnAccessor = this.columnAccessors[column];
+        if (columnAccessor === null) {
+          continue;
+        }
+        const fullFieldPath = `${rowAccessor}.${columnAccessor}`;
+        if (fullFieldPath === field) {
+          return { row, col: column };
+        }
+      }
+    }
+    return null;
+  }
+  getRowAccessor(row) {
+    if (row < 0 || row >= this.cells.length) {
+      return null;
+    }
+    const cells = this.cells[row];
+    const nonNullFields = cells.filter((cell) => cell !== null).map((cell) => cell.field.split("."));
+    if (nonNullFields.length === 0) {
+      return null;
+    }
+    let commonParts = nonNullFields[0];
+    for (const segments of nonNullFields) {
+      commonParts = commonParts.filter(
+        (part, index) => segments[index] === part
+      );
+      if (commonParts.length === 0) {
+        break;
+      }
+    }
+    const accessor = commonParts.join(".");
+    if (!accessor) {
+      return null;
+    }
+    return accessor;
+  }
+  getColumnAccessor(column) {
+    if (column < 0 || column >= this.cells[0].length) {
+      return null;
+    }
+    const uniqueParts = this.cells.map((row, rowIndex) => {
+      const cell = row[column];
+      if (!cell) {
+        return null;
+      }
+      const rowAccessor = this.getRowAccessor(rowIndex);
+      if (rowAccessor && cell.field.startsWith(rowAccessor + ".")) {
+        return cell.field.slice(rowAccessor.length + 1);
+      }
+      return null;
+    }).filter((part) => part !== null);
+    if (uniqueParts.length === 0) {
+      return null;
+    }
+    const firstPart = uniqueParts[0];
+    const isConsistent = uniqueParts.every((part) => part === firstPart);
+    return isConsistent ? firstPart : null;
+  }
+  getValidMovement(row, col, direction, metaKey = false) {
+    var _a;
+    const [dRow, dCol] = this._getDirectionDeltas(direction);
+    if (metaKey) {
+      return this._getLastValidCellInDirection(row, col, dRow, dCol);
+    } else {
+      let newRow = row + dRow;
+      let newCol = col + dCol;
+      while (this._isValidPosition(newRow, newCol)) {
+        if (this.cells[newRow][newCol] !== null && ((_a = this.cells[newRow][newCol]) == null ? void 0 : _a.enabled) !== false) {
+          return { row: newRow, col: newCol };
+        }
+        newRow += dRow;
+        newCol += dCol;
+      }
+      return { row, col };
+    }
+  }
+  _isValidPosition(row, col, cells) {
+    if (!cells) {
+      cells = this.cells;
+    }
+    return row >= 0 && row < cells.length && col >= 0 && col < cells[0].length;
+  }
+  _getDirectionDeltas(direction) {
+    switch (direction) {
+      case "ArrowUp":
+        return [-1, 0];
+      case "ArrowDown":
+        return [1, 0];
+      case "ArrowLeft":
+        return [0, -1];
+      case "ArrowRight":
+        return [0, 1];
+      default:
+        return [0, 0];
+    }
+  }
+  _getLastValidCellInDirection(row, col, dRow, dCol) {
+    let newRow = row;
+    let newCol = col;
+    let lastValidRow = row;
+    let lastValidCol = col;
+    while (this._isValidPosition(newRow + dRow, newCol + dCol)) {
+      newRow += dRow;
+      newCol += dCol;
+      if (this.cells[newRow][newCol] !== null) {
+        lastValidRow = newRow;
+        lastValidCol = newCol;
+      }
+    }
+    return {
+      row: lastValidRow,
+      col: lastValidCol
+    };
+  }
+  _populateCells(rows, columns) {
+    const cells = Array.from(
+      { length: rows.length },
+      () => Array(columns.length).fill(null)
+    );
+    rows.forEach((row, rowIndex) => {
+      columns.forEach((column, colIndex) => {
+        if (!this._isValidPosition(rowIndex, colIndex, cells)) {
+          return;
+        }
+        const {
+          name: _,
+          field,
+          type,
+          ...rest
+        } = column.meta;
+        const context = {
+          row,
+          column: {
+            ...column,
+            meta: rest
+          }
+        };
+        const fieldValue = field ? field(context) : null;
+        if (!fieldValue || !type) {
+          return;
+        }
+        cells[rowIndex][colIndex] = {
+          field: fieldValue,
+          type,
+          enabled: true
+        };
+      });
+    });
+    return cells;
+  }
+}
+export {
+  DataGridMatrix
+};

package/.medusa/server/src/admin/components/data-grid/models/data-grid-query-tool.js

@@ -0,0 +1,62 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { generateCellId } from "../utils.js";
+class DataGridQueryTool {
+  constructor(container) {
+    __publicField(this, "container");
+    this.container = container;
+  }
+  getInput(cell) {
+    var _a;
+    const id = this._getCellId(cell);
+    const input = (_a = this.container) == null ? void 0 : _a.querySelector(`[data-cell-id="${id}"]`);
+    if (!input) {
+      return null;
+    }
+    return input;
+  }
+  getInputByField(field) {
+    var _a;
+    const input = (_a = this.container) == null ? void 0 : _a.querySelector(`[data-field="${field}"]`);
+    if (!input) {
+      return null;
+    }
+    return input;
+  }
+  getCoordinatesByField(field) {
+    var _a;
+    const cell = (_a = this.container) == null ? void 0 : _a.querySelector(
+      `[data-field="${field}"][data-cell-id]`
+    );
+    if (!cell) {
+      return null;
+    }
+    const cellId = cell.getAttribute("data-cell-id");
+    if (!cellId) {
+      return null;
+    }
+    const [row, col] = cellId.split(":").map((n) => parseInt(n, 10));
+    if (isNaN(row) || isNaN(col)) {
+      return null;
+    }
+    return { row, col };
+  }
+  getContainer(cell) {
+    var _a;
+    const id = this._getCellId(cell);
+    const container = (_a = this.container) == null ? void 0 : _a.querySelector(
+      `[data-container-id="${id}"]`
+    );
+    if (!container) {
+      return null;
+    }
+    return container;
+  }
+  _getCellId(cell) {
+    return generateCellId(cell);
+  }
+}
+export {
+  DataGridQueryTool
+};

package/.medusa/server/src/admin/components/data-grid/models/data-grid-update-command.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class DataGridUpdateCommand {
+  constructor({ prev, next, setter }) {
+    __publicField(this, "_prev");
+    __publicField(this, "_next");
+    __publicField(this, "_setter");
+    this._prev = prev;
+    this._next = next;
+    this._setter = setter;
+  }
+  execute() {
+    this._setter(this._next);
+  }
+  undo() {
+    this._setter(this._prev);
+  }
+  redo() {
+    this.execute();
+  }
+}
+export {
+  DataGridUpdateCommand
+};

package/.medusa/server/src/admin/components/data-grid/models/index.js

@@ -0,0 +1,10 @@
+import { DataGridBulkUpdateCommand } from "./data-grid-bulk-update-command.js";
+import { DataGridMatrix } from "./data-grid-matrix.js";
+import { DataGridQueryTool } from "./data-grid-query-tool.js";
+import { DataGridUpdateCommand } from "./data-grid-update-command.js";
+export {
+  DataGridBulkUpdateCommand,
+  DataGridMatrix,
+  DataGridQueryTool,
+  DataGridUpdateCommand
+};

package/.medusa/server/src/admin/components/data-grid/types.js

@@ -0,0 +1 @@
+

package/.medusa/server/src/admin/components/data-grid/utils.js

@@ -0,0 +1,18 @@
+function generateCellId(coords) {
+  return `${coords.row}:${coords.col}`;
+}
+function isCellMatch(cell, coords) {
+  if (!coords) {
+    return false;
+  }
+  return cell.row === coords.row && cell.col === coords.col;
+}
+const SPECIAL_FOCUS_KEYS = [".", ","];
+function isSpecialFocusKey(event) {
+  return SPECIAL_FOCUS_KEYS.includes(event.key) && event.ctrlKey && event.altKey;
+}
+export {
+  generateCellId,
+  isCellMatch,
+  isSpecialFocusKey
+};

package/.medusa/server/src/admin/components/data-table/components/data-table-status-cell/data-table-status-cell.js

@@ -0,0 +1,36 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { clx } from "@medusajs/ui";
+const DataTableStatusCell = ({
+  color,
+  children
+}) => {
+  return /* @__PURE__ */ jsxs("div", { className: "txt-compact-small text-ui-fg-subtle flex h-full w-full items-center gap-x-2 overflow-hidden", children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "presentation",
+        className: "flex h-5 w-2 items-center justify-center",
+        children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: clx(
+              "h-2 w-2 rounded-sm shadow-[0px_0px_0px_1px_rgba(0,0,0,0.12)_inset]",
+              {
+                "bg-ui-tag-neutral-icon": color === "grey",
+                "bg-ui-tag-green-icon": color === "green",
+                "bg-ui-tag-red-icon": color === "red",
+                "bg-ui-tag-blue-icon": color === "blue",
+                "bg-ui-tag-orange-icon": color === "orange",
+                "bg-ui-tag-purple-icon": color === "purple"
+              }
+            )
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx("span", { className: "truncate", children })
+  ] });
+};
+export {
+  DataTableStatusCell
+};