@medusajs/loyalty-plugin 0.0.1

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

@@ -0,0 +1,149 @@
+import get from "/Users/oliverjuhl/Desktop/medusa/loyalty-plugin/node_modules/lodash/get.js";
+import set from "/Users/oliverjuhl/Desktop/medusa/loyalty-plugin/node_modules/lodash/set.js";
+import { useCallback } from "react";
+const useDataGridFormHandlers = ({
+  matrix,
+  form,
+  anchor
+}) => {
+  const { getValues, reset } = form;
+  const getSelectionValues = useCallback(
+    (fields) => {
+      if (!fields.length) {
+        return [];
+      }
+      const allValues = getValues();
+      return fields.map((field) => {
+        return field.split(".").reduce((obj, key) => obj == null ? void 0 : obj[key], allValues);
+      });
+    },
+    [getValues]
+  );
+  const setSelectionValues = useCallback(
+    async (fields, values, isHistory) => {
+      if (!fields.length || !anchor) {
+        return;
+      }
+      const type = matrix.getCellType(anchor);
+      if (!type) {
+        return;
+      }
+      const convertedValues = convertArrayToPrimitive(values, type);
+      const currentValues = getValues();
+      fields.forEach((field, index) => {
+        if (!field) {
+          return;
+        }
+        const valueIndex = index % values.length;
+        const newValue = convertedValues[valueIndex];
+        setValue(currentValues, field, newValue, type, isHistory);
+      });
+      reset(currentValues, {
+        keepDirty: true,
+        keepTouched: true,
+        keepDefaultValues: true
+      });
+    },
+    [matrix, anchor, getValues, reset]
+  );
+  return {
+    getSelectionValues,
+    setSelectionValues
+  };
+};
+function convertToNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const converted = Number(value);
+  if (isNaN(converted)) {
+    throw new Error(`String "${value}" cannot be converted to number.`);
+  }
+  return converted;
+}
+function convertToBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "undefined" || value === null) {
+    return false;
+  }
+  const lowerValue = value.toLowerCase();
+  if (lowerValue === "true" || lowerValue === "false") {
+    return lowerValue === "true";
+  }
+  throw new Error(`String "${value}" cannot be converted to boolean.`);
+}
+function covertToString(value) {
+  if (typeof value === "undefined" || value === null) {
+    return "";
+  }
+  return String(value);
+}
+function convertToggleableNumber(value) {
+  let obj = value;
+  if (typeof obj === "string") {
+    try {
+      obj = JSON.parse(obj);
+    } catch (error) {
+      throw new Error(`String "${value}" cannot be converted to object.`);
+    }
+  }
+  return obj;
+}
+function setValue(currentValues, field, newValue, type, isHistory) {
+  if (type !== "togglable-number") {
+    set(currentValues, field, newValue);
+    return;
+  }
+  setValueToggleableNumber(currentValues, field, newValue, isHistory);
+}
+function setValueToggleableNumber(currentValues, field, newValue, isHistory) {
+  const currentValue = get(currentValues, field);
+  const { disabledToggle } = currentValue;
+  const normalizeQuantity = (value) => {
+    if (disabledToggle && value === "") {
+      return 0;
+    }
+    return value;
+  };
+  const determineChecked = (quantity2) => {
+    if (disabledToggle) {
+      return true;
+    }
+    return quantity2 !== "" && quantity2 != null;
+  };
+  const quantity = normalizeQuantity(newValue.quantity);
+  const checked = isHistory ? disabledToggle ? true : newValue.checked : determineChecked(quantity);
+  set(currentValues, field, {
+    ...currentValue,
+    quantity,
+    checked
+  });
+}
+function convertArrayToPrimitive(values, type) {
+  switch (type) {
+    case "number":
+      return values.map((v) => {
+        if (v === "") {
+          return v;
+        }
+        if (v == null) {
+          return "";
+        }
+        return convertToNumber(v);
+      });
+    case "togglable-number":
+      return values.map(convertToggleableNumber);
+    case "boolean":
+      return values.map(convertToBoolean);
+    case "text":
+      return values.map(covertToString);
+    default:
+      throw new Error(`Unsupported target type "${type}".`);
+  }
+}
+export {
+  convertArrayToPrimitive,
+  useDataGridFormHandlers
+};

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

@@ -0,0 +1,482 @@
+import { useCallback } from "react";
+import { DataGridBulkUpdateCommand } from "../models/data-grid-bulk-update-command.js";
+import { DataGridUpdateCommand } from "../models/data-grid-update-command.js";
+const ARROW_KEYS = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
+const VERTICAL_KEYS = ["ArrowUp", "ArrowDown"];
+const useDataGridKeydownEvent = ({
+  containerRef,
+  matrix,
+  anchor,
+  rangeEnd,
+  isEditing,
+  setTrapActive,
+  scrollToCoordinates,
+  setSingleRange,
+  setRangeEnd,
+  onEditingChangeHandler,
+  getValues,
+  setValue,
+  execute,
+  undo,
+  redo,
+  queryTool,
+  getSelectionValues,
+  setSelectionValues,
+  restoreSnapshot,
+  createSnapshot
+}) => {
+  const handleKeyboardNavigation = useCallback(
+    (e) => {
+      if (!anchor) {
+        return;
+      }
+      const type = matrix.getCellType(anchor);
+      if (isEditing && type !== "boolean") {
+        return;
+      }
+      const direction = VERTICAL_KEYS.includes(e.key) ? "vertical" : "horizontal";
+      const basis = direction === "horizontal" ? anchor : e.shiftKey ? rangeEnd : anchor;
+      const updater = direction === "horizontal" ? setSingleRange : e.shiftKey ? setRangeEnd : setSingleRange;
+      if (!basis) {
+        return;
+      }
+      const { row, col } = basis;
+      const handleNavigation = (coords) => {
+        e.preventDefault();
+        e.stopPropagation();
+        scrollToCoordinates(coords, direction);
+        updater(coords);
+      };
+      const next = matrix.getValidMovement(
+        row,
+        col,
+        e.key,
+        e.metaKey || e.ctrlKey
+      );
+      handleNavigation(next);
+    },
+    [
+      isEditing,
+      anchor,
+      rangeEnd,
+      scrollToCoordinates,
+      setSingleRange,
+      setRangeEnd,
+      matrix
+    ]
+  );
+  const handleTabKey = useCallback(
+    (e) => {
+      if (!anchor) {
+        return;
+      }
+      e.preventDefault();
+      e.stopPropagation();
+      const { row, col } = anchor;
+      const key = e.shiftKey ? "ArrowLeft" : "ArrowRight";
+      const direction = "horizontal";
+      const next = matrix.getValidMovement(
+        row,
+        col,
+        key,
+        e.metaKey || e.ctrlKey
+      );
+      scrollToCoordinates(next, direction);
+      setSingleRange(next);
+    },
+    [anchor, scrollToCoordinates, setSingleRange, matrix]
+  );
+  const handleUndo = useCallback(
+    (e) => {
+      e.preventDefault();
+      if (e.shiftKey) {
+        redo();
+        return;
+      }
+      undo();
+    },
+    [redo, undo]
+  );
+  const handleSpaceKeyBoolean = useCallback(
+    (anchor2) => {
+      const end = rangeEnd ?? anchor2;
+      const fields = matrix.getFieldsInSelection(anchor2, end);
+      const prev = getSelectionValues(fields);
+      const allChecked = prev.every((value) => value === true);
+      const next = Array.from({ length: prev.length }, () => !allChecked);
+      const command = new DataGridBulkUpdateCommand({
+        fields,
+        next,
+        prev,
+        setter: setSelectionValues
+      });
+      execute(command);
+    },
+    [rangeEnd, matrix, getSelectionValues, setSelectionValues, execute]
+  );
+  const handleSpaceKeyTextOrNumber = useCallback(
+    (anchor2) => {
+      const field = matrix.getCellField(anchor2);
+      const input = queryTool == null ? void 0 : queryTool.getInput(anchor2);
+      if (!field || !input) {
+        return;
+      }
+      createSnapshot(anchor2);
+      const current = getValues(field);
+      const next = "";
+      const command = new DataGridUpdateCommand({
+        next,
+        prev: current,
+        setter: (value) => {
+          setValue(field, value, {
+            shouldDirty: true,
+            shouldTouch: true
+          });
+        }
+      });
+      execute(command);
+      input.focus();
+    },
+    [matrix, queryTool, getValues, execute, setValue, createSnapshot]
+  );
+  const handleSpaceKeyTogglableNumber = useCallback(
+    (anchor2) => {
+      const field = matrix.getCellField(anchor2);
+      const input = queryTool == null ? void 0 : queryTool.getInput(anchor2);
+      if (!field || !input) {
+        return;
+      }
+      createSnapshot(anchor2);
+      const current = getValues(field);
+      let checked = current.checked;
+      if (!current.disabledToggle) {
+        checked = false;
+      }
+      const next = { ...current, quantity: "", checked };
+      const command = new DataGridUpdateCommand({
+        next,
+        prev: current,
+        setter: (value) => {
+          setValue(field, value, {
+            shouldDirty: true,
+            shouldTouch: true
+          });
+        }
+      });
+      execute(command);
+      input.focus();
+    },
+    [matrix, queryTool, getValues, execute, setValue, createSnapshot]
+  );
+  const handleSpaceKey = useCallback(
+    (e) => {
+      if (!anchor || isEditing) {
+        return;
+      }
+      e.preventDefault();
+      const type = matrix.getCellType(anchor);
+      if (!type) {
+        return;
+      }
+      switch (type) {
+        case "boolean":
+          handleSpaceKeyBoolean(anchor);
+          break;
+        case "togglable-number":
+          handleSpaceKeyTogglableNumber(anchor);
+          break;
+        case "number":
+        case "text":
+          handleSpaceKeyTextOrNumber(anchor);
+          break;
+      }
+    },
+    [
+      anchor,
+      isEditing,
+      matrix,
+      handleSpaceKeyBoolean,
+      handleSpaceKeyTextOrNumber,
+      handleSpaceKeyTogglableNumber
+    ]
+  );
+  const handleMoveOnEnter = useCallback(
+    (e, anchor2) => {
+      const direction = e.shiftKey ? "ArrowUp" : "ArrowDown";
+      const pos = matrix.getValidMovement(
+        anchor2.row,
+        anchor2.col,
+        direction,
+        false
+      );
+      if (anchor2.row !== pos.row || anchor2.col !== pos.col) {
+        setSingleRange(pos);
+        scrollToCoordinates(pos, "vertical");
+      } else {
+        const container = queryTool == null ? void 0 : queryTool.getContainer(anchor2);
+        container == null ? void 0 : container.focus();
+      }
+      onEditingChangeHandler(false);
+    },
+    [
+      queryTool,
+      matrix,
+      scrollToCoordinates,
+      setSingleRange,
+      onEditingChangeHandler
+    ]
+  );
+  const handleEditOnEnter = useCallback(
+    (anchor2) => {
+      const input = queryTool == null ? void 0 : queryTool.getInput(anchor2);
+      if (!input) {
+        return;
+      }
+      input.focus();
+      onEditingChangeHandler(true);
+    },
+    [queryTool, onEditingChangeHandler]
+  );
+  const handleEnterKeyTextOrNumber = useCallback(
+    (e, anchor2) => {
+      if (isEditing) {
+        handleMoveOnEnter(e, anchor2);
+        return;
+      }
+      handleEditOnEnter(anchor2);
+    },
+    [handleMoveOnEnter, handleEditOnEnter, isEditing]
+  );
+  const handleEnterKeyBoolean = useCallback(
+    (e, anchor2) => {
+      const field = matrix.getCellField(anchor2);
+      if (!field) {
+        return;
+      }
+      const current = getValues(field);
+      let next;
+      if (typeof current === "boolean") {
+        next = !current;
+      } else {
+        next = true;
+      }
+      const command = new DataGridUpdateCommand({
+        next,
+        prev: current,
+        setter: (value) => {
+          setValue(field, value, {
+            shouldDirty: true,
+            shouldTouch: true
+          });
+        }
+      });
+      execute(command);
+      handleMoveOnEnter(e, anchor2);
+    },
+    [execute, getValues, handleMoveOnEnter, matrix, setValue]
+  );
+  const handleEnterKey = useCallback(
+    (e) => {
+      if (!anchor) {
+        return;
+      }
+      e.preventDefault();
+      const type = matrix.getCellType(anchor);
+      switch (type) {
+        case "togglable-number":
+        case "text":
+        case "number":
+          handleEnterKeyTextOrNumber(e, anchor);
+          break;
+        case "boolean": {
+          handleEnterKeyBoolean(e, anchor);
+          break;
+        }
+      }
+    },
+    [anchor, matrix, handleEnterKeyTextOrNumber, handleEnterKeyBoolean]
+  );
+  const handleDeleteKeyTogglableNumber = useCallback(
+    (anchor2, rangeEnd2) => {
+      const fields = matrix.getFieldsInSelection(anchor2, rangeEnd2);
+      const prev = getSelectionValues(fields);
+      const next = prev.map((value) => ({
+        ...value,
+        quantity: "",
+        checked: value.disableToggle ? value.checked : false
+      }));
+      const command = new DataGridBulkUpdateCommand({
+        fields,
+        next,
+        prev,
+        setter: setSelectionValues
+      });
+      execute(command);
+    },
+    [matrix, getSelectionValues, setSelectionValues, execute]
+  );
+  const handleDeleteKeyTextOrNumber = useCallback(
+    (anchor2, rangeEnd2) => {
+      const fields = matrix.getFieldsInSelection(anchor2, rangeEnd2);
+      const prev = getSelectionValues(fields);
+      const next = Array.from({ length: prev.length }, () => "");
+      const command = new DataGridBulkUpdateCommand({
+        fields,
+        next,
+        prev,
+        setter: setSelectionValues
+      });
+      execute(command);
+    },
+    [matrix, getSelectionValues, setSelectionValues, execute]
+  );
+  const handleDeleteKeyBoolean = useCallback(
+    (anchor2, rangeEnd2) => {
+      const fields = matrix.getFieldsInSelection(anchor2, rangeEnd2);
+      const prev = getSelectionValues(fields);
+      const next = Array.from({ length: prev.length }, () => false);
+      const command = new DataGridBulkUpdateCommand({
+        fields,
+        next,
+        prev,
+        setter: setSelectionValues
+      });
+      execute(command);
+    },
+    [execute, getSelectionValues, matrix, setSelectionValues]
+  );
+  const handleDeleteKey = useCallback(
+    (e) => {
+      if (!anchor || !rangeEnd || isEditing) {
+        return;
+      }
+      e.preventDefault();
+      const type = matrix.getCellType(anchor);
+      if (!type) {
+        return;
+      }
+      switch (type) {
+        case "text":
+        case "number":
+          handleDeleteKeyTextOrNumber(anchor, rangeEnd);
+          break;
+        case "boolean":
+          handleDeleteKeyBoolean(anchor, rangeEnd);
+          break;
+        case "togglable-number":
+          handleDeleteKeyTogglableNumber(anchor, rangeEnd);
+          break;
+      }
+    },
+    [
+      anchor,
+      rangeEnd,
+      isEditing,
+      matrix,
+      handleDeleteKeyTextOrNumber,
+      handleDeleteKeyBoolean,
+      handleDeleteKeyTogglableNumber
+    ]
+  );
+  const handleEscapeKey = useCallback(
+    (e) => {
+      if (!anchor || !isEditing) {
+        return;
+      }
+      e.preventDefault();
+      e.stopPropagation();
+      restoreSnapshot();
+      const container = queryTool == null ? void 0 : queryTool.getContainer(anchor);
+      container == null ? void 0 : container.focus();
+    },
+    [queryTool, isEditing, anchor, restoreSnapshot]
+  );
+  const handleSpecialFocusKeys = useCallback(
+    (e) => {
+      if (!containerRef || isEditing) {
+        return;
+      }
+      const focusableElements = getFocusableElements(containerRef);
+      const focusElement = (element) => {
+        if (element) {
+          setTrapActive(false);
+          element.focus();
+        }
+      };
+      switch (e.key) {
+        case ".":
+          focusElement(focusableElements.cancel);
+          break;
+        case ",":
+          focusElement(focusableElements.shortcuts);
+          break;
+      }
+    },
+    [isEditing, setTrapActive, containerRef]
+  );
+  const handleKeyDownEvent = useCallback(
+    (e) => {
+      if (ARROW_KEYS.includes(e.key)) {
+        handleKeyboardNavigation(e);
+        return;
+      }
+      if (e.key === "z" && (e.metaKey || e.ctrlKey)) {
+        handleUndo(e);
+        return;
+      }
+      if (e.key === " ") {
+        handleSpaceKey(e);
+        return;
+      }
+      if (e.key === "Delete" || e.key === "Backspace") {
+        handleDeleteKey(e);
+        return;
+      }
+      if (e.key === "Enter") {
+        handleEnterKey(e);
+        return;
+      }
+      if (e.key === "Escape") {
+        handleEscapeKey(e);
+        return;
+      }
+      if (e.key === "Tab") {
+        handleTabKey(e);
+        return;
+      }
+    },
+    [
+      handleEscapeKey,
+      handleKeyboardNavigation,
+      handleUndo,
+      handleSpaceKey,
+      handleEnterKey,
+      handleDeleteKey,
+      handleTabKey
+    ]
+  );
+  return {
+    handleKeyDownEvent,
+    handleSpecialFocusKeys
+  };
+};
+function getFocusableElements(ref) {
+  const focusableElements = Array.from(
+    document.querySelectorAll(
+      "[tabindex], a, button, input, select, textarea"
+    )
+  );
+  const currentElementIndex = focusableElements.indexOf(ref.current);
+  const shortcuts = currentElementIndex > 0 ? focusableElements[currentElementIndex - 1] : null;
+  let cancel = null;
+  for (let i = currentElementIndex + 1; i < focusableElements.length; i++) {
+    if (!ref.current.contains(focusableElements[i])) {
+      cancel = focusableElements[i];
+      break;
+    }
+  }
+  return { shortcuts, cancel };
+}
+export {
+  useDataGridKeydownEvent
+};

package/.medusa/server/src/admin/components/data-grid/hooks/use-data-grid-mouse-up-event.js

@@ -0,0 +1,64 @@
+import { useCallback } from "react";
+import { DataGridBulkUpdateCommand } from "../models/data-grid-bulk-update-command.js";
+const useDataGridMouseUpEvent = ({
+  matrix,
+  anchor,
+  dragEnd,
+  setDragEnd,
+  isDragging,
+  setIsDragging,
+  setRangeEnd,
+  setIsSelecting,
+  getSelectionValues,
+  setSelectionValues,
+  execute
+}) => {
+  const handleDragEnd = useCallback(() => {
+    if (!isDragging) {
+      return;
+    }
+    if (!anchor || !dragEnd) {
+      return;
+    }
+    const dragSelection = matrix.getFieldsInSelection(anchor, dragEnd);
+    const anchorField = matrix.getCellField(anchor);
+    if (!anchorField || !dragSelection.length) {
+      return;
+    }
+    const anchorValue = getSelectionValues([anchorField]);
+    const fields = dragSelection.filter((field) => field !== anchorField);
+    const prev = getSelectionValues(fields);
+    const next = Array.from({ length: prev.length }, () => anchorValue[0]);
+    const command = new DataGridBulkUpdateCommand({
+      fields,
+      prev,
+      next,
+      setter: setSelectionValues
+    });
+    execute(command);
+    setIsDragging(false);
+    setDragEnd(null);
+    setRangeEnd(dragEnd);
+  }, [
+    isDragging,
+    anchor,
+    dragEnd,
+    matrix,
+    getSelectionValues,
+    setSelectionValues,
+    execute,
+    setIsDragging,
+    setDragEnd,
+    setRangeEnd
+  ]);
+  const handleMouseUpEvent = useCallback(() => {
+    handleDragEnd();
+    setIsSelecting(false);
+  }, [handleDragEnd, setIsSelecting]);
+  return {
+    handleMouseUpEvent
+  };
+};
+export {
+  useDataGridMouseUpEvent
+};