@reforma/components 0.0.0-stage → 0.1.0

package/dist/Shimmer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Shimmer/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}

package/dist/Shimmer/index.js

@@ -0,0 +1,7 @@
+import { Shimmer as o } from "./Shimmer.js";
+import { ShimmerBlock as f } from "./ShimmerBlock.js";
+export {
+  o as Shimmer,
+  f as ShimmerBlock
+};
+//# sourceMappingURL=index.js.map

package/dist/Shimmer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/Show/Show.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+/** Values treated as falsy by `Show` (aligned with `if (value)` in JavaScript; `NaN` is still `number` at the type level). */
+export type ShowFalsy = false | null | undefined | 0 | 0n | '';
+/** `when` narrowed to values that pass the `Show` truthiness check. */
+export type ShowTruthy<T> = T extends ShowFalsy ? never : T;
+export interface ShowProps<T = unknown> {
+    when: T;
+    fallback?: ReactNode;
+    children: ReactNode | ((when: ShowTruthy<T>) => ReactNode);
+}
+export declare function Show<T>({ when, fallback, children }: ShowProps<T>): ReactNode;
+export declare namespace Show {
+    var displayName: string;
+}
+//# sourceMappingURL=Show.d.ts.map

package/dist/Show/Show.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Show.d.ts","sourceRoot":"","sources":["../../src/Show/Show.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,8HAA8H;AAC9H,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;AAE/D,uEAAuE;AACvE,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AAE5D,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IAClC,IAAI,EAAE,CAAC,CAAC;IACR,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;CAC9D;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,QAAe,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAUpF;yBAVe,IAAI"}

package/dist/Show/Show.js

@@ -0,0 +1,12 @@
+function f({
+  when: o,
+  fallback: u = null,
+  children: t
+}) {
+  return o ? typeof t == "function" ? t(o) : t : u;
+}
+f.displayName = "Show";
+export {
+  f as Show
+};
+//# sourceMappingURL=Show.js.map

package/dist/Show/Show.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Show.js","sources":["../../src/Show/Show.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\n\n/** Values treated as falsy by `Show` (aligned with `if (value)` in JavaScript; `NaN` is still `number` at the type level). */\nexport type ShowFalsy = false | null | undefined | 0 | 0n | '';\n\n/** `when` narrowed to values that pass the `Show` truthiness check. */\nexport type ShowTruthy<T> = T extends ShowFalsy ? never : T;\n\nexport interface ShowProps<T = unknown> {\n    when: T;\n    fallback?: ReactNode;\n    children: ReactNode | ((when: ShowTruthy<T>) => ReactNode);\n}\n\nexport function Show<T>({ when, fallback = null, children }: ShowProps<T>): ReactNode {\n    if (when) {\n        if (typeof children === 'function') {\n            return (children as (value: ShowTruthy<T>) => ReactNode)(when as ShowTruthy<T>);\n        }\n\n        return children;\n    }\n\n    return fallback;\n}\n\nShow.displayName = 'Show';\n"],"names":["Show","when","fallback","children"],"mappings":"AAIO,SAASA,EAAK;AAAA,EACnB,MAAAC;AAAA,EACA,UAAAC,IAAW;AAAA,EACX,UAAAC;AACF,GAAG;AACD,SAAIF,IACE,OAAOE,KAAa,aACfA,EAASF,CAAI,IAEfE,IAEFD;AACT;AACAF,EAAK,cAAc;"}

package/dist/Show/index.d.ts

@@ -0,0 +1,2 @@
+export { Show, type ShowFalsy, type ShowProps, type ShowTruthy } from './Show';
+//# sourceMappingURL=index.d.ts.map

package/dist/Show/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Show/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAC"}

package/dist/Show/index.js

@@ -0,0 +1,5 @@
+import { Show as e } from "./Show.js";
+export {
+  e as Show
+};
+//# sourceMappingURL=index.js.map

package/dist/Show/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/Slot/Slot.d.ts

@@ -0,0 +1,28 @@
+import React, { ReactNode, type ReactElement } from 'react';
+import type { SlotProps } from 'react-aria-components';
+export { DEFAULT_SLOT } from 'react-aria-components';
+type SlotFilter = ((slot: string) => boolean) | readonly string[] | string;
+export declare const SlotContext: React.Context<any>;
+export declare function useSlotContext<T>(slot?: string | null): T | null | undefined;
+/**
+ * React 19 adapter for RAC's useContextProps. Merges props (including ref) from SlotContext.
+ * Slots must include DEFAULT_SLOT for components used without an explicit slot.
+ *
+ * Returns props WITHOUT the `slot` property — `slot` is consumed by this hook to look up
+ * the matching SlotContext entry, and should not be forwarded to the rendered element.
+ */
+export declare function useSlotContextProps<T extends SlotProps & {
+    ref?: React.Ref<any>;
+}>({ ref, slot, ...rest }: T): Omit<T, 'slot'>;
+export declare function filterSlots(children: ReactNode, filter: SlotFilter, defaultChildren?: ReactNode): ReactNode;
+/**
+ * Renders content as a named slot, merging it with slot-specific props from the parent Provider
+ * (e.g. className from slots.label). Use when passing prop-based content that should participate
+ * in the slot system—e.g. <Slot as="div" slot="startAffix">{ startAffix }</Slot>.
+ */
+export declare function Slot({ as, children, slot, ...rest }: {
+    as?: React.ElementType;
+    slot?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLElement>): ReactElement<unknown, string | React.JSXElementConstructor<any>>[] | ReactElement<any, string | React.JSXElementConstructor<any>>;
+//# sourceMappingURL=Slot.d.ts.map

package/dist/Slot/Slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slot.d.ts","sourceRoot":"","sources":["../../src/Slot/Slot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAGV,SAAS,EACT,KAAK,YAAY,EACpB,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,KAAK,UAAU,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;AAe3E,eAAO,MAAM,WAAW,oBAAoD,CAAC;AAE7E,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,CAE5E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;CAAE,EAC9E,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC,GAC1B,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAajB;AAED,wBAAgB,WAAW,CACvB,QAAQ,EAAE,SAAS,EACnB,MAAM,EAAE,UAAU,EAClB,eAAe,CAAC,EAAE,SAAS,GAC5B,SAAS,CAYX;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,EAAE,EAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,EAAE;IAAE,EAAE,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,GAAG,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,qIAWzK"}

package/dist/Slot/Slot.js

@@ -0,0 +1,55 @@
+import r, { Fragment as i, createContext as a } from "react";
+import { useSlottedContext as p, useContextProps as f, DEFAULT_SLOT as x } from "react-aria-components";
+import { DEFAULT_SLOT as L } from "react-aria-components";
+function g(t) {
+  return typeof t == "string" ? (e) => e === t : Array.isArray(t) ? (e) => t.includes(e) : t;
+}
+const l = /* @__PURE__ */ a({});
+function S(t) {
+  return p(l, t);
+}
+function y({
+  ref: t,
+  slot: e,
+  ...o
+}) {
+  const [s, u] = f({
+    ...o,
+    slot: e ?? x
+  }, t, l), {
+    slot: c,
+    ...n
+  } = s;
+  return {
+    ...n,
+    ref: u
+  };
+}
+function A(t, e, o) {
+  const s = g(e), c = /* @__PURE__ */ r.isValidElement(t) && t.type === i ? t.props.children : t, n = r.Children.toArray(c).filter((m) => s(/* @__PURE__ */ r.isValidElement(m) ? m.props?.slot : ""));
+  return n.length ? n : o;
+}
+function E({
+  as: t = i,
+  children: e,
+  slot: o,
+  ...s
+}) {
+  const c = {
+    ...p(l, o),
+    ...s,
+    ...o != null && {
+      slot: o
+    }
+  };
+  return t === i ? r.Children.toArray(e).map((n) => /* @__PURE__ */ r.cloneElement(n, c)) : /* @__PURE__ */ r.createElement(t, c, e);
+}
+export {
+  L as DEFAULT_SLOT,
+  E as Slot,
+  l as SlotContext,
+  A as filterSlots,
+  S as useSlotContext,
+  y as useSlotContextProps
+};
+//# sourceMappingURL=Slot.js.map

package/dist/Slot/Slot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slot.js","sources":["../../src/Slot/Slot.tsx"],"sourcesContent":["import React, {\n    createContext,\n    Fragment,\n    ReactNode,\n    type ReactElement,\n} from 'react';\nimport { ContextValue, DEFAULT_SLOT, useContextProps, useSlottedContext } from 'react-aria-components';\n\nimport type { SlotProps } from 'react-aria-components';\n\nexport { DEFAULT_SLOT } from 'react-aria-components';\n\ntype SlotFilter = ((slot: string) => boolean) | readonly string[] | string;\n\nfunction toPredicate(filter: SlotFilter): (slot: string) => boolean {\n    if (typeof filter === 'string') {\n        return slot => slot === filter;\n    }\n\n    if (Array.isArray(filter)) {\n        return slot => filter.includes(slot);\n    }\n\n    return filter as (slot: string) => boolean;\n}\n\n\nexport const SlotContext = createContext<ContextValue<any, HTMLElement>>({});\n\nexport function useSlotContext<T>(slot?: string | null): T | null | undefined {\n    return useSlottedContext(SlotContext, slot) as T | null | undefined;\n}\n\n/**\n * React 19 adapter for RAC's useContextProps. Merges props (including ref) from SlotContext.\n * Slots must include DEFAULT_SLOT for components used without an explicit slot.\n *\n * Returns props WITHOUT the `slot` property — `slot` is consumed by this hook to look up\n * the matching SlotContext entry, and should not be forwarded to the rendered element.\n */\nexport function useSlotContextProps<T extends SlotProps & { ref?: React.Ref<any> }>(\n    { ref, slot, ...rest }: T\n): Omit<T, 'slot'> {\n    const [mergedProps, mergedRef] = useContextProps(\n        {\n            ...rest,\n            slot: slot ?? DEFAULT_SLOT,\n        } as T & SlotProps,\n        ref,\n        SlotContext\n    );\n\n    const { slot: _slot, ...mergedRest } = mergedProps as T & SlotProps;\n\n    return { ...mergedRest, ref: mergedRef };\n}\n\nexport function filterSlots(\n    children: ReactNode,\n    filter: SlotFilter,\n    defaultChildren?: ReactNode\n): ReactNode {\n    const predicate = toPredicate(filter);\n    const isFragment = React.isValidElement(children) && children.type === Fragment;\n    const content: ReactNode = isFragment\n        ? (children as React.ReactElement<{ children?: ReactNode }>).props.children\n        : children;\n\n    const slots = React.Children.toArray(content).filter(\n        child => predicate(React.isValidElement(child) ? (child.props as SlotProps)?.slot as string : '')\n    );\n\n    return slots.length ? slots : defaultChildren;\n}\n\n/**\n * Renders content as a named slot, merging it with slot-specific props from the parent Provider\n * (e.g. className from slots.label). Use when passing prop-based content that should participate\n * in the slot system—e.g. <Slot as=\"div\" slot=\"startAffix\">{ startAffix }</Slot>.\n */\nexport function Slot({ as = Fragment, children, slot, ...rest }: { as?: React.ElementType; slot?: string; children?: React.ReactNode } & React.HTMLAttributes<HTMLElement>) {\n    const context = useSlottedContext(SlotContext, slot);\n    const mergedProps = { ...context, ...rest, ...(slot != null && { slot }) };\n\n    if (as === Fragment) {\n        return React.Children.toArray(children).map(\n            child => React.cloneElement(child as ReactElement, mergedProps)\n        );\n    }\n\n    return React.createElement(as, mergedProps, children);\n}\n"],"names":["toPredicate","filter","slot","SlotContext","createContext","useSlotContext","useSlottedContext","useSlotContextProps","ref","rest","mergedProps","mergedRef","useContextProps","DEFAULT_SLOT","_slot","mergedRest","filterSlots","children","defaultChildren","predicate","content","React","Fragment","slots","child","Slot","as"],"mappings":";;;AAGA,SAASA,EAAYC,GAAQ;AAC3B,SAAI,OAAOA,KAAW,WACb,OAAQC,MAASD,IAEtB,MAAM,QAAQA,CAAM,IACf,CAAAC,MAAQD,EAAO,SAASC,CAAI,IAE9BD;AACT;AACO,MAAME,IAA2B,gBAAAC,EAAc,CAAA,CAAE;AACjD,SAASC,EAAeH,GAAM;AACnC,SAAOI,EAAkBH,GAAaD,CAAI;AAC5C;AASO,SAASK,EAAoB;AAAA,EAClC,KAAAC;AAAA,EACA,MAAAN;AAAA,EACA,GAAGO;AACL,GAAG;AACD,QAAM,CAACC,GAAaC,CAAS,IAAIC,EAAgB;AAAA,IAC/C,GAAGH;AAAA,IACH,MAAMP,KAAQW;AAAA,EAAA,GACbL,GAAKL,CAAW,GACb;AAAA,IACJ,MAAMW;AAAA,IACN,GAAGC;AAAA,EAAA,IACDL;AACJ,SAAO;AAAA,IACL,GAAGK;AAAA,IACH,KAAKJ;AAAA,EAAA;AAET;AACO,SAASK,EAAYC,GAAUhB,GAAQiB,GAAiB;AAC7D,QAAMC,IAAYnB,EAAYC,CAAM,GAE9BmB,IAD0BC,gBAAAA,EAAM,eAAeJ,CAAQ,KAAKA,EAAS,SAASK,IACvDL,EAAS,MAAM,WAAWA,GACjDM,IAAQF,EAAM,SAAS,QAAQD,CAAO,EAAE,OAAO,CAAAI,MAASL,EAAuBE,gBAAAA,EAAM,eAAeG,CAAK,IAAIA,EAAM,OAAO,OAAO,EAAE,CAAC;AAC1I,SAAOD,EAAM,SAASA,IAAQL;AAChC;AAOO,SAASO,EAAK;AAAA,EACnB,IAAAC,IAAKJ;AAAA,EACL,UAAAL;AAAA,EACA,MAAAf;AAAA,EACA,GAAGO;AACL,GAAG;AAED,QAAMC,IAAc;AAAA,IAClB,GAFcJ,EAAkBH,GAAaD,CAAI;AAAA,IAGjD,GAAGO;AAAA,IACH,GAAIP,KAAQ,QAAQ;AAAA,MAClB,MAAAA;AAAA,IAAA;AAAA,EACF;AAEF,SAAIwB,MAAOJ,IACFD,EAAM,SAAS,QAAQJ,CAAQ,EAAE,IAAI,CAAAO,MAAsBH,gBAAAA,EAAM,aAAaG,GAAOd,CAAW,CAAC,IAEtFW,gBAAAA,EAAM,cAAcK,GAAIhB,GAAaO,CAAQ;AACnE;"}

package/dist/Slot/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Slot';
+//# sourceMappingURL=index.d.ts.map

package/dist/Slot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Slot/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/Slot/index.js

@@ -0,0 +1,11 @@
+import { Slot as e, SlotContext as l, filterSlots as r, useSlotContext as S, useSlotContextProps as x } from "./Slot.js";
+import { DEFAULT_SLOT as f } from "react-aria-components";
+export {
+  f as DEFAULT_SLOT,
+  e as Slot,
+  l as SlotContext,
+  r as filterSlots,
+  S as useSlotContext,
+  x as useSlotContextProps
+};
+//# sourceMappingURL=index.js.map

package/dist/Slot/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/SortableList/SortableList.d.ts

@@ -0,0 +1,69 @@
+import type { ReactNode } from 'react';
+export type SortableListDragHandleAlignment = 'center' | 'top';
+export type SortableListDragHandleEdgeOffset = 'none' | 'sm' | 'md';
+export type SortableListDragHandleVariant = 'plain' | 'surface';
+export interface SortableListDragHandleOptions {
+    alignment?: SortableListDragHandleAlignment;
+    edgeOffset?: SortableListDragHandleEdgeOffset;
+    variant?: SortableListDragHandleVariant;
+}
+export interface SortableListItemContext<T> {
+    level: number;
+    parent: T | null;
+    index: number;
+    siblingCount: number;
+    isFirst: boolean;
+    isLast: boolean;
+    hasChildren: boolean;
+    canHaveChildren: boolean;
+}
+export interface SortableListItemRenderProps<T> extends SortableListItemContext<T> {
+    nestedItems: ReactNode;
+    isDragging: boolean;
+    isDropTarget: boolean;
+}
+export interface SortableListDropContext<T> {
+    items: readonly T[];
+    target: T | null;
+    sourceParent: T | null;
+    sourceLevel: number;
+    parent: T | null;
+    targetLevel: number;
+    dropPosition: 'on' | 'before' | 'after' | 'end';
+}
+interface SortableListBaseProps<T> {
+    items: readonly T[];
+    getKey?: (item: T, path: readonly number[]) => string;
+    getTextValue: (item: T) => string;
+    onChange: (items: T[]) => void;
+    children: (item: T, props: SortableListItemRenderProps<T>) => ReactNode;
+    canDrop?: (context: SortableListDropContext<T>) => boolean;
+    getDragHandleOptions?: (item: T, context: SortableListItemContext<T>) => SortableListDragHandleOptions;
+    className?: string;
+    gap?: 'sm' | 'md';
+    nestedGap?: 'sm' | 'md';
+    'aria-label': string;
+}
+interface FlatSortableListProps {
+    getChildren?: never;
+    setChildren?: never;
+    canHaveChildren?: never;
+}
+interface NestedSortableListProps<T> {
+    getChildren: (item: T) => readonly T[];
+    setChildren: (item: T, children: T[]) => T;
+    canHaveChildren?: (item: T) => boolean;
+}
+export type SortableListProps<T> = SortableListBaseProps<T> & (FlatSortableListProps | NestedSortableListProps<T>);
+/**
+ * Sortable collection with a dedicated pointer handle and optional child groups.
+ *
+ * The rendered item is the complete draggable surface. Child collections can
+ * accept moves when the caller's drop rules allow it.
+ */
+export declare function SortableList<T>({ items, getKey: getItemKey, getTextValue, getChildren, setChildren, canHaveChildren, onChange, children, canDrop, getDragHandleOptions, className, gap, nestedGap, 'aria-label': ariaLabel, }: SortableListProps<T>): import("react").JSX.Element;
+export declare namespace SortableList {
+    var displayName: string;
+}
+export {};
+//# sourceMappingURL=SortableList.d.ts.map

package/dist/SortableList/SortableList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SortableList.d.ts","sourceRoot":"","sources":["../../src/SortableList/SortableList.tsx"],"names":[],"mappings":"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"}

package/dist/SortableList/SortableList.js

@@ -0,0 +1,349 @@
+import { DragDropProvider as Z, PointerSensor as G, DragOverlay as ee, useDroppable as ne } from "@dnd-kit/react";
+import { isSortable as _, useSortable as te } from "@dnd-kit/react/sortable";
+import { DotsDrag as re } from "@reforma/icons/14";
+import { cn as ie } from "@reforma/lib";
+import { useRef as j, useCallback as oe, useMemo as ae } from "react";
+import { For as F } from "../For/For.js";
+import f from "./SortableList.module.css.js";
+import { buildSortableTree as le, moveSortableTreeNodeToIndex as se, restoreSortableTree as ce, findSortableTreeNode as $ } from "./sortableTree.js";
+import { jsxs as w, jsx as o } from "react/jsx-runtime";
+const A = "reforma-sortable:root", D = "reforma-sortable:children:", de = "reforma-sortable:item", ue = "reforma-sortable:collection", fe = [G], me = "sortable:primitive:";
+function ge({
+  items: e,
+  getKey: n,
+  getTextValue: t,
+  getChildren: r,
+  setChildren: i,
+  canHaveChildren: a,
+  onChange: u,
+  children: h,
+  canDrop: m,
+  getDragHandleOptions: x,
+  className: P,
+  gap: y = "md",
+  nestedGap: s = y,
+  "aria-label": S
+}) {
+  const g = j({
+    nextId: 0,
+    objectKeys: /* @__PURE__ */ new WeakMap()
+  }), T = oe((c, v) => {
+    const C = n?.(c, v);
+    if (C != null)
+      return C;
+    if (typeof c != "object" || c == null)
+      return `${me}${v.join(".")}`;
+    const d = g.current.objectKeys.get(c);
+    if (d)
+      return d;
+    const b = `sortable:item:${g.current.nextId}`;
+    return g.current.nextId += 1, g.current.objectKeys.set(c, b), b;
+  }, [n]), p = ae(() => le(e, {
+    getKey: T,
+    getTextValue: t,
+    getChildren: r,
+    canHaveChildren: a
+  }), [a, r, T, t, e]), I = j({
+    items: e,
+    revision: 0
+  });
+  I.current.items !== e && (I.current = {
+    items: e,
+    revision: I.current.revision + 1
+  });
+  function J(c) {
+    const {
+      canceled: v,
+      operation: C
+    } = c, {
+      source: d,
+      target: b
+    } = C;
+    if (v || !d || !_(d))
+      return;
+    const E = O(d)?.node;
+    if (!E)
+      return;
+    const N = q(b), L = N?.kind === "node" ? N.node : null;
+    let l;
+    if (N?.kind === "collection" ? l = {
+      parentNode: N.parentNode,
+      index: N.parentNode?.children.length ?? p.length,
+      dropPosition: "end"
+    } : L && b && _(b) ? l = ve(p, b.group, d.index, L) : l = null, !l)
+      return;
+    const Q = W(E, l.parentNode, L, l.dropPosition);
+    if (!X(E, l.parentNode) || m && !m(Q))
+      return;
+    const K = V(d.initialGroup), R = l.parentNode?.id ?? null;
+    if (K !== void 0 && K === R && d.initialIndex === l.index)
+      return;
+    const U = se(p, E.id, R, l.index);
+    u(ce(U, i));
+  }
+  return /* @__PURE__ */ w(Z, {
+    sensors: fe,
+    onDragEnd: J,
+    children: [/* @__PURE__ */ o(H, {
+      nodes: p,
+      rootNodes: p,
+      parentNode: null,
+      renderItem: h,
+      canDrop: m,
+      getDragHandleOptions: x,
+      className: P,
+      gap: y,
+      nestedGap: s,
+      ariaLabel: S
+    }), /* @__PURE__ */ o(ee, {
+      className: f.dragOverlay,
+      dropAnimation: {
+        duration: 160,
+        easing: "cubic-bezier(0.25, 1, 0.5, 1)"
+      },
+      children: (c) => {
+        const v = O(c)?.node;
+        return v ? /* @__PURE__ */ o(M, {
+          node: v,
+          renderItem: h,
+          nestedGap: s
+        }) : null;
+      }
+    })]
+  }, I.current.revision);
+}
+function H({
+  nodes: e,
+  rootNodes: n,
+  parentNode: t,
+  renderItem: r,
+  canDrop: i,
+  getDragHandleOptions: a,
+  className: u,
+  gap: h,
+  nestedGap: m,
+  ariaLabel: x
+}) {
+  const {
+    ref: P,
+    isDropTarget: y
+  } = ne({
+    id: be(t),
+    type: ue,
+    data: {
+      kind: "collection",
+      parentNode: t
+    },
+    disabled: e.length > 0,
+    collisionPriority: 1,
+    accept: (s) => B(s, t, null, "end", i)
+  });
+  return /* @__PURE__ */ o("div", {
+    ref: P,
+    role: "list",
+    className: ie(f.list, u),
+    "data-gap": h,
+    "data-drop-target": y || void 0,
+    "aria-label": x,
+    children: /* @__PURE__ */ o(F, {
+      each: e,
+      children: (s) => /* @__PURE__ */ o(pe, {
+        node: s,
+        rootNodes: n,
+        renderItem: r,
+        canDrop: i,
+        getDragHandleOptions: a,
+        nestedGap: m
+      }, s.id)
+    })
+  });
+}
+function pe({
+  node: e,
+  rootNodes: n,
+  renderItem: t,
+  canDrop: r,
+  getDragHandleOptions: i,
+  nestedGap: a
+}) {
+  const u = Y(e), {
+    alignment: h = "center",
+    edgeOffset: m = "none",
+    variant: x = "plain"
+  } = i?.(e.value, u) ?? {}, {
+    handleRef: P,
+    ref: y,
+    targetRef: s,
+    isDragging: S,
+    isDropTarget: g
+  } = te({
+    id: e.id,
+    index: e.index,
+    group: z(he(n, e)),
+    type: de,
+    data: {
+      kind: "node",
+      node: e
+    },
+    accept: (p) => B(p, e.parent == null ? null : k(n, e), e, "before", r)
+  }), T = e.canHaveChildren ? /* @__PURE__ */ o(H, {
+    nodes: e.children,
+    rootNodes: n,
+    parentNode: e,
+    renderItem: t,
+    canDrop: r,
+    getDragHandleOptions: i,
+    gap: a,
+    nestedGap: a,
+    ariaLabel: `${e.textValue} items`
+  }) : null;
+  return /* @__PURE__ */ w("div", {
+    ref: y,
+    role: "listitem",
+    className: f.item,
+    "data-level": e.level,
+    "data-dragging": S || void 0,
+    "data-drop-target": g || void 0,
+    children: [/* @__PURE__ */ o("div", {
+      ref: s,
+      className: f.dropTarget,
+      "data-container": e.canHaveChildren || void 0,
+      "aria-hidden": !0
+    }), /* @__PURE__ */ o("span", {
+      ref: P,
+      className: f.dragHandle,
+      "data-alignment": h,
+      "data-edge-offset": m,
+      "data-variant": x,
+      "aria-hidden": !0,
+      children: /* @__PURE__ */ o(re, {
+        "aria-hidden": !0,
+        width: 14,
+        height: 14
+      })
+    }), /* @__PURE__ */ o("div", {
+      className: f.content,
+      children: t(e.value, {
+        ...u,
+        nestedItems: T,
+        isDragging: S,
+        isDropTarget: g
+      })
+    })]
+  });
+}
+function M({
+  node: e,
+  renderItem: n,
+  nestedGap: t
+}) {
+  const r = e.canHaveChildren ? /* @__PURE__ */ o("div", {
+    className: f.previewList,
+    "data-gap": t,
+    children: /* @__PURE__ */ o(F, {
+      each: e.children,
+      children: (i) => /* @__PURE__ */ o(M, {
+        node: i,
+        renderItem: n,
+        nestedGap: t
+      }, i.id)
+    })
+  }) : null;
+  return /* @__PURE__ */ o("div", {
+    className: f.dragPreviewItem,
+    children: n(e.value, {
+      ...Y(e),
+      nestedItems: r,
+      isDragging: !1,
+      isDropTarget: !1
+    })
+  });
+}
+function Y(e) {
+  return {
+    level: e.level,
+    parent: e.parent,
+    index: e.index,
+    siblingCount: e.siblingCount,
+    isFirst: e.index === 0,
+    isLast: e.index === e.siblingCount - 1,
+    hasChildren: e.children.length > 0,
+    canHaveChildren: e.canHaveChildren
+  };
+}
+function B(e, n, t, r, i) {
+  const a = O(e)?.node;
+  return !a || !X(a, n) ? !1 : i?.(W(a, n, t, r)) ?? !0;
+}
+function W(e, n, t, r) {
+  return {
+    items: [e.value],
+    target: t?.value ?? null,
+    sourceParent: e.parent,
+    sourceLevel: e.level,
+    parent: n?.value ?? null,
+    targetLevel: n ? n.level + 1 : 1,
+    dropPosition: r
+  };
+}
+function X(e, n) {
+  return n == null || n.id !== e.id && $(e.children, n.id) == null;
+}
+function ve(e, n, t, r) {
+  const i = V(n);
+  if (i === void 0)
+    return null;
+  const a = i == null ? null : $(e, i);
+  if (i != null && !a)
+    return null;
+  const u = r != null && t > r.index;
+  return {
+    parentNode: a,
+    index: t,
+    dropPosition: u ? "after" : "before"
+  };
+}
+function be(e) {
+  return z(e?.id ?? null);
+}
+function z(e) {
+  return e == null ? A : `${D}${e}`;
+}
+function V(e) {
+  if (e === A)
+    return null;
+  if (typeof e == "string" && e.startsWith(D))
+    return e.slice(D.length);
+}
+function he(e, n) {
+  return k(e, n)?.id ?? null;
+}
+function k(e, n) {
+  for (const t of e) {
+    if (t.children.some((i) => i.id === n.id))
+      return t;
+    const r = k(t.children, n);
+    if (r)
+      return r;
+  }
+  return null;
+}
+function q(e) {
+  const n = e?.data;
+  return n?.kind === "node" && "node" in n ? {
+    kind: "node",
+    node: n.node
+  } : n?.kind === "collection" && "parentNode" in n ? {
+    kind: "collection",
+    parentNode: n.parentNode
+  } : null;
+}
+function O(e) {
+  const n = q(e);
+  return n?.kind === "node" ? n : null;
+}
+ge.displayName = "SortableList";
+export {
+  ge as SortableList
+};
+//# sourceMappingURL=SortableList.js.map