@retikolo/drag-drop-content-types-strapi 2.0.0

package/dist/_chunks/index-D5Ne-GrP.js

@@ -0,0 +1,478 @@
+"use strict";
+const React = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const arrayMove = require("array-move");
+const admin = require("@strapi/strapi/admin");
+const designSystem = require("@strapi/design-system");
+const icons = require("@strapi/icons");
+const reactIntl = require("react-intl");
+const core = require("@dnd-kit/core");
+const sortable = require("@dnd-kit/sortable");
+const utilities = require("@dnd-kit/utilities");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const React__default = /* @__PURE__ */ _interopDefault(React);
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "drag-drop-content-types";
+const Initializer = ({ setPlugin }) => {
+  const ref = React.useRef(setPlugin);
+  React.useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+function useQueryParams() {
+  const [params, setParams] = React.useState(null);
+  React.useEffect(() => {
+    const q = new Proxy(new URLSearchParams(window.location.search), {
+      get: (queryParams, prop) => queryParams.get(prop.toString())
+    });
+    setParams(q);
+  }, [window.location.search]);
+  return { queryParams: params };
+}
+const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
+const CustomItem = React.forwardRef(
+  ({ item, isOpacityEnabled, isDragging, style, ...props }, ref) => {
+    const styles = {
+      opacity: isOpacityEnabled ? "0.4" : "1",
+      cursor: isDragging ? "grabbing" : "grab",
+      lineHeight: "0.5",
+      transform: isDragging ? "scale(1.05)" : "scale(1)",
+      ...style
+    };
+    const ellipsis = (str, num = str.length, ellipsisStr = "...") => str.length >= num ? str.slice(0, num >= ellipsisStr.length ? num - ellipsisStr.length : num) + ellipsisStr : str;
+    item.title = ellipsis(item.title ?? "", 30);
+    item.subtitle = ellipsis(item.subtitle ?? "", 30);
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { ref, style: styles, ...props, children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Box,
+      {
+        style: { zIndex: 10, cursor: "all-scroll", userSelect: "none" },
+        background: "neutral0",
+        hasRadius: true,
+        shadow: "filterShadow",
+        padding: 2,
+        children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Grid.Root, { gap: 1, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Grid.Item, { col: 2, s: 12, children: /* @__PURE__ */ jsxRuntime.jsx(icons.Drag, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Grid.Item, { col: 10, s: 12, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { children: [
+            item.title,
+            item.subtitle
+          ] }) })
+        ] })
+      }
+    ) });
+  }
+);
+const SortableListItem = ({ item, ...props }) => {
+  const { attributes, isDragging, listeners, setNodeRef, transform, transition } = sortable.useSortable({
+    id: item.id
+  });
+  const styles = {
+    transform: utilities.CSS.Transform.toString(transform),
+    transition: transition || void 0
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    CustomItem,
+    {
+      item,
+      ref: setNodeRef,
+      style: styles,
+      isOpacityEnabled: isDragging,
+      ...props,
+      ...attributes,
+      ...listeners
+    }
+  );
+};
+function getSubtitle(entry, subTitleField, titleField) {
+  try {
+    if (subTitleField && entry[subTitleField]) {
+      if (entry[subTitleField].constructor.name == "Array") {
+        if (entry[subTitleField].length > 0)
+          return ` - ${entry[subTitleField][0][titleField]}`;
+      } else if (typeof entry[subTitleField] === "object") {
+        return ` - ${entry[subTitleField][titleField]}`;
+      } else {
+        return ` - ${entry[subTitleField]}`;
+      }
+    }
+    return "";
+  } catch (e) {
+    console.log("Unsupported subtitle field value.", e);
+    return "";
+  }
+}
+function getTitle(entry, titleField, mainField) {
+  const title = entry[titleField] ? entry[titleField] : entry[mainField];
+  return title?.toString();
+}
+const SortableList = ({ data, onShowMore, hasMore, settings, onSortEnd }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  let { title, subtitle, mainField } = settings;
+  subtitle = subtitle ?? "";
+  mainField = mainField ?? "";
+  const convertDataItem = (pageEntry) => {
+    return {
+      ...pageEntry,
+      title: getTitle(pageEntry, title, mainField),
+      subtitle: getSubtitle(pageEntry, subtitle, title)
+    };
+  };
+  const defaultItems = data.map((x) => convertDataItem(x));
+  const [items, setItems] = React.useState(defaultItems);
+  if (items.length !== defaultItems.length)
+    setItems(defaultItems);
+  const [activeItem, setActiveItem] = React.useState();
+  const sensors = core.useSensors(core.useSensor(core.PointerSensor), core.useSensor(core.TouchSensor));
+  const handleDragStart = (event) => {
+    const { active } = event;
+    setActiveItem(items.find((item) => item.id === active.id));
+  };
+  const handleDragEnd = (event) => {
+    const { active, over } = event;
+    if (!over) return;
+    const activeItem2 = items.find((item) => item.id === active.id);
+    const overItem = items.find((item) => item.id === over.id);
+    if (!activeItem2 || !overItem) {
+      return;
+    }
+    const activeIndex = items.findIndex((item) => item.id === active.id);
+    const overIndex = items.findIndex((item) => item.id === over.id);
+    if (activeIndex !== overIndex) {
+      setItems((prev) => sortable.arrayMove(prev, activeIndex, overIndex));
+    }
+    setActiveItem(void 0);
+    onSortEnd({ oldIndex: activeIndex, newIndex: overIndex });
+  };
+  const handleDragCancel = () => {
+    setActiveItem(void 0);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { maxWidth: "280px" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      core.DndContext,
+      {
+        sensors,
+        collisionDetection: core.closestCenter,
+        onDragStart: handleDragStart,
+        onDragEnd: handleDragEnd,
+        onDragCancel: handleDragCancel,
+        children: /* @__PURE__ */ jsxRuntime.jsx(sortable.SortableContext, { items, children: items.map((item) => /* @__PURE__ */ jsxRuntime.jsx(SortableListItem, { item }, item.id)) })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Divider, { margin: 0 }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { size: "S", disabled: hasMore ? true : false, onClick: onShowMore, children: formatMessage({ id: getTranslation("plugin.settings.sortableList.showMore") }) }) })
+  ] });
+};
+const SortMenu = ({ status, data, onSortEnd, onShowMore, hasMore, settings, onClose }) => {
+  const [visible, setVisible] = React.useState(false);
+  const buttonRef = React__default.default.useRef(null);
+  const togglePortal = React__default.default.useCallback(() => {
+    setVisible((prev) => !prev);
+  }, []);
+  const handleClose = React__default.default.useCallback((event) => {
+    if (event?.target?.id !== "drag-drop-content-type-plugin--sort-menu-button") {
+      setVisible(false);
+      if (onClose) {
+        onClose();
+      }
+    }
+  }, [onClose]);
+  return /* @__PURE__ */ jsxRuntime.jsx(React__default.default.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Popover.Root, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Popover.Trigger, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.IconButton,
+      {
+        id: "drag-drop-content-type-plugin--sort-menu-button",
+        ref: buttonRef,
+        variant: "secondary",
+        disabled: status === "success" ? false : true,
+        withTooltip: false,
+        onClick: togglePortal,
+        label: "Sort",
+        children: /* @__PURE__ */ jsxRuntime.jsx(icons.Drag, {})
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Popover.Content,
+      {
+        onEscapeKeyDown: handleClose,
+        onPointerDownOutside: handleClose,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          SortableList,
+          {
+            data,
+            onShowMore,
+            onSortEnd,
+            hasMore,
+            settings
+          }
+        )
+      }
+    )
+  ] }) });
+};
+const SortModal = () => {
+  const { get, post, put } = admin.useFetchClient();
+  const [data, setData] = React.useState([]);
+  const [pagination, setPagination] = React.useState();
+  const [status, setStatus] = React.useState("loading");
+  const [mainField, setMainField] = React.useState("id");
+  const [uid, setUid] = React.useState(null);
+  const [settings, setSettings] = React.useState({
+    rank: "",
+    title: "",
+    subtitle: "",
+    mainField: null
+  });
+  const [noEntriesFromNextPage, setNoEntriesFromNextPage] = React.useState(0);
+  const [hasSorted, setHasSorted] = React.useState(false);
+  const { queryParams } = useQueryParams();
+  const { toggleNotification } = admin.useNotification();
+  const { formatAPIError } = admin.useAPIErrorHandler();
+  const paths = window.location.pathname.split("/");
+  const contentTypePath = paths[paths.length - 1];
+  const params = queryParams;
+  const pageSize = parseInt(params?.pageSize) ?? 0;
+  const currentPage = parseInt(params?.page) ?? 0;
+  const locale = params?.["plugins[i18n][locale]"];
+  const listIncrementSize = pageSize ? pageSize / 2 : 1;
+  const hasMore = noEntriesFromNextPage ? noEntriesFromNextPage + listIncrementSize >= data?.length - 1 : false;
+  const fetchContentTypeConfig = async () => {
+    try {
+      const { data: data2 } = await get(
+        `/content-manager/content-types/${contentTypePath}/configuration`
+      );
+      const settings2 = data2.data.contentType?.settings;
+      setMainField(settings2.mainField);
+      setUid(data2.data.contentType?.uid);
+      setNoEntriesFromNextPage(settings2.pageSize / 2);
+    } catch (e) {
+      console.log(e);
+    }
+  };
+  const fetchSettings = async () => {
+    try {
+      const { data: data2 } = await get(`/drag-drop-content-types/settings`);
+      let fetchedSettings = {
+        rank: data2.body.rank,
+        title: data2.body.title?.length > 0 ? data2.body.title : mainField,
+        subtitle: data2.body.subtitle?.length > 0 ? data2.body.subtitle : null,
+        mainField
+      };
+      setSettings(fetchedSettings);
+    } catch (e) {
+      console.log(e);
+    }
+  };
+  const getPageEntries = async () => {
+    if (pageSize) {
+      const sortIndexParam = {
+        contentType: contentTypePath,
+        rankFieldName: settings.rank,
+        start: Math.max(
+          0,
+          (currentPage - 1) * pageSize - noEntriesFromNextPage
+        ),
+        limit: currentPage === 1 ? pageSize + noEntriesFromNextPage : pageSize + 2 * noEntriesFromNextPage,
+        locale
+      };
+      const results = await post(`/drag-drop-content-types/sort-index`, sortIndexParam);
+      return results;
+    }
+  };
+  const initializeContentType = async () => {
+    try {
+      if (settings?.rank) {
+        const entries = await getPageEntries();
+        if (entries?.data?.length) {
+          const firstEntry = entries.data[0];
+          const firstEntryRank = firstEntry[settings.rank];
+          if (entries.data?.length > 0 && firstEntryRank && !!firstEntryRank.toString()) {
+            setStatus("success");
+          }
+        }
+      }
+    } catch (e) {
+      console.log("Could not initialize content type", e);
+      setStatus("error");
+    }
+  };
+  const fetchContentType = async () => {
+    try {
+      const entries = await getPageEntries();
+      if (entries?.data?.length) {
+        setStatus("success");
+        setData(entries.data);
+        const { data: data2 } = await get(
+          `/content-manager/collection-types/${contentTypePath}?sort=${settings.rank}:asc&page=${currentPage}&pageSize=${pageSize}&locale=${locale}`
+        );
+        setPagination(data2.pagination);
+      }
+    } catch (e) {
+      console.log("Could not fetch content type", e);
+      setStatus("error");
+    }
+  };
+  const updateContentType = async (item) => {
+    const { oldIndex, newIndex } = item;
+    try {
+      const sortedList = arrayMove.arrayMoveImmutable(data, oldIndex, newIndex);
+      const rankUpdates = [];
+      let rankHasChanged = false;
+      for (let i = 0; i < sortedList.length; i++) {
+        if (sortedList[i].id != data[i].id) {
+          const newRank = pageSize * (currentPage - 1) + i || 0;
+          const update = {
+            id: sortedList[i].id,
+            rank: newRank
+          };
+          rankUpdates.push(update);
+          rankHasChanged = true;
+        } else if (rankHasChanged) {
+          break;
+        }
+      }
+      await put("/drag-drop-content-types/batch-update", {
+        contentType: contentTypePath,
+        updates: rankUpdates
+      });
+      let sortedListViewEntries = currentPage == 1 ? sortedList.slice(0, pageSize) : sortedList.length < pageSize ? sortedList.slice(noEntriesFromNextPage, sortedList.length) : sortedList.slice(
+        noEntriesFromNextPage,
+        pageSize + noEntriesFromNextPage
+      );
+      setData(sortedList);
+      setStatus("success");
+      afterUpdate(sortedListViewEntries, pagination);
+    } catch (e) {
+      console.log("Could not update content type:", e);
+      toggleNotification({
+        type: "warning",
+        message: formatAPIError(e)
+      });
+      setStatus("error");
+    }
+  };
+  const afterUpdate = (newData, pagination2) => {
+    setHasSorted(true);
+  };
+  const handleModalClose = () => {
+    if (hasSorted) {
+      window.location.reload();
+    }
+  };
+  const showMoreHandler = () => {
+    setNoEntriesFromNextPage(noEntriesFromNextPage + listIncrementSize);
+  };
+  React.useEffect(() => {
+    fetchContentTypeConfig();
+  }, []);
+  React.useEffect(() => {
+    fetchSettings();
+  }, [mainField]);
+  React.useEffect(() => {
+    if (settings?.rank) {
+      initializeContentType();
+    }
+  }, [settings]);
+  React.useEffect(() => {
+    if (settings?.rank && pageSize && currentPage) {
+      fetchContentType();
+    }
+  }, [noEntriesFromNextPage, locale, pageSize, currentPage, settings]);
+  return (
+    // <CheckPermissions permissions={pluginPermissions.main}>
+    /* @__PURE__ */ jsxRuntime.jsx(
+      SortMenu,
+      {
+        data,
+        status,
+        onOpen: fetchContentType,
+        onSortEnd: updateContentType,
+        onShowMore: showMoreHandler,
+        onClose: handleModalClose,
+        hasMore,
+        settings
+      }
+    )
+  );
+};
+const pluginPermissions = {
+  main: [{ action: "plugin::drag-drop-content-types.read", subject: null }]
+};
+const prefixPluginTranslations = (trad, pluginId) => {
+  return Object.keys(trad).reduce((acc, current) => {
+    acc[`${pluginId}.${current}`] = trad[current];
+    return acc;
+  }, {});
+};
+const index = {
+  register(app) {
+    app.createSettingSection(
+      {
+        id: PLUGIN_ID,
+        intlLabel: {
+          id: `${PLUGIN_ID}.plugin.name`,
+          defaultMessage: "Drag Drop Content Types"
+        },
+        permissions: pluginPermissions.main
+      },
+      [
+        {
+          intlLabel: {
+            id: `${PLUGIN_ID}.plugin.configuration`,
+            defaultMessage: "Configuration"
+          },
+          id: "settings",
+          to: `${PLUGIN_ID}`,
+          Component: () => Promise.resolve().then(() => require("./Settings-BUJ6OWyE.js"))
+        }
+      ]
+    );
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  bootstrap(app) {
+    app.getPlugin("content-manager").injectComponent("listView", "actions", {
+      name: "sort-component",
+      Component: SortModal
+    });
+  },
+  async registerTrads(app) {
+    const { locales } = app;
+    const importedTranslations = await Promise.all(
+      locales.map((locale) => {
+        return __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => Promise.resolve().then(() => require("./en-I3-CH3Sy.js")), "./translations/fr.json": () => Promise.resolve().then(() => require("./fr-C8Qw4iPZ.js")) }), `./translations/${locale}.json`, 3).then(({ default: data }) => {
+          return {
+            data: prefixPluginTranslations(data, PLUGIN_ID),
+            locale
+          };
+        }).catch(() => {
+          return {
+            data: {},
+            locale
+          };
+        });
+      })
+    );
+    return importedTranslations;
+  }
+};
+exports.getTranslation = getTranslation;
+exports.index = index;

package/dist/admin/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const index = require("../_chunks/index-D5Ne-GrP.js");
+module.exports = index.index;

package/dist/admin/index.mjs

@@ -0,0 +1,4 @@
+import { i } from "../_chunks/index-CxWC49Ye.mjs";
+export {
+  i as default
+};

package/dist/admin/src/components/Initializer.d.ts

@@ -0,0 +1,5 @@
+type InitializerProps = {
+    setPlugin: (id: string) => void;
+};
+declare const Initializer: ({ setPlugin }: InitializerProps) => null;
+export { Initializer };

package/dist/admin/src/components/PluginIcon.d.ts

@@ -0,0 +1,2 @@
+declare const PluginIcon: () => import("react/jsx-runtime").JSX.Element;
+export { PluginIcon };

package/dist/admin/src/components/SettingsTextField.d.ts

@@ -0,0 +1,14 @@
+interface SettingsTextFieldProps {
+    fieldName: string;
+    displayName: string;
+    required: boolean;
+    value?: string;
+    hasLabel?: boolean;
+    hasHint?: boolean;
+    hasTooltip?: boolean;
+    hasPlaceholder?: boolean;
+    type?: string;
+    updateItem: (fieldName: string, value: string) => void;
+}
+declare const SettingsTextField: (props: SettingsTextFieldProps) => import("react/jsx-runtime").JSX.Element;
+export default SettingsTextField;

package/dist/admin/src/components/SettingsToggleField.d.ts

@@ -0,0 +1,13 @@
+interface SettingsToggleFieldProps {
+    fieldName: string;
+    displayName: string;
+    required: boolean;
+    value?: boolean;
+    hasLabel?: boolean;
+    hasHint?: boolean;
+    hasTooltip?: boolean;
+    type?: string;
+    updateItem: (fieldName: string, value: boolean) => void;
+}
+declare const SettingsToggleField: (props: SettingsToggleFieldProps) => import("react/jsx-runtime").JSX.Element;
+export default SettingsToggleField;

package/dist/admin/src/components/SortModal/CustomItem.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes } from "react";
+export type TItem = {
+    id: number;
+    title: string;
+    subtitle: string;
+};
+declare const CustomItem: import("react").ForwardRefExoticComponent<{
+    item: TItem;
+    isOpacityEnabled?: boolean | undefined;
+    isDragging?: boolean | undefined;
+} & HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+export default CustomItem;

package/dist/admin/src/components/SortModal/SortMenu.d.ts

@@ -0,0 +1,3 @@
+import { SortMenuProps } from "./types";
+declare const SortMenu: ({ status, data, onSortEnd, onShowMore, hasMore, settings, onClose }: SortMenuProps) => import("react/jsx-runtime").JSX.Element;
+export default SortMenu;

package/dist/admin/src/components/SortModal/SortableList.d.ts

@@ -0,0 +1,3 @@
+import { SortableListProps } from "./types";
+declare const SortableList: ({ data, onShowMore, hasMore, settings, onSortEnd }: SortableListProps) => import("react/jsx-runtime").JSX.Element;
+export default SortableList;

package/dist/admin/src/components/SortModal/SortableListItem.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from "react";
+import { TItem } from "./CustomItem";
+type Props = {
+    item: TItem;
+} & HTMLAttributes<HTMLDivElement>;
+declare const SortableListItem: ({ item, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
+export default SortableListItem;

package/dist/admin/src/components/SortModal/index.d.ts

@@ -0,0 +1,2 @@
+declare const SortModal: () => import("react/jsx-runtime").JSX.Element;
+export default SortModal;

package/dist/admin/src/components/SortModal/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getSubtitle(entry: any, subTitleField: string, titleField: string): string;
+export declare function getTitle(entry: any, titleField: string, mainField: string): any;

package/dist/admin/src/components/TooltipIconButton.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+interface TooltipIconButtonProps {
+    children: React.ReactNode;
+    label: string | undefined;
+    variant?: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    showBorder?: boolean;
+}
+declare const TooltipIconButton: ({ children, label, variant, onClick, disabled, showBorder }: TooltipIconButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default TooltipIconButton;

package/dist/admin/src/index.d.ts

@@ -0,0 +1,13 @@
+type TradOptions = Record<string, string>;
+declare const _default: {
+    register(app: any): void;
+    bootstrap(app: any): void;
+    registerTrads(app: any): Promise<({
+        data: TradOptions;
+        locale: string;
+    } | {
+        data: {};
+        locale: string;
+    })[]>;
+};
+export default _default;

package/dist/admin/src/pages/App.d.ts

@@ -0,0 +1,2 @@
+declare const App: () => import("react/jsx-runtime").JSX.Element;
+export { App };

package/dist/admin/src/pages/HomePage.d.ts

@@ -0,0 +1,2 @@
+declare const HomePage: () => import("react/jsx-runtime").JSX.Element;
+export { HomePage };

package/dist/admin/src/pages/Settings.d.ts

@@ -0,0 +1,2 @@
+declare const Settings: () => import("react/jsx-runtime").JSX.Element;
+export default Settings;

package/dist/admin/src/permissions.d.ts

@@ -0,0 +1,7 @@
+declare const pluginPermissions: {
+    main: {
+        action: string;
+        subject: null;
+    }[];
+};
+export default pluginPermissions;

package/dist/admin/src/pluginId.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "drag-drop-content-types";

package/dist/admin/src/utils/getTranslation.d.ts

@@ -0,0 +1,2 @@
+declare const getTranslation: (id: string) => string;
+export { getTranslation };

package/dist/admin/src/utils/strapi.d.ts

@@ -0,0 +1,13 @@
+import { GetPageEntriesResponse, Pagination } from "../components/SortModal/types";
+export declare const GET_DATA = "ContentManager/ListView/GET_DATA";
+export declare const GET_DATA_SUCCEEDED = "ContentManager/ListView/GET_DATA_SUCCEEDED";
+export declare function getData(uid: any, params: any): {
+    type: string;
+    uid: any;
+    params: any;
+};
+export declare function getDataSucceeded(pagination: Pagination, data: GetPageEntriesResponse[]): {
+    type: string;
+    pagination: Pagination;
+    data: GetPageEntriesResponse[];
+};

package/dist/admin/src/utils/useQueryParams.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @returns {Object} | {}}
+ */
+export declare function useQueryParams(): {
+    queryParams: URLSearchParams | null;
+};