@medusajs/loyalty-plugin 0.0.1

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

@@ -0,0 +1,123 @@
+import { useCallback } from "react";
+import { DataGridUpdateCommand } from "../models/data-grid-update-command.js";
+const useDataGridCellHandlers = ({
+  matrix,
+  anchor,
+  rangeEnd,
+  setRangeEnd,
+  isDragging,
+  setIsDragging,
+  isSelecting,
+  setIsSelecting,
+  setSingleRange,
+  dragEnd,
+  setDragEnd,
+  setValue,
+  execute,
+  multiColumnSelection
+}) => {
+  const getWrapperFocusHandler = useCallback(
+    (coords) => {
+      return (_e) => {
+        setSingleRange(coords);
+      };
+    },
+    [setSingleRange]
+  );
+  const getOverlayMouseDownHandler = useCallback(
+    (coords) => {
+      return (e) => {
+        e.stopPropagation();
+        e.preventDefault();
+        if (e.shiftKey) {
+          setRangeEnd(coords);
+          return;
+        }
+        setIsSelecting(true);
+        setSingleRange(coords);
+      };
+    },
+    [setIsSelecting, setRangeEnd, setSingleRange]
+  );
+  const getWrapperMouseOverHandler = useCallback(
+    (coords) => {
+      if (!isDragging && !isSelecting) {
+        return;
+      }
+      return (_e) => {
+        if ((anchor == null ? void 0 : anchor.col) !== coords.col && !multiColumnSelection) {
+          return;
+        }
+        if (isSelecting) {
+          setRangeEnd(coords);
+        } else {
+          setDragEnd(coords);
+        }
+      };
+    },
+    [
+      anchor == null ? void 0 : anchor.col,
+      isDragging,
+      isSelecting,
+      setDragEnd,
+      setRangeEnd,
+      multiColumnSelection
+    ]
+  );
+  const getInputChangeHandler = useCallback(
+    // Using `any` here as the generic type of Path<TFieldValues> will
+    // not be inferred correctly.
+    (field) => {
+      return (next, prev) => {
+        const command = new DataGridUpdateCommand({
+          next,
+          prev,
+          setter: (value) => {
+            setValue(field, value, {
+              shouldDirty: true,
+              shouldTouch: true
+            });
+          }
+        });
+        execute(command);
+      };
+    },
+    [setValue, execute]
+  );
+  const onDragToFillStart = useCallback(
+    (_e) => {
+      setIsDragging(true);
+    },
+    [setIsDragging]
+  );
+  const getIsCellSelected = useCallback(
+    (cell) => {
+      if (!cell || !anchor || !rangeEnd) {
+        return false;
+      }
+      return matrix.getIsCellSelected(cell, anchor, rangeEnd);
+    },
+    [anchor, rangeEnd, matrix]
+  );
+  const getIsCellDragSelected = useCallback(
+    (cell) => {
+      if (!cell || !anchor || !dragEnd) {
+        return false;
+      }
+      return matrix.getIsCellSelected(cell, anchor, dragEnd);
+    },
+    [anchor, dragEnd, matrix]
+  );
+  return {
+    getWrapperFocusHandler,
+    getOverlayMouseDownHandler,
+    getWrapperMouseOverHandler,
+    getInputChangeHandler,
+    getIsCellSelected,
+    getIsCellDragSelected,
+    onDragToFillStart
+  };
+};
+export {
+  useDataGridCellHandlers
+};

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

@@ -0,0 +1,52 @@
+import { useCallback } from "react";
+import { generateCellId } from "../utils.js";
+const useDataGridCellMetadata = ({
+  matrix
+}) => {
+  const getCellMetadata = useCallback(
+    (coords) => {
+      const { row, col } = coords;
+      const id = generateCellId(coords);
+      const field = matrix.getCellField(coords);
+      const type = matrix.getCellType(coords);
+      if (!field || !type) {
+        throw new Error(`'field' or 'type' is null for cell ${id}`);
+      }
+      const inputAttributes = {
+        "data-row": row,
+        "data-col": col,
+        "data-cell-id": id,
+        "data-field": field
+      };
+      const innerAttributes = {
+        "data-container-id": id
+      };
+      return {
+        id,
+        field,
+        type,
+        inputAttributes,
+        innerAttributes
+      };
+    },
+    [matrix]
+  );
+  const getCellErrorMetadata = useCallback(
+    (coords) => {
+      const accessor = matrix.getRowAccessor(coords.row);
+      const field = matrix.getCellField(coords);
+      return {
+        accessor,
+        field
+      };
+    },
+    [matrix]
+  );
+  return {
+    getCellMetadata,
+    getCellErrorMetadata
+  };
+};
+export {
+  useDataGridCellMetadata
+};

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

@@ -0,0 +1,43 @@
+import { useState, useCallback } from "react";
+const useDataGridCellSnapshot = ({
+  matrix,
+  form
+}) => {
+  const [snapshot, setSnapshot] = useState(null);
+  const { getValues, setValue } = form;
+  const createSnapshot = useCallback(
+    (cell) => {
+      if (!cell) {
+        return null;
+      }
+      const field = matrix.getCellField(cell);
+      if (!field) {
+        return null;
+      }
+      const value = getValues(field);
+      setSnapshot((curr) => {
+        if ((curr == null ? void 0 : curr.field) === field) {
+          return curr;
+        }
+        return { field, value };
+      });
+    },
+    [getValues, matrix]
+  );
+  const restoreSnapshot = useCallback(() => {
+    if (!snapshot) {
+      return;
+    }
+    const { field, value } = snapshot;
+    requestAnimationFrame(() => {
+      setValue(field, value);
+    });
+  }, [setValue, snapshot]);
+  return {
+    createSnapshot,
+    restoreSnapshot
+  };
+};
+export {
+  useDataGridCellSnapshot
+};

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

@@ -0,0 +1,191 @@
+import { useMemo, useState, useRef, useCallback, useEffect } from "react";
+import "../context/data-grid-context.js";
+import { useDataGridContext } from "../context/use-data-grid-context.js";
+import { isSpecialFocusKey, isCellMatch } from "../utils.js";
+const textCharacterRegex = /^.$/u;
+const numberCharacterRegex = /^[0-9]$/u;
+const useDataGridCell = ({
+  context
+}) => {
+  const {
+    register,
+    control,
+    anchor,
+    setIsEditing,
+    setSingleRange,
+    setIsSelecting,
+    setRangeEnd,
+    getWrapperFocusHandler,
+    getWrapperMouseOverHandler,
+    getInputChangeHandler,
+    getIsCellSelected,
+    getIsCellDragSelected,
+    getCellMetadata
+  } = useDataGridContext();
+  const { rowIndex, columnIndex } = context;
+  const coords = useMemo(
+    () => ({ row: rowIndex, col: columnIndex }),
+    [rowIndex, columnIndex]
+  );
+  const { id, field, type, innerAttributes, inputAttributes } = useMemo(() => {
+    return getCellMetadata(coords);
+  }, [coords, getCellMetadata]);
+  const [showOverlay, setShowOverlay] = useState(true);
+  const containerRef = useRef(null);
+  const inputRef = useRef(null);
+  const handleOverlayMouseDown = useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (e.detail === 2) {
+        if (inputRef.current) {
+          setShowOverlay(false);
+          inputRef.current.focus();
+          return;
+        }
+      }
+      if (e.shiftKey) {
+        if (coords.col === (anchor == null ? void 0 : anchor.col)) {
+          setRangeEnd(coords);
+          return;
+        }
+      }
+      if (containerRef.current) {
+        setSingleRange(coords);
+        setIsSelecting(true);
+        containerRef.current.focus();
+      }
+    },
+    [coords, anchor, setRangeEnd, setSingleRange, setIsSelecting]
+  );
+  const handleBooleanInnerMouseDown = useCallback(
+    (e) => {
+      var _a;
+      e.preventDefault();
+      e.stopPropagation();
+      if (e.detail === 2) {
+        (_a = inputRef.current) == null ? void 0 : _a.focus();
+        return;
+      }
+      if (e.shiftKey) {
+        setRangeEnd(coords);
+        return;
+      }
+      if (containerRef.current) {
+        setSingleRange(coords);
+        setIsSelecting(true);
+        containerRef.current.focus();
+      }
+    },
+    [setIsSelecting, setSingleRange, setRangeEnd, coords]
+  );
+  const handleInputBlur = useCallback(() => {
+    setShowOverlay(true);
+    setIsEditing(false);
+  }, [setIsEditing]);
+  const handleInputFocus = useCallback(() => {
+    setShowOverlay(false);
+    setIsEditing(true);
+  }, [setIsEditing]);
+  const validateKeyStroke = useCallback(
+    (key) => {
+      switch (type) {
+        case "togglable-number":
+        case "number":
+          return numberCharacterRegex.test(key);
+        case "text":
+          return textCharacterRegex.test(key);
+        default:
+          return false;
+      }
+    },
+    [type]
+  );
+  const handleContainerKeyDown = useCallback(
+    (e) => {
+      var _a;
+      if (!inputRef.current || !validateKeyStroke(e.key) || !showOverlay) {
+        return;
+      }
+      if (e.key.toLowerCase() === "z" && (e.ctrlKey || e.metaKey)) {
+        return;
+      }
+      if (e.key.toLowerCase() === "c" && (e.ctrlKey || e.metaKey)) {
+        return;
+      }
+      if (e.key.toLowerCase() === "v" && (e.ctrlKey || e.metaKey)) {
+        return;
+      }
+      if (e.key === "Enter") {
+        return;
+      }
+      if (isSpecialFocusKey(e.nativeEvent)) {
+        return;
+      }
+      inputRef.current.focus();
+      setShowOverlay(false);
+      if (inputRef.current instanceof HTMLInputElement) {
+        inputRef.current.value = "";
+        const nativeInputValueSetter = (_a = Object.getOwnPropertyDescriptor(
+          window.HTMLInputElement.prototype,
+          "value"
+        )) == null ? void 0 : _a.set;
+        nativeInputValueSetter == null ? void 0 : nativeInputValueSetter.call(inputRef.current, e.key);
+        const event = new Event("input", { bubbles: true });
+        inputRef.current.dispatchEvent(event);
+      }
+      e.stopPropagation();
+      e.preventDefault();
+    },
+    [showOverlay, validateKeyStroke]
+  );
+  const isAnchor = useMemo(() => {
+    return anchor ? isCellMatch(coords, anchor) : false;
+  }, [anchor, coords]);
+  const fieldWithoutOverlay = useMemo(() => {
+    return type === "boolean";
+  }, [type]);
+  useEffect(() => {
+    var _a, _b;
+    if (isAnchor && !((_a = containerRef.current) == null ? void 0 : _a.contains(document.activeElement))) {
+      (_b = containerRef.current) == null ? void 0 : _b.focus();
+    }
+  }, [isAnchor]);
+  const renderProps = {
+    container: {
+      field,
+      isAnchor,
+      isSelected: getIsCellSelected(coords),
+      isDragSelected: getIsCellDragSelected(coords),
+      showOverlay: fieldWithoutOverlay ? false : showOverlay,
+      innerProps: {
+        ref: containerRef,
+        onMouseOver: getWrapperMouseOverHandler(coords),
+        onMouseDown: type === "boolean" ? handleBooleanInnerMouseDown : void 0,
+        onKeyDown: handleContainerKeyDown,
+        onFocus: getWrapperFocusHandler(coords),
+        ...innerAttributes
+      },
+      overlayProps: {
+        onMouseDown: handleOverlayMouseDown
+      }
+    },
+    input: {
+      ref: inputRef,
+      onBlur: handleInputBlur,
+      onFocus: handleInputFocus,
+      onChange: getInputChangeHandler(field),
+      ...inputAttributes
+    }
+  };
+  return {
+    id,
+    field,
+    register,
+    control,
+    renderProps
+  };
+};
+export {
+  useDataGridCell
+};

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

@@ -0,0 +1,70 @@
+import { useCallback } from "react";
+import { DataGridBulkUpdateCommand } from "../models/data-grid-bulk-update-command.js";
+const useDataGridClipboardEvents = ({
+  matrix,
+  anchor,
+  rangeEnd,
+  isEditing,
+  getSelectionValues,
+  setSelectionValues,
+  execute
+}) => {
+  const handleCopyEvent = useCallback(
+    (e) => {
+      var _a;
+      if (isEditing || !anchor || !rangeEnd) {
+        return;
+      }
+      e.preventDefault();
+      const fields = matrix.getFieldsInSelection(anchor, rangeEnd);
+      const values = getSelectionValues(fields);
+      const text = values.map((value) => {
+        if (typeof value === "object" && value !== null) {
+          return JSON.stringify(value);
+        }
+        return `${value}` ?? "";
+      }).join("	");
+      (_a = e.clipboardData) == null ? void 0 : _a.setData("text/plain", text);
+    },
+    [isEditing, anchor, rangeEnd, matrix, getSelectionValues]
+  );
+  const handlePasteEvent = useCallback(
+    (e) => {
+      var _a;
+      if (isEditing || !anchor || !rangeEnd) {
+        return;
+      }
+      e.preventDefault();
+      const text = (_a = e.clipboardData) == null ? void 0 : _a.getData("text/plain");
+      if (!text) {
+        return;
+      }
+      const next = text.split("	");
+      const fields = matrix.getFieldsInSelection(anchor, rangeEnd);
+      const prev = getSelectionValues(fields);
+      const command = new DataGridBulkUpdateCommand({
+        fields,
+        next,
+        prev,
+        setter: setSelectionValues
+      });
+      execute(command);
+    },
+    [
+      isEditing,
+      anchor,
+      rangeEnd,
+      matrix,
+      getSelectionValues,
+      setSelectionValues,
+      execute
+    ]
+  );
+  return {
+    handleCopyEvent,
+    handlePasteEvent
+  };
+};
+export {
+  useDataGridClipboardEvents
+};

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

@@ -0,0 +1,51 @@
+import { useCallback } from "react";
+function useDataGridColumnVisibility(grid, matrix) {
+  const columns = grid.getAllLeafColumns();
+  const columnOptions = columns.map((column) => ({
+    id: column.id,
+    name: getColumnName(column),
+    checked: column.getIsVisible(),
+    disabled: !column.getCanHide()
+  }));
+  const handleToggleColumn = useCallback(
+    (index) => (value) => {
+      const column = columns[index];
+      if (!column.getCanHide()) {
+        return;
+      }
+      matrix.toggleColumn(index, value);
+      column.toggleVisibility(value);
+    },
+    [columns, matrix]
+  );
+  const handleResetColumns = useCallback(() => {
+    grid.setColumnVisibility({});
+  }, [grid]);
+  const optionCount = columnOptions.filter((c) => !c.disabled).length;
+  const isDisabled = optionCount === 0;
+  return {
+    columnOptions,
+    handleToggleColumn,
+    handleResetColumns,
+    isDisabled
+  };
+}
+function getColumnName(column) {
+  const id = column.columnDef.id;
+  const enableHiding = column.columnDef.enableHiding;
+  const meta = column == null ? void 0 : column.columnDef.meta;
+  if (!id) {
+    throw new Error(
+      "Column is missing an id, which is a required field. Please provide an id for the column."
+    );
+  }
+  if (process.env.NODE_ENV === "development" && !(meta == null ? void 0 : meta.name) && enableHiding) {
+    console.warn(
+      `Column "${id}" does not have a name. You should add a name to the column definition. Falling back to the column id.`
+    );
+  }
+  return (meta == null ? void 0 : meta.name) || id;
+}
+export {
+  useDataGridColumnVisibility
+};

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

@@ -0,0 +1,15 @@
+import { useWatch } from "/Users/oliverjuhl/Desktop/medusa/loyalty-plugin/node_modules/react-hook-form/dist/index.esm.mjs";
+import "../context/data-grid-context.js";
+import { useDataGridContext } from "../context/use-data-grid-context.js";
+const useDataGridDuplicateCell = ({
+  duplicateOf
+}) => {
+  const { control } = useDataGridContext();
+  const watchedValue = useWatch({ control, name: duplicateOf });
+  return {
+    watchedValue
+  };
+};
+export {
+  useDataGridDuplicateCell
+};

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

@@ -0,0 +1,86 @@
+import { useState, useMemo, useCallback } from "react";
+const useDataGridErrorHighlighting = (matrix, grid, errors) => {
+  const [isHighlighted, setIsHighlighted] = useState(false);
+  const [visibilitySnapshot, setVisibilitySnapshot] = useState(null);
+  const { flatRows } = grid.getRowModel();
+  const flatColumns = grid.getAllFlatColumns();
+  const errorPaths = findErrorPaths(errors);
+  const errorCount = errorPaths.length;
+  const { rowsWithErrors, columnsWithErrors } = useMemo(() => {
+    const rowsWithErrors2 = /* @__PURE__ */ new Set();
+    const columnsWithErrors2 = /* @__PURE__ */ new Set();
+    errorPaths.forEach((errorPath) => {
+      const rowIndex = matrix.rowAccessors.findIndex(
+        (accessor) => accessor && (errorPath === accessor || errorPath.startsWith(`${accessor}.`))
+      );
+      if (rowIndex !== -1) {
+        rowsWithErrors2.add(rowIndex);
+      }
+      const columnIndex = matrix.columnAccessors.findIndex(
+        (accessor) => accessor && (errorPath === accessor || errorPath.endsWith(`.${accessor}`))
+      );
+      if (columnIndex !== -1) {
+        columnsWithErrors2.add(columnIndex);
+      }
+    });
+    return { rowsWithErrors: rowsWithErrors2, columnsWithErrors: columnsWithErrors2 };
+  }, [errorPaths, matrix.rowAccessors, matrix.columnAccessors]);
+  const toggleErrorHighlighting = useCallback(
+    (currentRowVisibility, currentColumnVisibility, setRowVisibility, setColumnVisibility) => {
+      if (isHighlighted) {
+        if (visibilitySnapshot) {
+          setRowVisibility(visibilitySnapshot.rows);
+          setColumnVisibility(visibilitySnapshot.columns);
+        }
+      } else {
+        setVisibilitySnapshot({
+          rows: { ...currentRowVisibility },
+          columns: { ...currentColumnVisibility }
+        });
+        const rowsToHide = flatRows.map((_, index) => {
+          return !rowsWithErrors.has(index) ? index : void 0;
+        }).filter((index) => index !== void 0);
+        const columnsToHide = flatColumns.map((column, index) => {
+          return !columnsWithErrors.has(index) && index !== 0 ? column.id : void 0;
+        }).filter((id) => id !== void 0);
+        setRowVisibility(
+          rowsToHide.reduce((acc, row) => ({ ...acc, [row]: false }), {})
+        );
+        setColumnVisibility(
+          columnsToHide.reduce(
+            (acc, column) => ({ ...acc, [column]: false }),
+            {}
+          )
+        );
+      }
+      setIsHighlighted((prev) => !prev);
+    },
+    [
+      isHighlighted,
+      visibilitySnapshot,
+      flatRows,
+      flatColumns,
+      rowsWithErrors,
+      columnsWithErrors
+    ]
+  );
+  return {
+    errorCount,
+    isHighlighted,
+    toggleErrorHighlighting
+  };
+};
+function findErrorPaths(obj, path = []) {
+  if (typeof obj !== "object" || obj === null) {
+    return [];
+  }
+  if ("message" in obj && "type" in obj) {
+    return [path.join(".")];
+  }
+  return Object.entries(obj).flatMap(
+    ([key, value]) => findErrorPaths(value, [...path, key])
+  );
+}
+export {
+  useDataGridErrorHighlighting
+};