@godxjp/ui 13.9.2 → 13.10.0

package/dist/components/data-entry/tree-select.js

@@ -1,13 +1,299 @@
-export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeSelect } from '../../chunk-DIH7VPGN.js';
-import '../../chunk-SMLKNECP.js';
-import '../../chunk-2RGPEFAW.js';
-import '../../chunk-XBFUROAY.js';
-import '../../chunk-BE6GJGKJ.js';
-import '../../chunk-44YRPSZ7.js';
-import '../../chunk-DY5C44UP.js';
-import '../../chunk-J2DEWIYY.js';
-import '../../chunk-B4K4BXEF.js';
-import '../../chunk-7PWBC4BY.js';
-import '../../chunk-B6S6LTWT.js';
-import '../../chunk-5732TWQF.js';
-import '../../chunk-U7N2A7A3.js';
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { ChevronDown, ChevronRight, ChevronsUpDown, X } from "lucide-react";
+import { useTranslation } from "../../i18n/use-translation";
+import { cn } from "../../lib/utils";
+import { controlOpenRingClass } from "../../lib/control-styles";
+import { Button } from "../general/button";
+import { Popover, PopoverContent, PopoverTrigger } from "../data-display/popover";
+import { ScrollArea } from "../data-display/scroll-area";
+import { Checkbox } from "./checkbox";
+import { Command, CommandInput } from "./command";
+import {
+  collectAllExpandableKeys,
+  filterVisibleTree,
+  findNodeByValue,
+  flattenVisibleTree,
+  getDescendantValues,
+  normalizeTreeOptions,
+  reactNodeText
+} from "./tree-utils";
+import { SHOW_CHILD, SHOW_PARENT, SHOW_ALL } from "./tree-select-strategy";
+import { SHOW_CHILD as SHOW_CHILD2, SHOW_PARENT as SHOW_PARENT2, SHOW_ALL as SHOW_ALL2 } from "./tree-select-strategy";
+function toArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function displayValues(values, options, showCheckedStrategy, treeCheckStrictly) {
+  if (treeCheckStrictly || showCheckedStrategy === SHOW_ALL2) return values;
+  if (showCheckedStrategy === SHOW_PARENT2) {
+    const filtered = values.filter((v) => {
+      const node = findNodeByValue(options, v);
+      if (!node?.children?.length) return true;
+      const desc = getDescendantValues(node).slice(1);
+      return !desc.every((d) => values.includes(d));
+    });
+    return filtered.length ? filtered : values;
+  }
+  return values.filter((v) => {
+    const node = findNodeByValue(options, v);
+    return !node?.children?.length;
+  });
+}
+function TreeSelectRoot({
+  treeData: treeDataProp,
+  value,
+  defaultValue,
+  onValueChange,
+  multiple,
+  treeCheckable,
+  treeCheckStrictly,
+  showSearch,
+  showCheckedStrategy = SHOW_CHILD2,
+  treeDefaultExpandAll,
+  placeholder,
+  disabled,
+  allowClear = true,
+  className,
+  id,
+  fieldNames
+}) {
+  const { t } = useTranslation();
+  const options = React.useMemo(
+    () => normalizeTreeOptions(treeDataProp, fieldNames),
+    [treeDataProp, fieldNames]
+  );
+  const checkable = treeCheckable ?? multiple;
+  const [open, setOpen] = React.useState(false);
+  const [search, setSearch] = React.useState("");
+  const [expandedKeys, setExpandedKeys] = React.useState(
+    () => new Set(treeDefaultExpandAll ? collectAllExpandableKeys(options) : [])
+  );
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React.useState(() => toArray(defaultValue));
+  const [activeKey, setActiveKey] = React.useState(null);
+  const treeItemRefs = React.useRef(/* @__PURE__ */ new Map());
+  const selected = isControlled ? toArray(value) : internal;
+  const resolvedPlaceholder = placeholder ?? t("dataEntry.treeSelect.placeholder");
+  const visible = React.useMemo(() => {
+    if (showSearch && search.trim()) return filterVisibleTree(options, search);
+    return flattenVisibleTree(options, expandedKeys);
+  }, [options, expandedKeys, search, showSearch]);
+  const commit = (next) => {
+    if (!isControlled) setInternal(next);
+    onValueChange?.(checkable || multiple ? next : next[0] ?? void 0);
+  };
+  const toggleExpand = (key) => {
+    setExpandedKeys((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  };
+  const toggleSelect = (node) => {
+    if (node.disabled) return;
+    const key = node.value;
+    if (!checkable && !multiple) {
+      commit([key]);
+      setOpen(false);
+      return;
+    }
+    const isOn = selected.includes(key);
+    let next;
+    if (treeCheckStrictly) {
+      next = isOn ? selected.filter((v) => v !== key) : [...selected, key];
+    } else {
+      const related = getDescendantValues(node);
+      next = isOn ? selected.filter((v) => !related.includes(v)) : [.../* @__PURE__ */ new Set([...selected, ...related])];
+    }
+    commit(next);
+  };
+  const displayKeys = displayValues(selected, options, showCheckedStrategy, treeCheckStrictly);
+  const displayLabel = displayKeys.map((v) => {
+    const label = findNodeByValue(options, v)?.label;
+    return label ? reactNodeText(label) : v;
+  }).join(", ");
+  const clearValue = (e) => {
+    e.stopPropagation();
+    commit([]);
+  };
+  const rovingKey = (activeKey && visible.some(({ node }) => node.value === activeKey) ? activeKey : null) ?? visible[0]?.node.value ?? null;
+  React.useEffect(() => {
+    if (!open || !activeKey) return;
+    treeItemRefs.current.get(activeKey)?.focus();
+  }, [activeKey, open, visible]);
+  const focusByOffset = (currentValue, delta) => {
+    const index = visible.findIndex(({ node }) => node.value === currentValue);
+    if (index === -1) return;
+    const next = visible[index + delta];
+    if (next) setActiveKey(next.node.value);
+  };
+  const onTreeItemKeyDown = (event, node, hasChildren, expanded) => {
+    switch (event.key) {
+      case "ArrowDown": {
+        event.preventDefault();
+        focusByOffset(node.value, 1);
+        break;
+      }
+      case "ArrowUp": {
+        event.preventDefault();
+        focusByOffset(node.value, -1);
+        break;
+      }
+      case "ArrowRight": {
+        event.preventDefault();
+        if (hasChildren && !expanded) {
+          toggleExpand(node.value);
+        } else if (hasChildren && expanded) {
+          focusByOffset(node.value, 1);
+        }
+        break;
+      }
+      case "ArrowLeft": {
+        event.preventDefault();
+        if (hasChildren && expanded) {
+          toggleExpand(node.value);
+        }
+        break;
+      }
+      case "Enter":
+      case " ": {
+        event.preventDefault();
+        toggleSelect(node);
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  return /* @__PURE__ */ jsxs(Popover, { open, onOpenChange: setOpen, children: [
+    /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+      Button,
+      {
+        id,
+        type: "button",
+        variant: "outline",
+        role: "combobox",
+        "aria-expanded": open,
+        disabled,
+        className: cn(
+          "w-full justify-between font-normal",
+          controlOpenRingClass,
+          !displayKeys.length && "text-muted-foreground",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "truncate", children: displayKeys.length ? displayLabel : resolvedPlaceholder }),
+          /* @__PURE__ */ jsxs("span", { className: "ms-2 flex shrink-0 items-center gap-1", children: [
+            allowClear && displayKeys.length > 0 && !disabled && /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                "aria-label": t("dataEntry.treeSelect.clear"),
+                className: "flex size-4 items-center justify-center rounded-sm opacity-50 hover:opacity-100 focus-visible:opacity-100",
+                onClick: clearValue,
+                children: /* @__PURE__ */ jsx(X, { className: "size-4", "aria-hidden": "true" })
+              }
+            ),
+            /* @__PURE__ */ jsx(ChevronsUpDown, { className: "size-4 opacity-50", "aria-hidden": "true" })
+          ] })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(PopoverContent, { className: "w-[var(--radix-popover-trigger-width)] p-0", align: "start", children: [
+      showSearch && /* @__PURE__ */ jsx("div", { className: "border-b p-2", children: /* @__PURE__ */ jsx(Command, { shouldFilter: false, children: /* @__PURE__ */ jsx(
+        CommandInput,
+        {
+          placeholder: t("dataEntry.treeSelect.searchPlaceholder"),
+          value: search,
+          onValueChange: setSearch
+        }
+      ) }) }),
+      /* @__PURE__ */ jsx(ScrollArea, { className: "max-h-[min(300px,50vh)]", children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          role: "tree",
+          "aria-multiselectable": Boolean(checkable) || Boolean(multiple),
+          className: "p-1",
+          children: visible.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground py-6 text-center text-sm", children: t("dataEntry.treeSelect.empty") }) : visible.map(({ node, depth, hasChildren }) => {
+            const expanded = expandedKeys.has(node.value);
+            const isSelected = selected.includes(node.value);
+            return /* @__PURE__ */ jsxs(
+              "div",
+              {
+                ref: (el) => {
+                  treeItemRefs.current.set(node.value, el);
+                },
+                role: "treeitem",
+                tabIndex: node.disabled ? -1 : rovingKey === node.value ? 0 : -1,
+                "aria-expanded": hasChildren ? expanded : void 0,
+                "aria-selected": isSelected,
+                onFocus: () => setActiveKey(node.value),
+                onKeyDown: (event) => onTreeItemKeyDown(event, node, hasChildren, expanded),
+                className: cn(
+                  "flex items-center rounded-sm py-1.5 pe-2 text-sm outline-none",
+                  "hover:bg-accent hover:text-accent-foreground",
+                  "focus-visible:ring-ring focus-visible:ring-2 focus-visible:ring-offset-1",
+                  isSelected && "bg-accent/60",
+                  node.disabled && "pointer-events-none opacity-50"
+                ),
+                style: { paddingInlineStart: `${depth * 1.25 + 0.5}rem` },
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      tabIndex: -1,
+                      "aria-label": expanded ? t("dataEntry.treeSelect.collapse") : t("dataEntry.treeSelect.expand"),
+                      className: cn(
+                        "me-1 flex size-5 shrink-0 items-center justify-center rounded-sm",
+                        !hasChildren && "invisible"
+                      ),
+                      onClick: () => toggleExpand(node.value),
+                      children: expanded ? /* @__PURE__ */ jsx(ChevronDown, { className: "size-4", "aria-hidden": "true" }) : /* @__PURE__ */ jsx(ChevronRight, { className: "size-4", "aria-hidden": "true" })
+                    }
+                  ),
+                  checkable ? /* @__PURE__ */ jsxs("label", { className: "flex flex-1 cursor-pointer items-center gap-2", children: [
+                    /* @__PURE__ */ jsx(
+                      Checkbox,
+                      {
+                        checked: isSelected,
+                        tabIndex: -1,
+                        disabled: Boolean(node.disabled) || Boolean(node.disableCheckbox),
+                        onCheckedChange: () => toggleSelect(node)
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("span", { className: "truncate", children: node.label })
+                  ] }) : /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      tabIndex: -1,
+                      className: "flex-1 truncate text-start",
+                      disabled: node.disabled,
+                      onClick: () => toggleSelect(node),
+                      children: node.label
+                    }
+                  )
+                ]
+              },
+              node.value
+            );
+          })
+        }
+      ) })
+    ] })
+  ] });
+}
+const TreeSelect = Object.assign(TreeSelectRoot, {
+  SHOW_CHILD: SHOW_CHILD2,
+  SHOW_PARENT: SHOW_PARENT2,
+  SHOW_ALL: SHOW_ALL2
+});
+export {
+  SHOW_ALL,
+  SHOW_CHILD,
+  SHOW_PARENT,
+  TreeSelect
+};

package/dist/components/data-entry/tree-utils.d.ts

@@ -0,0 +1,48 @@
+import type * as React from "react";
+/** Normalized tree node — Ant Design `treeData` / Cascader `options`. */
+export type TreeOption = {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    /** When false with `loadData`, shows expand affordance */
+    isLeaf?: boolean;
+    children?: TreeOption[];
+};
+export type TreeFieldNames = {
+    label?: string;
+    value?: string;
+    children?: string;
+};
+export type NormalizedTreeOption = TreeOption & {
+    children?: NormalizedTreeOption[];
+};
+type RawTreeNode = Record<string, unknown>;
+export declare function reactNodeText(value: React.ReactNode): string;
+export declare function normalizeTreeOptions(nodes: RawTreeNode[] | undefined, fieldNames?: TreeFieldNames): NormalizedTreeOption[];
+export declare function getNodeByPath(options: NormalizedTreeOption[], path: string[]): NormalizedTreeOption[];
+export declare function getOptionsAtPath(options: NormalizedTreeOption[], path: string[]): NormalizedTreeOption[];
+export declare function formatPathLabels(chain: NormalizedTreeOption[], separator?: string): string;
+export type TreePath = {
+    path: string[];
+    labels: string[];
+};
+export declare function collectLeafPaths(options: NormalizedTreeOption[], prefix?: string[], root?: NormalizedTreeOption[]): TreePath[];
+export declare function collectAllPaths(options: NormalizedTreeOption[], prefix?: string[], root?: NormalizedTreeOption[]): TreePath[];
+export declare function pathKey(path: string[]): string;
+export declare function pathsEqual(a: string[], b: string[]): boolean;
+export declare function filterTreeOptions(options: NormalizedTreeOption[], query: string, filter?: (query: string, path: NormalizedTreeOption[]) => boolean): TreePath[];
+export declare function getDescendantValues(node: NormalizedTreeOption): string[];
+export declare function flattenVisibleTree(options: NormalizedTreeOption[], expandedKeys: Set<string>, depth?: number): {
+    node: NormalizedTreeOption;
+    depth: number;
+    hasChildren: boolean;
+}[];
+export declare function filterVisibleTree(options: NormalizedTreeOption[], query: string): {
+    node: NormalizedTreeOption;
+    depth: number;
+    hasChildren: boolean;
+}[];
+export declare function collectAllExpandableKeys(options: NormalizedTreeOption[]): string[];
+export declare function findNodeByValue(options: NormalizedTreeOption[], value: string): NormalizedTreeOption | undefined;
+export {};

package/dist/{chunk-SMLKNECP.js → components/data-entry/tree-utils.js}

@@ -1,4 +1,3 @@
-// src/components/data-entry/tree-utils.ts
 function reactNodeText(value) {
   if (value == null || typeof value === "boolean") return "";
   if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
@@ -45,6 +44,11 @@ function getNodeByPath(options, path) {
   }
   return chain;
 }
+function getOptionsAtPath(options, path) {
+  if (!path.length) return options;
+  const chain = getNodeByPath(options, path);
+  return chain.at(-1)?.children ?? [];
+}
 function formatPathLabels(chain, separator = " / ") {
   return chain.map((n) => reactNodeText(n.label)).join(separator);
 }
@@ -60,6 +64,15 @@ function collectLeafPaths(options, prefix = [], root = options) {
   }
   return out;
 }
+function collectAllPaths(options, prefix = [], root = options) {
+  const out = [];
+  for (const node of options) {
+    const path = [...prefix, node.value];
+    out.push({ path, labels: getNodeByPath(root, path).map((n) => reactNodeText(n.label)) });
+    if (node.children?.length) out.push(...collectAllPaths(node.children, path, root));
+  }
+  return out;
+}
 function pathKey(path) {
   return path.join("\0");
 }
@@ -100,7 +113,7 @@ function filterVisibleTree(options, query) {
     let branchMatch = false;
     for (const node of nodes) {
       const selfMatch = reactNodeText(node.label).toLowerCase().includes(q);
-      const childMatch = node.children?.length ? walk(node.children) : false;
+      const childMatch = node.children?.length ? walk(node.children, depth + 1) : false;
       if (selfMatch || childMatch) {
         branchMatch = true;
         if (childMatch) expanded.add(node.value);
@@ -108,7 +121,7 @@ function filterVisibleTree(options, query) {
     }
     return branchMatch;
   }
-  walk(options);
+  walk(options, 0);
   return flattenVisibleTree(options, expanded);
 }
 function collectAllExpandableKeys(options) {
@@ -129,5 +142,20 @@ function findNodeByValue(options, value) {
   }
   return void 0;
 }
-
-export { collectAllExpandableKeys, filterTreeOptions, filterVisibleTree, findNodeByValue, flattenVisibleTree, formatPathLabels, getDescendantValues, getNodeByPath, normalizeTreeOptions, pathKey, pathsEqual, reactNodeText };
+export {
+  collectAllExpandableKeys,
+  collectAllPaths,
+  collectLeafPaths,
+  filterTreeOptions,
+  filterVisibleTree,
+  findNodeByValue,
+  flattenVisibleTree,
+  formatPathLabels,
+  getDescendantValues,
+  getNodeByPath,
+  getOptionsAtPath,
+  normalizeTreeOptions,
+  pathKey,
+  pathsEqual,
+  reactNodeText
+};

package/dist/components/data-entry/upload-crop-dialog.d.ts

@@ -0,0 +1,9 @@
+interface UploadCropDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    file: File | null;
+    onConfirm: (cropped: File) => void;
+}
+/** Simple 1:1 avatar crop — canvas export, no extra deps. */
+export declare function UploadCropDialog({ open, onOpenChange, file, onConfirm }: UploadCropDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-entry/upload-crop-dialog.js

@@ -0,0 +1,102 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { useTranslation } from "../../i18n/use-translation";
+import { cn } from "../../lib/utils";
+import { Button } from "../general/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from "../feedback/dialog";
+import { Slider } from "./slider";
+function UploadCropDialog({ open, onOpenChange, file, onConfirm }) {
+  const { t } = useTranslation();
+  const [scale, setScale] = React.useState(1.2);
+  const [src, setSrc] = React.useState(null);
+  const imgRef = React.useRef(null);
+  React.useEffect(() => {
+    if (!file) {
+      setSrc(null);
+      return;
+    }
+    const url = URL.createObjectURL(file);
+    setSrc(url);
+    return () => URL.revokeObjectURL(url);
+  }, [file]);
+  const handleConfirm = async () => {
+    const img = imgRef.current;
+    if (!img || !file) return;
+    const size = 256;
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return;
+    const iw = img.naturalWidth;
+    const ih = img.naturalHeight;
+    const side = Math.min(iw, ih) / scale;
+    const sx = (iw - side) / 2;
+    const sy = (ih - side) / 2;
+    ctx.drawImage(img, sx, sy, side, side, 0, 0, size, size);
+    const blob = await new Promise(
+      (resolve) => canvas.toBlob(resolve, "image/jpeg", 0.92)
+    );
+    if (!blob) return;
+    const cropped = new File([blob], file.name.replace(/\.\w+$/, "") + ".jpg", {
+      type: "image/jpeg"
+    });
+    onConfirm(cropped);
+    onOpenChange(false);
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(DialogContent, { className: "max-w-sm", children: [
+    /* @__PURE__ */ jsxs(DialogHeader, { children: [
+      /* @__PURE__ */ jsx(DialogTitle, { children: t("dataEntry.upload.cropTitle") }),
+      /* @__PURE__ */ jsx(DialogDescription, { children: t("dataEntry.upload.cropDescription") })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "ui-stack-sm", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: cn(
+            "bg-muted relative mx-auto size-48 overflow-hidden rounded-full border",
+            "flex items-center justify-center"
+          ),
+          children: src ? /* @__PURE__ */ jsx(
+            "img",
+            {
+              ref: imgRef,
+              src,
+              alt: "",
+              className: "size-full object-cover transition-transform duration-150",
+              style: { transform: `scale(${scale})` }
+            }
+          ) : null
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "ui-stack-xs px-2", children: [
+        /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-xs", children: t("dataEntry.upload.cropZoom") }),
+        /* @__PURE__ */ jsx(
+          Slider,
+          {
+            min: 1,
+            max: 2.5,
+            step: 0.05,
+            value: [scale],
+            onValueChange: (v) => setScale(v[0] ?? 1),
+            "aria-label": t("dataEntry.upload.cropZoom")
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(DialogFooter, { children: [
+      /* @__PURE__ */ jsx(Button, { variant: "ghost", onClick: () => onOpenChange(false), children: t("common.cancel") }),
+      /* @__PURE__ */ jsx(Button, { onClick: () => void handleConfirm(), children: t("dataEntry.upload.cropConfirm") })
+    ] })
+  ] }) });
+}
+export {
+  UploadCropDialog
+};

package/dist/components/data-entry/upload-types.d.ts

@@ -0,0 +1,39 @@
+/** Upload item — maps to media-service after `onUpload` resolves `mediaId`. */
+export type UploadFileStatus = "idle" | "uploading" | "done" | "error" | "removed";
+export type UploadFileItem = {
+    /** Stable key for list reconciliation */
+    uid: string;
+    name: string;
+    size: number;
+    mimeType?: string;
+    /** Blob URL or media-service download URL */
+    previewUrl?: string;
+    /** Set after issue → PUT → complete */
+    mediaId?: string;
+    status: UploadFileStatus;
+    error?: string;
+    /** Local file before / during upload */
+    file?: File;
+    /**
+     * Draft-only: marked for soft-delete on form commit.
+     * Undo clears this before save — media-service has no restore API.
+     */
+    pendingDelete?: boolean;
+    /**
+     * Draft-only: replacement staged locally; baseline kept for undo.
+     */
+    pendingReplace?: boolean;
+    /** mediaId to soft-delete on commit when `pendingReplace` */
+    replacesMediaId?: string;
+};
+export type UploadVariant = "dropzone" | "button" | "picture-card" | "picture" | "avatar" | "avatar-crop";
+/** Actions parent runs on form submit (media-service). */
+export type UploadCommitAction = {
+    /** Soft-delete on save — no restore API */
+    deleteMediaIds: string[];
+    /** Temp uploads already completed via `onUpload` — promote on save */
+    promoteMediaIds: string[];
+};
+export declare function createUploadItem(file: File, partial?: Partial<UploadFileItem>): UploadFileItem;
+export declare function revokePreviewUrl(item: UploadFileItem | null | undefined): void;
+export declare function collectUploadCommitActions(items: UploadFileItem[]): UploadCommitAction;

package/dist/components/data-entry/upload-types.js

@@ -0,0 +1,41 @@
+function createUploadItem(file, partial) {
+  const previewUrl = file.type.startsWith("image/") ? URL.createObjectURL(file) : void 0;
+  return {
+    uid: partial?.uid ?? crypto.randomUUID(),
+    name: file.name,
+    size: file.size,
+    mimeType: file.type,
+    previewUrl,
+    status: "idle",
+    file,
+    ...partial
+  };
+}
+function revokePreviewUrl(item) {
+  if (item?.previewUrl?.startsWith("blob:")) URL.revokeObjectURL(item.previewUrl);
+}
+function collectUploadCommitActions(items) {
+  const deleteMediaIds = [];
+  const promoteMediaIds = [];
+  for (const item of items) {
+    if (item.pendingDelete && item.mediaId) {
+      deleteMediaIds.push(item.mediaId);
+      continue;
+    }
+    if (item.pendingReplace && item.replacesMediaId) {
+      deleteMediaIds.push(item.replacesMediaId);
+    }
+    if (item.mediaId && !item.pendingDelete && item.status !== "error") {
+      promoteMediaIds.push(item.mediaId);
+    }
+  }
+  return {
+    deleteMediaIds: [...new Set(deleteMediaIds)],
+    promoteMediaIds: [...new Set(promoteMediaIds)]
+  };
+}
+export {
+  collectUploadCommitActions,
+  createUploadItem,
+  revokePreviewUrl
+};

package/dist/components/data-entry/upload.d.ts

@@ -1,45 +1,6 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { x as UploadFileItem, U as UploadCommitAction, z as UploadProp } from '../../data-entry.prop-BSUaseKh.js';
-export { y as UploadFileItemProp, A as UploadVariant, B as UploadVariantProp, E as collectUploadCommitActions, G as createUploadItem } from '../../data-entry.prop-BSUaseKh.js';
-import '@radix-ui/react-checkbox';
-import '@radix-ui/react-radio-group';
-import '@radix-ui/react-slider';
-import '@radix-ui/react-switch';
-import 'react-day-picker';
-import 'react';
-import '../../shared.prop-BvMSLFJ6.js';
-import '../../content.prop-DrV_zDy-.js';
-import '../../layout.prop-CXvl2rVR.js';
-import '../../interaction.prop-DD46aTro.js';
-import '../../data.prop-D0UEEczj.js';
-import '../../layout.prop-fCz-Vlie.js';
-import '../../navigation.prop-CXDaVNaR.js';
-
-type UploadDraftState = {
-    /** Item rendered in UI (may reflect pending delete/replace). */
-    display: UploadFileItem | null;
-    /** Server baseline — restored on undo remove/replace. */
-    baseline: UploadFileItem | null;
-    canUndoRemove: boolean;
-    canUndoReplace: boolean;
-};
-type UseUploadDraftOptions = {
-    value?: UploadFileItem | null;
-    onChange?: (item: UploadFileItem | null) => void;
-};
-/**
- * Single-value draft for avatar / picture — coordinates with media-service:
- * soft-delete only on form commit; undo before save (no restore API).
- */
-declare function useUploadDraft({ value, onChange }: UseUploadDraftOptions): {
-    state: UploadDraftState;
-    markRemove: () => void;
-    undoRemove: () => void;
-    stageReplace: (file: File) => void;
-    undoReplace: () => void;
-    getCommitActions: () => UploadCommitAction;
-};
-
-declare function Upload({ variant, value, defaultValue, onValueChange, accept: acceptProp, multiple: multipleProp, maxCount: maxCountProp, maxSizeBytes, disabled, removable, onUpload, className, children, }: UploadProp): react_jsx_runtime.JSX.Element;
-
-export { Upload, UploadCommitAction, UploadFileItem, UploadProp, UploadProp as UploadProps, useUploadDraft };
+import type { UploadProp } from "../../props/components/data-entry.prop";
+export type { UploadProp, UploadProp as UploadProps, UploadFileItemProp, UploadVariantProp, } from "../../props/components/data-entry.prop";
+export type { UploadFileItem, UploadVariant, UploadCommitAction } from "./upload-types";
+export { collectUploadCommitActions, createUploadItem } from "./upload-types";
+export { useUploadDraft } from "./use-upload-draft";
+export declare function Upload({ variant, value, defaultValue, onValueChange, accept: acceptProp, multiple: multipleProp, maxCount: maxCountProp, maxSizeBytes, disabled, removable, onUpload, className, children, }: UploadProp): import("react/jsx-runtime").JSX.Element;