@hartl-services/medusa-base 2.4.0 → 2.6.0

package/.medusa/server/src/admin/admin-components/shared/ui/FilePickerButton.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "@medusajs/ui";
+import { useRef } from "react";
+/** Button that opens the file dialog; the native input stays hidden. */
+export const FilePickerButton = ({ accept, label, disabled, isLoading, id, "aria-describedby": describedBy, onFileSelected, }) => {
+    const fileInput = useRef(null);
+    return (_jsxs(_Fragment, { children: [_jsx("input", { ref: fileInput, id: id, "aria-describedby": describedBy, type: "file", accept: accept, className: "hidden", disabled: disabled, onChange: (event) => {
+                    const file = event.target.files?.[0];
+                    event.target.value = "";
+                    if (file) {
+                        onFileSelected(file);
+                    }
+                } }), _jsx(Button, { type: "button", size: "small", variant: "secondary", isLoading: isLoading, disabled: disabled || isLoading, onClick: () => fileInput.current?.click(), children: label })] }));
+};

package/.medusa/server/src/admin/admin-components/shared/ui/MappedStatusBadge.d.ts

@@ -0,0 +1,17 @@
+import { StatusBadge } from "@medusajs/ui";
+import type { ComponentProps } from "react";
+export type MappedStatus = {
+    label: string;
+    color: NonNullable<ComponentProps<typeof StatusBadge>["color"]>;
+};
+type MappedStatusBadgeProps = {
+    /** An empty value renders `ADMIN_DASH` instead of a badge. */
+    value: string | null | undefined;
+    /** Label and colour per status; `null` hides the badge for that status. */
+    map: Record<string, MappedStatus | null>;
+    /** For a value missing from `map`; default: the raw value in grey. */
+    fallback?: MappedStatus | null;
+};
+/** `StatusBadge` for a status string with a label and colour per status. */
+export declare const MappedStatusBadge: ({ value, map, fallback, }: MappedStatusBadgeProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/MappedStatusBadge.js

@@ -0,0 +1,12 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { StatusBadge } from "@medusajs/ui";
+import { ADMIN_DASH } from "../lib/format";
+import { resolveMappedStatus } from "./mapped-status";
+/** `StatusBadge` for a status string with a label and colour per status. */
+export const MappedStatusBadge = ({ value, map, fallback, }) => {
+    if (!value) {
+        return _jsx(_Fragment, { children: ADMIN_DASH });
+    }
+    const status = resolveMappedStatus(value, map, fallback === undefined ? { label: value, color: "grey" } : fallback);
+    return status ? (_jsx(StatusBadge, { color: status.color, children: status.label })) : null;
+};

package/.medusa/server/src/admin/admin-components/shared/ui/OffsetTablePagination.d.ts

@@ -0,0 +1,15 @@
+type OffsetTablePaginationProps = {
+    /** Total number of rows over all pages. */
+    count: number;
+    offset: number;
+    limit: number;
+    onOffsetChange: (offset: number) => void;
+    /** Highest offset the API accepts; the next page is disabled beyond it. */
+    maxOffset?: number;
+};
+/**
+ * German `Table.Pagination` for an offset/limit list: page navigation moves
+ * `offset` by `limit`; render it below the `Table` when `count > 0`.
+ */
+export declare const OffsetTablePagination: ({ count, offset, limit, onOffsetChange, maxOffset, }: OffsetTablePaginationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/OffsetTablePagination.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Table } from "@medusajs/ui";
+import { getOffsetPagination } from "./offset-pagination";
+// Table.Pagination renders "1 - 20 von 45 Ergebnisse", "1 von 3 Seiten".
+const translations = {
+    of: "von",
+    results: "Ergebnisse",
+    pages: "Seiten",
+    prev: "Zurück",
+    next: "Weiter",
+};
+/**
+ * German `Table.Pagination` for an offset/limit list: page navigation moves
+ * `offset` by `limit`; render it below the `Table` when `count > 0`.
+ */
+export const OffsetTablePagination = ({ count, offset, limit, onOffsetChange, maxOffset, }) => {
+    const page = getOffsetPagination({ count, offset, limit, maxOffset });
+    return (_jsx(Table.Pagination, { canNextPage: page.canNext, canPreviousPage: page.canPrevious, count: count, nextPage: () => onOffsetChange(page.nextOffset), pageCount: page.pageCount, pageIndex: page.pageIndex, pageSize: limit, previousPage: () => onOffsetChange(page.previousOffset), translations: translations }));
+};

package/.medusa/server/src/admin/admin-components/shared/ui/PdfPreviewModal.d.ts

@@ -0,0 +1,20 @@
+type PdfPreviewModalProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    /** Object URL (or any URL) of the PDF; `null` until loaded. */
+    url: string | null;
+    isLoading?: boolean;
+    /** Shown instead of the PDF. */
+    error?: string | null;
+    /** Accessible title of the frame; default "Vorschau". */
+    frameTitle?: string;
+    loadingText?: string;
+    closeLabel?: string;
+};
+/**
+ * Full-screen PDF preview. Owns no URL: the caller creates the object URL and
+ * revokes it when the modal closes (see `fetchPdfObjectUrl`).
+ */
+export declare const PdfPreviewModal: ({ open, onOpenChange, title, url, isLoading, error, frameTitle, loadingText, closeLabel, }: PdfPreviewModalProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/PdfPreviewModal.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, FocusModal, Text } from "@medusajs/ui";
+/**
+ * Full-screen PDF preview. Owns no URL: the caller creates the object URL and
+ * revokes it when the modal closes (see `fetchPdfObjectUrl`).
+ */
+export const PdfPreviewModal = ({ open, onOpenChange, title, url, isLoading = false, error = null, frameTitle = "Vorschau", loadingText = "Wird geladen.", closeLabel = "Schließen", }) => (_jsx(FocusModal, { onOpenChange: onOpenChange, open: open, children: _jsxs(FocusModal.Content, { children: [_jsx(FocusModal.Header, { children: _jsx(FocusModal.Title, { children: title }) }), _jsx(FocusModal.Body, { className: "h-[75vh] p-0", children: url && !isLoading ? (_jsx("iframe", { className: "h-full w-full border-0", src: url, title: frameTitle })) : error ? (_jsx(Text, { "aria-atomic": "true", "aria-live": "assertive", className: "p-6 text-ui-fg-error", role: "alert", children: error })) : (_jsx(Text, { "aria-atomic": "true", "aria-live": "polite", className: "p-6 text-ui-fg-subtle", role: "status", children: loadingText })) }), _jsx(FocusModal.Footer, { children: _jsx(FocusModal.Close, { asChild: true, children: _jsx(Button, { variant: "secondary", children: closeLabel }) }) })] }) }));

package/.medusa/server/src/admin/admin-components/shared/ui/PluginFeatureRoute.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from "react";
+type PluginFeatureRouteProps = {
+    pluginKey: string;
+    /** Also required to be on; none = plugin switch only. */
+    featureKey?: string;
+    /** Named in the disabled notice when given. */
+    featureLabel?: string;
+    /** Render nothing (instead of the notice) when the toggles cannot be read. */
+    hideOnError?: boolean;
+    children: ReactNode;
+};
+/**
+ * Body of an Admin route (page) that belongs to a plugin or one of its
+ * features: nothing while the toggles load, `children` when on, otherwise the
+ * "disabled" notice that links to the hub. Never flashes the notice for an
+ * enabled plugin.
+ */
+export declare const PluginFeatureRoute: ({ pluginKey, featureKey, featureLabel, hideOnError, children, }: PluginFeatureRouteProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/PluginFeatureRoute.js

@@ -0,0 +1,16 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { PluginFeatureDisabledNotice } from "../../features/plugin-features/components/PluginFeatureGate";
+import { usePluginFeatureEnabled } from "../../features/plugin-features/hooks/usePluginFeatureEnabled";
+/**
+ * Body of an Admin route (page) that belongs to a plugin or one of its
+ * features: nothing while the toggles load, `children` when on, otherwise the
+ * "disabled" notice that links to the hub. Never flashes the notice for an
+ * enabled plugin.
+ */
+export const PluginFeatureRoute = ({ pluginKey, featureKey, featureLabel, hideOnError = false, children, }) => {
+    const { enabled, isPending, isError } = usePluginFeatureEnabled(pluginKey, ...(featureKey ? [featureKey] : []));
+    if (isPending || (hideOnError && isError)) {
+        return null;
+    }
+    return enabled ? (_jsx(_Fragment, { children: children })) : (_jsx(PluginFeatureDisabledNotice, { pluginKey: pluginKey, featureLabel: featureLabel }));
+};

package/.medusa/server/src/admin/admin-components/shared/ui/QueryState.d.ts

@@ -0,0 +1,24 @@
+import type { ReactNode } from "react";
+type QueryStateProps = {
+    isLoading: boolean;
+    error?: unknown;
+    /** Forces the error branch; default `Boolean(error)`. */
+    isError?: boolean;
+    /** Shows `emptyText` instead of `children`. */
+    isEmpty?: boolean;
+    loadingText?: string;
+    /**
+     * A string is shown as is; a function gets the error's message
+     * (`undefined` when it has none) to compose the text.
+     */
+    errorText?: string | ((message: string | undefined) => string);
+    emptyText?: string;
+    children?: ReactNode;
+};
+/**
+ * Body of a section whose data comes from a query: loading, error or empty
+ * text, otherwise `children`. Pass `isLoading` for the first load only
+ * (`isPending` / `isLoading`), `error` as the query's error or `null`.
+ */
+export declare const QueryState: ({ isLoading, error, isError, isEmpty, loadingText, errorText, emptyText, children, }: QueryStateProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/QueryState.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text } from "@medusajs/ui";
+import { getErrorMessage } from "../lib/errors";
+const Message = ({ children, tone = "subtle", }) => (_jsx("div", { className: "px-6 py-8", children: _jsx(Text, { className: tone === "error" ? "text-ui-fg-error" : "text-ui-fg-subtle", role: tone === "error" ? "alert" : "status", children: children }) }));
+/**
+ * Body of a section whose data comes from a query: loading, error or empty
+ * text, otherwise `children`. Pass `isLoading` for the first load only
+ * (`isPending` / `isLoading`), `error` as the query's error or `null`.
+ */
+export const QueryState = ({ isLoading, error, isError, isEmpty = false, loadingText = "Wird geladen…", errorText = "Konnte nicht geladen werden.", emptyText = "Keine Einträge vorhanden.", children, }) => {
+    if (isLoading) {
+        return _jsx(Message, { children: loadingText });
+    }
+    if (isError ?? Boolean(error)) {
+        return (_jsx(Message, { tone: "error", children: typeof errorText === "function"
+                ? errorText(getErrorMessage(error))
+                : errorText }));
+    }
+    if (isEmpty) {
+        return _jsx(Message, { children: emptyText });
+    }
+    return _jsx(_Fragment, { children: children });
+};

package/.medusa/server/src/admin/admin-components/shared/ui/SearchableReferenceField.d.ts

@@ -0,0 +1,63 @@
+import { type ReactNode } from "react";
+export type SearchableReferenceSelected = {
+    title: string;
+    /** Second line, e.g. the record's id. */
+    description?: string;
+    /** Admin route of the record; turns the title into a link. */
+    href?: string;
+    /** Label of the button that clears the selection. */
+    clearLabel?: string;
+    /** Without it the selection has no remove button. */
+    onClear?: () => void;
+};
+export type SearchableReferenceFieldProps<T> = {
+    /** Visible label above the field. */
+    label?: string;
+    /** Accessible name of the search input when there is no visible label. */
+    ariaLabel?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    /** The text in the search input. */
+    value: string;
+    onValueChange: (value: string) => void;
+    /**
+     * The search term the results are for; default `value.trim()`. Results show
+     * only while it has at least `minQueryLength` characters.
+     */
+    query?: string;
+    minQueryLength?: number;
+    /** Called with `query` once it stayed unchanged for `debounceMs`. */
+    onDebouncedQueryChange?: (query: string) => void;
+    /** Default 300. */
+    debounceMs?: number;
+    /** Enter in the search input. */
+    onSubmit?: () => void;
+    /** Results for the debounced query. */
+    items: readonly T[];
+    isLoading: boolean;
+    isError?: boolean;
+    getKey: (item: T) => string;
+    getLabel: (item: T) => string;
+    getDescription?: (item: T) => string | undefined;
+    /** Replaces the default label + description content of a result row. */
+    renderItem?: (item: T) => ReactNode;
+    isItemDisabled?: (item: T) => boolean;
+    onSelect: (item: T) => void;
+    /** Accessible name of the result list. */
+    listLabel?: string;
+    /** The chosen record; replaces the search input unless `keepInputWhenSelected`. */
+    selected?: SearchableReferenceSelected | null;
+    keepInputWhenSelected?: boolean;
+    /** Shown while `query` is shorter than `minQueryLength`, e.g. a hint. */
+    idleText?: ReactNode;
+    searchingText?: string;
+    emptyText?: string;
+    errorText?: string;
+};
+/**
+ * Search input with a result dropdown for picking one record (an order, an
+ * inventory item, an affiliate …). The input updates at once; `isLoading`
+ * shows the searching text while the query is debounced or loading, so the
+ * caller runs its query on the value from `onDebouncedQueryChange`.
+ */
+export declare const SearchableReferenceField: <T>({ label, ariaLabel, placeholder, disabled, value, onValueChange, query: queryProp, minQueryLength, onDebouncedQueryChange, debounceMs, onSubmit, items, isLoading, isError, getKey, getLabel, getDescription, renderItem, isItemDisabled, onSelect, listLabel, selected, keepInputWhenSelected, idleText, searchingText, emptyText, errorText, }: SearchableReferenceFieldProps<T>) => import("react/jsx-runtime").JSX.Element;

package/.medusa/server/src/admin/admin-components/shared/ui/SearchableReferenceField.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Input, Label, Text } from "@medusajs/ui";
+import { useEffect, useId, useLayoutEffect, useRef, useState, } from "react";
+import { Link } from "react-router-dom";
+import { useDebouncedValue } from "../lib/use-debounced-value";
+import { resolveReferenceResultsState } from "./reference-results-state";
+const Message = ({ children, tone = "subtle", }) => (_jsx(Text, { className: `px-3 py-2 ${tone === "error" ? "text-ui-fg-error" : "text-ui-fg-subtle"}`, role: tone === "error" ? "alert" : undefined, size: "small", children: children }));
+/**
+ * Search input with a result dropdown for picking one record (an order, an
+ * inventory item, an affiliate …). The input updates at once; `isLoading`
+ * shows the searching text while the query is debounced or loading, so the
+ * caller runs its query on the value from `onDebouncedQueryChange`.
+ */
+export const SearchableReferenceField = ({ label, ariaLabel, placeholder, disabled = false, value, onValueChange, query: queryProp, minQueryLength = 1, onDebouncedQueryChange, debounceMs = 300, onSubmit, items, isLoading, isError = false, getKey, getLabel, getDescription, renderItem, isItemDisabled, onSelect, listLabel, selected = null, keepInputWhenSelected = false, idleText, searchingText = "Suche …", emptyText = "Keine Treffer.", errorText = "Die Suche ist fehlgeschlagen.", }) => {
+    const query = queryProp ?? value.trim();
+    const debouncedQuery = useDebouncedValue(query, debounceMs);
+    // Layout effect: the caller's state updates before paint, so the stale
+    // result list never flashes for the new query.
+    useLayoutEffect(() => {
+        onDebouncedQueryChange?.(debouncedQuery);
+        // Only a new debounced query counts; the callback may change identity.
+    }, [debouncedQuery]);
+    const inputId = useId();
+    const wrapperRef = useRef(null);
+    const [isOpen, setIsOpen] = useState(false);
+    useEffect(() => {
+        if (!isOpen) {
+            return;
+        }
+        const closeOutside = (event) => {
+            if (!wrapperRef.current?.contains(event.target)) {
+                setIsOpen(false);
+            }
+        };
+        document.addEventListener("mousedown", closeOutside);
+        return () => document.removeEventListener("mousedown", closeOutside);
+    }, [isOpen]);
+    const showInput = !selected || keepInputWhenSelected;
+    const state = resolveReferenceResultsState({
+        query,
+        minQueryLength,
+        hasIdleText: Boolean(idleText),
+        isDebouncing: debouncedQuery !== query,
+        isLoading,
+        isError,
+        itemCount: items.length,
+    });
+    const showDropdown = isOpen && !disabled && state !== "hidden";
+    const renderResults = () => {
+        if (state === "idle") {
+            return _jsx(Message, { children: idleText });
+        }
+        if (state === "searching") {
+            return _jsx(Message, { children: searchingText });
+        }
+        if (state === "error") {
+            return _jsx(Message, { tone: "error", children: errorText });
+        }
+        if (state === "empty") {
+            return _jsx(Message, { children: emptyText });
+        }
+        return (_jsx("ul", { "aria-label": listLabel, className: "flex flex-col", children: items.map((item) => (_jsx("li", { children: _jsx("button", { className: "flex w-full items-center justify-between gap-2 px-3 py-2 text-left text-sm hover:bg-ui-bg-base-hover disabled:cursor-not-allowed disabled:text-ui-fg-disabled disabled:hover:bg-transparent", disabled: disabled || isItemDisabled?.(item) === true, onClick: () => {
+                        onSelect(item);
+                        setIsOpen(false);
+                    }, type: "button", children: renderItem ? (renderItem(item)) : (_jsxs("span", { className: "flex min-w-0 flex-col", children: [_jsx("span", { className: "truncate font-medium", children: getLabel(item) }), getDescription?.(item) ? (_jsx("span", { className: "truncate text-xs text-ui-fg-subtle", children: getDescription(item) })) : null] })) }) }, getKey(item)))) }));
+    };
+    return (_jsxs("div", { className: "grid gap-2", children: [label ? _jsx(Label, { htmlFor: inputId, children: label }) : null, selected ? (_jsxs("div", { className: "flex items-center justify-between gap-2 rounded-md border border-ui-border-base bg-ui-bg-subtle px-3 py-2", children: [_jsxs("div", { className: "min-w-0", children: [_jsx(Text, { size: "small", children: selected.href ? (_jsx(Link, { className: "text-ui-fg-interactive hover:underline", to: selected.href, children: selected.title })) : (selected.title) }), selected.description ? (_jsx(Text, { className: "truncate text-ui-fg-muted", size: "xsmall", children: selected.description })) : null] }), selected.onClear ? (_jsx(Button, { disabled: disabled, onClick: selected.onClear, size: "small", type: "button", variant: "transparent", children: selected.clearLabel })) : null] })) : null, showInput ? (_jsxs("div", { className: "relative", onBlur: (event) => {
+                    const next = event.relatedTarget;
+                    if (next instanceof Node && !event.currentTarget.contains(next)) {
+                        setIsOpen(false);
+                    }
+                }, ref: wrapperRef, children: [_jsx(Input, { "aria-label": ariaLabel, disabled: disabled, id: inputId, onChange: (event) => {
+                            onValueChange(event.target.value);
+                            setIsOpen(true);
+                        }, onFocus: () => setIsOpen(true), onKeyDown: (event) => {
+                            if (event.key === "Escape") {
+                                setIsOpen(false);
+                            }
+                            if (event.key === "Enter" && onSubmit) {
+                                event.preventDefault();
+                                onSubmit();
+                            }
+                        }, placeholder: placeholder, value: value }), showDropdown ? (_jsx("div", { className: "absolute z-10 mt-1 w-full max-h-64 overflow-auto rounded-md border border-ui-border-base bg-ui-bg-base shadow-elevation-card-rest", children: renderResults() })) : null] })) : null] }));
+};

package/.medusa/server/src/admin/admin-components/shared/ui/SectionHeader.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+type SectionHeaderProps = {
+    title: ReactNode;
+    description?: ReactNode;
+    /** Buttons at the end; below the text on narrow screens. */
+    actions?: ReactNode;
+    /** `h1` for the page's own header, `h2` (default) for a section. */
+    level?: "h1" | "h2";
+};
+/**
+ * Header of a section: heading, optional subtle description and optional
+ * actions. Sits at the top of a `Container className="divide-y p-0"`.
+ */
+export declare const SectionHeader: ({ title, description, actions, level, }: SectionHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/SectionHeader.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Heading, Text } from "@medusajs/ui";
+/**
+ * Header of a section: heading, optional subtle description and optional
+ * actions. Sits at the top of a `Container className="divide-y p-0"`.
+ */
+export const SectionHeader = ({ title, description, actions, level = "h2", }) => {
+    const text = (_jsxs("div", { children: [_jsx(Heading, { level: level, children: title }), description ? (_jsx(Text, { className: "text-ui-fg-subtle", children: description })) : null] }));
+    if (!actions) {
+        return _jsx("div", { className: "px-6 py-4", children: text });
+    }
+    return (_jsxs("div", { className: "flex flex-col gap-3 px-6 py-4 sm:flex-row sm:items-start sm:justify-between", children: [text, _jsx("div", { className: "flex shrink-0 gap-2", children: actions })] }));
+};

package/.medusa/server/src/admin/admin-components/shared/ui/mapped-status.d.ts

@@ -0,0 +1,6 @@
+import type { MappedStatus } from "./MappedStatusBadge";
+/**
+ * The status to show for `value`: the entry of `map` (`null` hides the badge),
+ * `fallback` for a value missing from `map`, `null` for an empty value.
+ */
+export declare const resolveMappedStatus: (value: string | null | undefined, map: Record<string, MappedStatus | null>, fallback: MappedStatus | null) => MappedStatus | null;

package/.medusa/server/src/admin/admin-components/shared/ui/mapped-status.js

@@ -0,0 +1,10 @@
+/**
+ * The status to show for `value`: the entry of `map` (`null` hides the badge),
+ * `fallback` for a value missing from `map`, `null` for an empty value.
+ */
+export const resolveMappedStatus = (value, map, fallback) => {
+    if (!value) {
+        return null;
+    }
+    return Object.prototype.hasOwnProperty.call(map, value) ? map[value] : fallback;
+};

package/.medusa/server/src/admin/admin-components/shared/ui/offset-pagination.d.ts

@@ -0,0 +1,17 @@
+type OffsetPaginationInput = {
+    count: number;
+    offset: number;
+    limit: number;
+    /** Highest offset the API accepts; the next page is disabled beyond it. */
+    maxOffset?: number;
+};
+/** Page math of an offset/limit list. */
+export declare const getOffsetPagination: ({ count, offset, limit, maxOffset, }: OffsetPaginationInput) => {
+    pageIndex: number;
+    pageCount: number;
+    nextOffset: number;
+    previousOffset: number;
+    canPrevious: boolean;
+    canNext: boolean;
+};
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/offset-pagination.js

@@ -0,0 +1,15 @@
+/** Page math of an offset/limit list. */
+export const getOffsetPagination = ({ count, offset, limit, maxOffset, }) => {
+    const pageIndex = Math.floor(offset / limit);
+    const pageCount = Math.max(1, Math.ceil(count / limit));
+    const nextOffset = offset + limit;
+    return {
+        pageIndex,
+        pageCount,
+        nextOffset,
+        previousOffset: Math.max(0, offset - limit),
+        canPrevious: pageIndex > 0,
+        canNext: pageIndex < pageCount - 1 &&
+            (maxOffset === undefined || nextOffset <= maxOffset),
+    };
+};

package/.medusa/server/src/admin/admin-components/shared/ui/reference-results-state.d.ts

@@ -0,0 +1,16 @@
+export type ReferenceResultsState = "hidden" | "idle" | "searching" | "error" | "empty" | "list";
+type ReferenceResultsInput = {
+    /** The search term the results are for. */
+    query: string;
+    minQueryLength: number;
+    /** Whether there is a hint to show while `query` is too short. */
+    hasIdleText: boolean;
+    /** The debounced query still differs from `query`. */
+    isDebouncing: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    itemCount: number;
+};
+/** What the result dropdown of `SearchableReferenceField` shows. */
+export declare const resolveReferenceResultsState: ({ query, minQueryLength, hasIdleText, isDebouncing, isLoading, isError, itemCount, }: ReferenceResultsInput) => ReferenceResultsState;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/reference-results-state.js

@@ -0,0 +1,13 @@
+/** What the result dropdown of `SearchableReferenceField` shows. */
+export const resolveReferenceResultsState = ({ query, minQueryLength, hasIdleText, isDebouncing, isLoading, isError, itemCount, }) => {
+    if (query.length < minQueryLength) {
+        return hasIdleText ? "idle" : "hidden";
+    }
+    if (isDebouncing || (isLoading && !isError)) {
+        return "searching";
+    }
+    if (isError) {
+        return "error";
+    }
+    return itemCount === 0 ? "empty" : "list";
+};

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/InsertMenu.d.ts

@@ -0,0 +1,8 @@
+interface InsertMenuProps<T extends string> {
+    label: string;
+    options: readonly T[];
+    labels: Record<T, string>;
+    onSelect: (option: T) => void;
+}
+export declare const InsertMenu: <T extends string>({ label, options, labels, onSelect, }: InsertMenuProps<T>) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/InsertMenu.js

@@ -0,0 +1,10 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Button, DropdownMenu } from "@medusajs/ui";
+// A toolbar dropdown listing what can be inserted; nothing when there are no
+// options.
+export const InsertMenu = ({ label, options, labels, onSelect, }) => {
+    if (!options.length) {
+        return null;
+    }
+    return (_jsxs(DropdownMenu, { children: [_jsx(DropdownMenu.Trigger, { asChild: true, children: _jsxs(Button, { size: "small", type: "button", variant: "secondary", children: [label, " \u25BE"] }) }), _jsx(DropdownMenu.Content, { align: "start", onCloseAutoFocus: (event) => event.preventDefault(), children: options.map((option) => (_jsx(DropdownMenu.Item, { onSelect: () => onSelect(option), children: labels[option] }, option))) })] }));
+};

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/LinkPrompt.d.ts

@@ -0,0 +1,14 @@
+interface LinkPromptProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Href of the link under the cursor, empty for a new one. */
+    initialHref: string;
+    onApply: (href: string) => void;
+    onRemove: () => void;
+    /** The link targets the editor accepts (`getLinkPolicy(editor)`). */
+    isAllowedHref: (href: string) => boolean;
+    /** Shown when the typed target is not accepted. */
+    invalidMessage?: string;
+}
+export declare const LinkPrompt: ({ open, onOpenChange, initialHref, onApply, onRemove, isAllowedHref, invalidMessage, }: LinkPromptProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/LinkPrompt.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Input, Prompt, Text } from "@medusajs/ui";
+import { useState } from "react";
+import { normalizeLinkHref } from "./link-href";
+// Asks for a link target; only what `isAllowedHref` accepts is applied.
+export const LinkPrompt = ({ open, onOpenChange, initialHref, onApply, onRemove, isAllowedHref, invalidMessage = "Bitte eine gültige Adresse eingeben.", }) => {
+    const [value, setValue] = useState(initialHref);
+    const [error, setError] = useState(null);
+    const apply = () => {
+        const href = normalizeLinkHref(value, isAllowedHref);
+        if (!href) {
+            setError(invalidMessage);
+            return;
+        }
+        onApply(href);
+    };
+    return (_jsx(Prompt, { open: open, onOpenChange: onOpenChange, children: _jsxs(Prompt.Content, { children: [_jsxs(Prompt.Header, { children: [_jsx(Prompt.Title, { children: "Link" }), _jsx(Prompt.Description, { children: "Web-Adresse oder E-Mail-Adresse, auf die der markierte Text verweist." })] }), _jsxs("div", { className: "flex flex-col gap-2 px-6 pb-4", children: [_jsx(Input, { "aria-label": "Link-Adresse", autoFocus: true, onChange: (event) => {
+                                setValue(event.target.value);
+                                setError(null);
+                            }, onKeyDown: (event) => {
+                                if (event.key === "Enter") {
+                                    event.preventDefault();
+                                    apply();
+                                }
+                            }, placeholder: "https://", value: value }), error ? (_jsx(Text, { className: "text-ui-fg-error", role: "alert", size: "small", children: error })) : null] }), _jsxs(Prompt.Footer, { children: [initialHref ? (_jsx(Button, { onClick: onRemove, type: "button", variant: "secondary", children: "Link entfernen" })) : null, _jsx(Prompt.Cancel, { children: "Abbrechen" }), _jsx(Button, { onClick: apply, type: "button", children: "\u00DCbernehmen" })] })] }) }));
+};

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/RichTextEditor.d.ts

@@ -0,0 +1,15 @@
+import type { Editor } from "@tiptap/react";
+import type { ReactNode } from "react";
+interface RichTextEditorProps {
+    editor: Editor;
+    /** Shown by the link prompt for a target the editor's link policy rejects. */
+    linkInvalidMessage?: string;
+    /** Added to the editor's wrapper, to scope `styles` to it. */
+    className?: string;
+    /** CSS appended to the base styles, for the owner's nodes. */
+    styles?: string;
+    /** Controls after the formatting buttons, e.g. insert menus. */
+    toolbarExtra?: ReactNode;
+}
+export declare const RichTextEditor: ({ editor, linkInvalidMessage, className, styles, toolbarExtra, }: RichTextEditorProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/RichTextEditor.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EditorContent } from "@tiptap/react";
+import { RICH_TEXT_EDITOR_STYLES } from "./editor-styles";
+import { RichTextToolbar } from "./RichTextToolbar";
+// Toolbar and writing area of a rich-text field. The styles are a plain
+// stylesheet because Tailwind's reset removes list markers and node views
+// live inside ProseMirror's own DOM.
+export const RichTextEditor = ({ editor, linkInvalidMessage, className, styles, toolbarExtra, }) => (_jsxs("div", { className: `rte-editor${className ? ` ${className}` : ""} border-ui-border-base bg-ui-bg-base rounded-md border`, children: [_jsx("style", { children: `${RICH_TEXT_EDITOR_STYLES}${styles ?? ""}` }), _jsx(RichTextToolbar, { editor: editor, linkInvalidMessage: linkInvalidMessage, children: toolbarExtra }), _jsx(EditorContent, { editor: editor })] }));

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/RichTextToolbar.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "@tiptap/react";
+import type { ReactNode } from "react";
+interface RichTextToolbarProps {
+    editor: Editor;
+    linkInvalidMessage?: string;
+    /** Controls of the owner, shown after the formatting buttons. */
+    children?: ReactNode;
+}
+export declare const RichTextToolbar: ({ editor, linkInvalidMessage, children, }: RichTextToolbarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/.medusa/server/src/admin/admin-components/shared/ui/rich-text-editor/RichTextToolbar.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "@medusajs/ui";
+import { useEditorState } from "@tiptap/react";
+import { useState } from "react";
+import { LinkPrompt } from "./LinkPrompt";
+import { getLinkPolicy } from "./link-policy";
+// Formatting buttons above the editor; a button appears only when the editor
+// has the mark or node it toggles.
+export const RichTextToolbar = ({ editor, linkInvalidMessage, children, }) => {
+    const [linkOpen, setLinkOpen] = useState(false);
+    const [linkHref, setLinkHref] = useState("");
+    const active = useEditorState({
+        editor,
+        selector: ({ editor: current }) => ({
+            bold: current?.isActive("bold") ?? false,
+            italic: current?.isActive("italic") ?? false,
+            link: current?.isActive("link") ?? false,
+            bulletList: current?.isActive("bulletList") ?? false,
+        }),
+    });
+    const { marks, nodes } = editor.schema;
+    const openLink = () => {
+        setLinkHref(editor.isActive("link")
+            ? String(editor.getAttributes("link").href ?? "")
+            : "");
+        setLinkOpen(true);
+    };
+    const applyLink = (href) => {
+        const chain = editor.chain().focus();
+        if (editor.isActive("link") || !editor.state.selection.empty) {
+            chain.extendMarkRange("link").setLink({ href }).run();
+        }
+        else {
+            chain
+                .insertContent({
+                type: "text",
+                text: href,
+                marks: [{ type: "link", attrs: { href } }],
+            })
+                .run();
+        }
+        setLinkOpen(false);
+    };
+    const removeLink = () => {
+        editor.chain().focus().extendMarkRange("link").unsetLink().run();
+        setLinkOpen(false);
+    };
+    return (_jsxs("div", { className: "border-ui-border-base flex flex-wrap items-center gap-2 border-b px-3 py-2", children: [marks.bold ? (_jsx(Button, { "aria-pressed": active.bold, onClick: () => editor.chain().focus().toggleBold().run(), size: "small", type: "button", variant: active.bold ? "primary" : "secondary", children: "Fett" })) : null, marks.italic ? (_jsx(Button, { "aria-pressed": active.italic, onClick: () => editor.chain().focus().toggleItalic().run(), size: "small", type: "button", variant: active.italic ? "primary" : "secondary", children: "Kursiv" })) : null, marks.link ? (_jsx(Button, { "aria-pressed": active.link, onClick: openLink, size: "small", type: "button", variant: active.link ? "primary" : "secondary", children: "Link" })) : null, nodes.bulletList ? (_jsx(Button, { "aria-pressed": active.bulletList, onClick: () => editor.chain().focus().toggleBulletList().run(), size: "small", type: "button", variant: active.bulletList ? "primary" : "secondary", children: "Aufz\u00E4hlung" })) : null, children, linkOpen ? (_jsx(LinkPrompt, { initialHref: linkHref, invalidMessage: linkInvalidMessage, isAllowedHref: getLinkPolicy(editor), onApply: applyLink, onOpenChange: setLinkOpen, onRemove: removeLink, open: true })) : null] }));
+};