@medusajs/loyalty-plugin 0.0.1 → 0.0.2

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

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

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

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

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

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

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

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

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