@multiplatform.one/backoffice 6.4.2 → 6.6.0

package/dist/jsx/list/DoctypeListScreen.mjs

@@ -0,0 +1,815 @@
+import { EmptyState, H1, PageHeader, Paragraph, ScrollView, Spinner, ViewSwitcher, XStack, YStack, isWeb, notify } from "@multiplatform.one/components";
+import { useLayoutSizeClass } from "@multiplatform.one/theme";
+import { Button as ActionButton } from "@multiplatform.one/forms";
+import { ArrowsClockwiseIcon, PlusIcon, SidebarSimpleIcon } from "@phosphor-icons/react";
+import { FrappeTable, docFieldsToFilterFields, useFrappeAggregate, useFrappeConfig } from "@multiplatform.one/frappe-ui";
+import { DataTablePagination } from "@multiplatform.one/table";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { actionsForDoctype, useBackofficeCapabilities, useBackofficeConfig, useBackofficeNavigator, useBackofficePaths, useBackofficeSlots } from "../config/BackofficeProvider.mjs";
+import { BACKOFFICE_I18N_NAMESPACE } from "../i18n/index.mjs";
+import { BACKOFFICE_VIEWS } from "../navigation/paths.mjs";
+import { QuickEntryDialog } from "../quickEntry/QuickEntryDialog.mjs";
+import { useRecentVisit } from "../shared/useRecentVisit.mjs";
+import { buildPermLevelMatrix } from "../form/fieldPermissions.mjs";
+import { useDoctypeMeta } from "../shared/useDoctypeMeta.mjs";
+import { useFrappeApp } from "../shared/useFrappeApp.mjs";
+import { useUserRoles } from "../shared/useUserRoles.mjs";
+import { AddTagsDialog } from "./AddTagsDialog.mjs";
+import { AssignToDialog } from "./AssignToDialog.mjs";
+import { bulkDelete, toggleLike } from "./bulkActions.mjs";
+import { BulkEditDialog } from "./bulk-edit-dialog.mjs";
+import { bulkExportCsv } from "./bulk-export.mjs";
+import { bulkSubmitCancel } from "./bulk-submit-cancel.mjs";
+import { FilterChips } from "./filter-chips.mjs";
+import { frappeFiltersToTableFilters, sameFilterTuple, tableStateToFrappeFilters } from "./filterConversion.mjs";
+import { ListFilterBar } from "./ListFilterBar.mjs";
+import { ListSidebar } from "./ListSidebar.mjs";
+import { buildListColumns } from "./listColumns.mjs";
+import { listFieldsToFetch } from "./listFields.mjs";
+import { parseFiltersParam, parseSortParam, serializeFiltersParam, serializeSortParam } from "./listUrlState.mjs";
+import { useSessionUserId as useSessionUser } from "../shared/useSessionUserId.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+const PAGE_SIZES = [20, 100, 500];
+const ListTable = FrappeTable;
+function sameFilters(a, b) {
+  return a.length === b.length && a.every((tuple, index) => sameFilterTuple(tuple, b[index]));
+}
+function sameSort(a, b) {
+  return (a?.field ?? null) === (b?.field ?? null) && (a?.order ?? null) === (b?.order ?? null);
+}
+function DoctypeListScreen({
+  doctype,
+  filtersParam,
+  sortParam,
+  metaOverride,
+  views: viewsAllowlist,
+  initialFilters,
+  fixedFilters,
+  columnOverrides,
+  pageSize,
+  onRowOpen,
+  hideNewButton,
+  toolbarActions
+}) {
+  const {
+    t
+  } = useTranslation(BACKOFFICE_I18N_NAMESPACE);
+  const navigator = useBackofficeNavigator();
+  const paths = useBackofficePaths();
+  const capabilities = useBackofficeCapabilities();
+  const {
+    actions,
+    emitEvent
+  } = useBackofficeConfig();
+  const slots = useBackofficeSlots();
+  const config = useFrappeConfig();
+  const app = useFrappeApp();
+  const fixtureMode = Boolean(config?.fixtures);
+  const sessionUser = useSessionUser();
+  const compactChrome = useLayoutSizeClass() === "compact";
+  useRecentVisit(fixtureMode ? void 0 : {
+    label: doctype,
+    path: paths.list(doctype)
+  });
+  const {
+    meta: loadedMeta,
+    loading: metaLoading,
+    error: metaError
+  } = useDoctypeMeta(metaOverride ? void 0 : doctype);
+  const meta = metaOverride ?? loadedMeta;
+  useEffect(() => {
+    if (metaError && !meta) emitEvent({
+      type: "error",
+      error: metaError,
+      context: "list-meta"
+    });
+  }, [metaError, meta, emitEvent]);
+  const showNew = !hideNewButton && capabilities.newDoc.enabled;
+  const [baseFilters, setBaseFilters] = useState(() => {
+    const fromParam = parseFiltersParam(filtersParam);
+    if (fromParam.length > 0) return fromParam;
+    return initialFilters ? [...initialFilters] : fromParam;
+  });
+  const [filtersGen, setFiltersGen] = useState(0);
+  const [effectiveFilters, setEffectiveFilters] = useState(null);
+  const [sort, setSort] = useState(() => parseSortParam(sortParam) ?? null);
+  const [sortGen, setSortGen] = useState(0);
+  const [refreshGen, setRefreshGen] = useState(0);
+  const [sidebarVisible, setSidebarVisible] = useState(true);
+  const [quickEntryOpen, setQuickEntryOpen] = useState(false);
+  const [pendingDialog, setPendingDialog] = useState(null);
+  const [likeOverrides, setLikeOverrides] = useState({});
+  const pageSizeRef = useRef(pageSize ?? PAGE_SIZES[0]);
+  const fixedFiltersKey = JSON.stringify(fixedFilters ?? []);
+  const fixedTuples = useMemo(() => JSON.parse(fixedFiltersKey), [fixedFiltersKey]);
+  const withFixed = useCallback(filters => fixedTuples.length > 0 ? [...fixedTuples, ...filters] : filters, [fixedTuples]);
+  const initialFiltersRef = useRef(initialFilters);
+  initialFiltersRef.current = initialFilters;
+  const baseFiltersRef = useRef(baseFilters);
+  baseFiltersRef.current = baseFilters;
+  const sortRef = useRef(sort);
+  sortRef.current = sort;
+  const writeUrlState = useCallback((filters, sortState) => {
+    navigator.setParams?.({
+      f: serializeFiltersParam(filters),
+      sort: sortState ? serializeSortParam(sortState) : void 0
+    });
+  }, [navigator]);
+  const lastDoctype = useRef(doctype);
+  const lastFiltersParam = useRef(filtersParam);
+  const lastSortParam = useRef(sortParam);
+  useEffect(() => {
+    const doctypeChanged = lastDoctype.current !== doctype;
+    const filtersParamChanged = lastFiltersParam.current !== filtersParam;
+    const sortParamChanged = lastSortParam.current !== sortParam;
+    if (!doctypeChanged && !filtersParamChanged && !sortParamChanged) return;
+    lastDoctype.current = doctype;
+    lastFiltersParam.current = filtersParam;
+    lastSortParam.current = sortParam;
+    if (doctypeChanged || filtersParamChanged) {
+      const fromParam = parseFiltersParam(filtersParam);
+      const next = fromParam.length > 0 ? fromParam : doctypeChanged && initialFiltersRef.current ? [...initialFiltersRef.current] : fromParam;
+      if (doctypeChanged || !sameFilters(next, baseFiltersRef.current)) {
+        setBaseFilters(next);
+        setEffectiveFilters(withFixed(next));
+        setFiltersGen(generation => generation + 1);
+      }
+    }
+    if (doctypeChanged) {
+      setSort(parseSortParam(sortParam) ?? null);
+      setLikeOverrides({});
+      return;
+    }
+    if (sortParamChanged) {
+      const parsed = parseSortParam(sortParam) ?? null;
+      if (!sameSort(parsed, sortRef.current)) {
+        setSort(parsed);
+        setSortGen(generation => generation + 1);
+      }
+    }
+  }, [doctype, filtersParam, sortParam, withFixed]);
+  const sortField = sort?.field ?? meta?.sort_field ?? "modified";
+  const sortOrder = sort?.order ?? (meta?.sort_order?.toUpperCase() === "ASC" ? "asc" : "desc");
+  const effectiveSortRef = useRef({
+    field: sortField,
+    order: sortOrder
+  });
+  effectiveSortRef.current = {
+    field: sortField,
+    order: sortOrder
+  };
+  const currentFilters = effectiveFilters ?? withFixed(baseFilters);
+  const connection = useMemo(() => config ? {
+    baseURL: config.baseURL,
+    socketPort: config.socketPort,
+    auth: config.auth ? {
+      useToken: config.auth.useToken,
+      token: typeof config.auth.token === "string" ? config.auth.token : void 0,
+      type: config.auth.type
+    } : void 0,
+    // Forward the provider's engine options: the SyncModule is
+    // shared per baseURL and the FIRST consumer's config wins — a
+    // connection built without syncOptions here would silently
+    // strip persistKey/cdcInterval for every other screen when the
+    // list's aggregate watcher happens to construct the engine
+    // first (observed on GNOME, where this screen is the first
+    // engine touch).
+    syncOptions: config.syncOptions,
+    socketOptions: config.socketOptions,
+    fixtures: config.fixtures
+  } : void 0, [config]);
+  const count = useFrappeAggregate(connection, {
+    doctype,
+    filters: currentFilters.length > 0 ? currentFilters : void 0
+  });
+  const handleToggleLike = useCallback((name, nextLiked) => {
+    setLikeOverrides(previous => ({
+      ...previous,
+      [name]: nextLiked
+    }));
+    if (!app || fixtureMode) return;
+    toggleLike(app, doctype, name, nextLiked).catch(() => {
+      setLikeOverrides(previous => ({
+        ...previous,
+        [name]: !nextLiked
+      }));
+      notify({
+        severity: "error",
+        scope: "page",
+        body: t("list.likeFailed", "Could not update liked state")
+      });
+    });
+  }, [app, fixtureMode, doctype, t]);
+  const {
+    roles
+  } = useUserRoles();
+  const permMatrix = useMemo(() => buildPermLevelMatrix(meta?.permissions, roles), [meta?.permissions, roles]);
+  const columns = useMemo(() => {
+    const built = buildListColumns({
+      meta,
+      t: (key, fallback) => t(key, fallback),
+      sessionUser,
+      onToggleLike: handleToggleLike,
+      likeOverrides,
+      permMatrix
+    });
+    return columnOverrides ? columnOverrides(built) : built;
+  }, [meta, t, sessionUser, handleToggleLike, likeOverrides, permMatrix, columnOverrides]);
+  const fields = useMemo(() => listFieldsToFetch(meta, permMatrix), [meta, permMatrix]);
+  const filterableFields = useMemo(() => {
+    if (!meta?.fields) return void 0;
+    return [...docFieldsToFilterFields(meta.fields), {
+      id: "_assign",
+      label: t("list.assignedTo", "Assigned To"),
+      type: "text"
+    }, {
+      id: "_user_tags",
+      label: t("list.tags", "Tags"),
+      type: "text"
+    }, {
+      id: "_liked_by",
+      label: t("list.likedBy", "Liked By"),
+      type: "text"
+    }];
+  }, [meta, t]);
+  const initialTableFilters = useMemo(() => frappeFiltersToTableFilters(withFixed(baseFilters)), [baseFilters, withFixed]);
+  const handleBaseFiltersChange = useCallback(next => {
+    setBaseFilters(next);
+    setEffectiveFilters(withFixed(next));
+    setFiltersGen(generation => generation + 1);
+    writeUrlState(next, sortRef.current);
+  }, [withFixed, writeUrlState]);
+  const handleSortChange = useCallback((field, order) => {
+    setSort({
+      field,
+      order
+    });
+    setSortGen(generation => generation + 1);
+    writeUrlState(baseFiltersRef.current, {
+      field,
+      order
+    });
+  }, [writeUrlState]);
+  const handleStateChange = useCallback(state => {
+    if (state.pagination?.pageSize) pageSizeRef.current = state.pagination.pageSize;
+    const nextFilters = tableStateToFrappeFilters(state);
+    setEffectiveFilters(previous => previous && sameFilters(previous, nextFilters) ? previous : nextFilters);
+    const sorting = state.sorting?.[0];
+    if (sorting) {
+      const order = sorting.desc ? "desc" : "asc";
+      const effective = effectiveSortRef.current;
+      if (effective.field !== sorting.id || effective.order !== order) {
+        const nextSort = {
+          field: sorting.id,
+          order
+        };
+        setSort(nextSort);
+        writeUrlState(baseFiltersRef.current, nextSort);
+      }
+    }
+  }, [writeUrlState]);
+  const handleRefresh = useCallback(() => {
+    setRefreshGen(generation => generation + 1);
+    count.refresh();
+  }, [count]);
+  const handleRowClick = useCallback(row => {
+    if (!row.name) return;
+    if (onRowOpen) {
+      onRowOpen(doctype, row.name);
+      return;
+    }
+    emitEvent({
+      type: "doc-opened",
+      doctype,
+      name: row.name
+    });
+    navigator.navigate(paths.form(doctype, row.name));
+  }, [navigator, paths, doctype, onRowOpen, emitEvent]);
+  const handleBulkExport = useCallback(async names => {
+    if (!app) return;
+    try {
+      const result = await bulkExportCsv(app, doctype, names, meta);
+      if (!result.downloaded) {
+        notify({
+          severity: "warning",
+          scope: "page",
+          body: t("list.exportUnsupported", "CSV export needs a browser download \u2014 not available on this platform yet")
+        });
+      } else {
+        notify({
+          severity: "success",
+          scope: "page",
+          body: t("list.exportDone", {
+            count: result.rowCount,
+            defaultValue_one: "Exported {{count}} row to CSV",
+            defaultValue_other: "Exported {{count}} rows to CSV"
+          })
+        });
+      }
+    } catch (error) {
+      notify({
+        severity: "error",
+        scope: "page",
+        body: error instanceof Error ? error.message : t("list.exportFailed", "CSV export failed")
+      });
+    }
+  }, [app, doctype, meta, t]);
+  const handleBulkDocstatus = useCallback(async (names, action) => {
+    if (!app) return;
+    try {
+      const result = await bulkSubmitCancel(app, doctype, names, action);
+      if (result.queued) {
+        notify({
+          severity: "info",
+          scope: "page",
+          body: t("list.docstatusQueued", {
+            action: action === "submit" ? t("list.submit", "Submit") : t("list.cancel", "Cancel"),
+            count: result.attempted,
+            defaultValue_one: "{{action}} of {{count}} document queued in the background",
+            defaultValue_other: "{{action}} of {{count}} documents queued in the background"
+          })
+        });
+      } else if (result.failed.length > 0) {
+        notify({
+          severity: "warning",
+          scope: "page",
+          // Two independent counts in one sentence — phrased "X of Y" so
+          // no noun needs a second plural slot.
+          body: t("list.docstatusPartial", {
+            count: result.attempted - result.failed.length,
+            total: result.attempted,
+            names: result.failed.join(", "),
+            defaultValue: "Processed {{count}} of {{total}} documents; failed: {{names}}"
+          })
+        });
+      } else {
+        notify({
+          severity: "success",
+          scope: "page",
+          body: action === "submit" ? t("list.submitDone", {
+            count: result.attempted,
+            defaultValue_one: "Submitted {{count}} document",
+            defaultValue_other: "Submitted {{count}} documents"
+          }) : t("list.cancelDone", {
+            count: result.attempted,
+            defaultValue_one: "Cancelled {{count}} document",
+            defaultValue_other: "Cancelled {{count}} documents"
+          })
+        });
+      }
+      count.refresh();
+    } catch (error) {
+      notify({
+        severity: "error",
+        scope: "page",
+        body: error instanceof Error ? error.message : t("list.docstatusFailed", "Bulk action failed")
+      });
+    }
+  }, [app, doctype, t, count]);
+  const isSubmittable = meta?.is_submittable === 1;
+  const hostListActions = useMemo(() => {
+    const injected = [...actionsForDoctype(actions.list, doctype), ...actionsForDoctype(toolbarActions, doctype)];
+    return injected.map(action => ({
+      id: action.id,
+      label: action.label,
+      onExecute: items => {
+        const names = items.map(item => item.name).filter(Boolean);
+        action.onPress({
+          doctype,
+          selection: names
+        });
+      }
+    }));
+  }, [actions.list, toolbarActions, doctype]);
+  const bulkActions = useMemo(() => [
+  // Assignment/tag actions ride their capability flags.
+  ...(capabilities.assignments.enabled ? [{
+    id: "assign",
+    label: t("list.assignTitle", "Assign To"),
+    onExecute: (items, clearSelection) => {
+      const names = items.map(item => item.name).filter(Boolean);
+      if (names.length > 0) setPendingDialog({
+        type: "assign",
+        names,
+        clear: clearSelection
+      });
+    }
+  }] : []), ...(capabilities.tags.enabled ? [{
+    id: "tag",
+    label: t("list.tagTitle", "Add Tags"),
+    onExecute: (items, clearSelection) => {
+      const names = items.map(item => item.name).filter(Boolean);
+      if (names.length > 0) setPendingDialog({
+        type: "tag",
+        names,
+        clear: clearSelection
+      });
+    }
+  }] : []), {
+    id: "edit",
+    label: t("list.editTitle", "Bulk Edit"),
+    onExecute: (items, clearSelection) => {
+      const names = items.map(item => item.name).filter(Boolean);
+      if (names.length > 0) setPendingDialog({
+        type: "edit",
+        names,
+        clear: clearSelection
+      });
+    }
+  }, {
+    id: "export",
+    label: t("list.export", "Export CSV"),
+    onExecute: async items => {
+      const names = items.map(item => item.name).filter(Boolean);
+      if (names.length > 0) await handleBulkExport(names);
+    }
+  }, ...(isSubmittable ? [{
+    id: "submit",
+    label: t("list.submit", "Submit"),
+    requiresConfirmation: true,
+    confirmTitle: t("list.submitTitle", "Submit documents"),
+    confirmMessage: t("list.submitConfirm", {
+      defaultValue: "Submit the selected {{doctype}} documents?",
+      doctype
+    }),
+    onExecute: async (items, clearSelection) => {
+      const names = items.map(item => item.name).filter(Boolean);
+      if (names.length === 0) return;
+      await handleBulkDocstatus(names, "submit");
+      clearSelection();
+    }
+  }, {
+    id: "cancel",
+    label: t("list.cancel", "Cancel"),
+    requiresConfirmation: true,
+    confirmTitle: t("list.cancelTitle", "Cancel documents"),
+    confirmMessage: t("list.cancelBody", {
+      defaultValue: "Cancel the selected submitted {{doctype}} documents?",
+      doctype
+    }),
+    onExecute: async (items, clearSelection) => {
+      const names = items.map(item => item.name).filter(Boolean);
+      if (names.length === 0) return;
+      await handleBulkDocstatus(names, "cancel");
+      clearSelection();
+    }
+  }] : []), {
+    id: "delete",
+    label: t("list.delete", "Delete"),
+    variant: "destructive",
+    requiresConfirmation: true,
+    confirmTitle: t("list.deleteTitle", "Delete documents"),
+    confirmMessage: t("list.deleteConfirm", {
+      defaultValue: "Permanently delete the selected {{doctype}} documents?",
+      doctype
+    }),
+    onExecute: async (items, clearSelection) => {
+      if (!app) return;
+      const names = items.map(item => item.name).filter(Boolean);
+      if (names.length === 0) return;
+      const result = await bulkDelete(app, doctype, names);
+      if (result.failed.length > 0) {
+        notify({
+          severity: "warning",
+          scope: "page",
+          body: t("list.deletePartial", {
+            count: result.succeeded.length,
+            total: names.length,
+            names: result.failed.map(failure => failure.name).join(", "),
+            defaultValue: "Deleted {{count}} of {{total}} documents; failed: {{names}}"
+          })
+        });
+      } else {
+        notify({
+          severity: "success",
+          scope: "page",
+          body: t("list.deleteDone", {
+            count: result.succeeded.length,
+            defaultValue_one: "Deleted {{count}} document",
+            defaultValue_other: "Deleted {{count}} documents"
+          })
+        });
+      }
+      clearSelection();
+      count.refresh();
+    }
+  }, ...hostListActions], [t, app, doctype, count, isSubmittable, handleBulkExport, handleBulkDocstatus, capabilities.assignments.enabled, capabilities.tags.enabled, hostListActions]);
+  const bulkActionsEnabled = capabilities.bulkActions.enabled;
+  const views = useMemo(() => {
+    if (!capabilities.views.enabled) return [];
+    return BACKOFFICE_VIEWS.filter(view => capabilities.views.allow.includes(view) && (!viewsAllowlist || viewsAllowlist.includes(view))).map(view => ({
+      type: view,
+      label: t(`views.${view}`, view.charAt(0).toUpperCase() + view.slice(1))
+    }));
+  }, [t, capabilities.views.enabled, capabilities.views.allow, viewsAllowlist]);
+  const tableKey = `${doctype}|${refreshGen}|${sortGen}|${filtersGen}`;
+  if (metaError && !meta) {
+    return /* @__PURE__ */jsx(YStack, {
+      flex: 1,
+      children: /* @__PURE__ */jsx(EmptyState, {
+        intent: "error",
+        title: t("list.metaError", {
+          defaultValue: "Could not load {{doctype}}",
+          doctype
+        }),
+        description: metaError.message
+      })
+    });
+  }
+  if (!meta && metaLoading) {
+    return /* @__PURE__ */jsx(YStack, {
+      flex: 1,
+      alignItems: "center",
+      justifyContent: "center",
+      padding: "$6",
+      children: /* @__PURE__ */jsx(Spinner, {
+        size: "large"
+      })
+    });
+  }
+  const showCreateFirst = !count.isLoading && count.value === 0 && currentFilters.length === 0;
+  const countText = count.isLoading ? void 0 : t("list.resultCount", {
+    count: count.value ?? 0,
+    defaultValue_one: "{{count}} result",
+    defaultValue_other: "{{count}} results"
+  });
+  const handleViewChange = view => {
+    if (view !== "list") navigator.navigate(paths.view(doctype, view));
+  };
+  const showViewSwitcher = views.length > 1;
+  return /* @__PURE__ */jsxs(YStack, {
+    flex: 1,
+    gap: compactChrome ? "$2" : "$3",
+    padding: compactChrome ? "$3" : "$4",
+    children: [compactChrome ?
+    // Compact chrome (< 640): one title row (title + live count inline,
+    // icon refresh, compact New), then one row with the view switcher
+    // (horizontally scrollable — all views stay reachable) and the
+    // single Filter affordance (filters/sort collapse into its sheet).
+    /* @__PURE__ */
+    jsxs(PageHeader, {
+      heading: /* @__PURE__ */jsxs(XStack, {
+        gap: "$2",
+        alignItems: "baseline",
+        flexWrap: "wrap",
+        children: [/* @__PURE__ */jsx(H1, {
+          size: "$7",
+          margin: 0,
+          flexShrink: 1,
+          minWidth: 0,
+          children: doctype
+        }), countText ? /* @__PURE__ */jsx(Paragraph, {
+          size: "$2",
+          color: "$color10",
+          margin: 0,
+          children: countText
+        }) : null]
+      }),
+      actions: /* @__PURE__ */jsxs(XStack, {
+        gap: "$2",
+        alignItems: "center",
+        children: [/* @__PURE__ */jsx(ActionButton, {
+          size: "$3",
+          circular: true,
+          chromeless: true,
+          icon: ArrowsClockwiseIcon,
+          onPress: handleRefresh,
+          "aria-label": t("list.refresh", "Refresh")
+        }), showNew && /* @__PURE__ */jsx(ActionButton, {
+          size: "$3",
+          accent: true,
+          icon: PlusIcon,
+          onPress: () => setQuickEntryOpen(true),
+          "aria-label": t("list.new", {
+            defaultValue: "New {{doctype}}",
+            doctype
+          }),
+          children: t("list.newShort", "New")
+        })]
+      }),
+      children: [/* @__PURE__ */jsxs(XStack, {
+        gap: "$2",
+        alignItems: "center",
+        children: [/* @__PURE__ */jsx(ScrollView, {
+          horizontal: true,
+          flexGrow: 1,
+          flexShrink: 1,
+          minWidth: 0,
+          showsHorizontalScrollIndicator: false,
+          children: showViewSwitcher ? /* @__PURE__ */jsx(ViewSwitcher, {
+            views,
+            currentView: "list",
+            onViewChange: handleViewChange
+          }) : null
+        }), /* @__PURE__ */jsx(ListFilterBar, {
+          compact: true,
+          doctype,
+          meta,
+          filters: baseFilters,
+          onFiltersChange: handleBaseFiltersChange,
+          sortField,
+          sortOrder,
+          onSortChange: handleSortChange
+        })]
+      }), /* @__PURE__ */jsx(FilterChips, {
+        meta,
+        filters: baseFilters,
+        onFiltersChange: handleBaseFiltersChange
+      })]
+    }) : /* @__PURE__ */jsxs(Fragment, {
+      children: [/* @__PURE__ */jsx(PageHeader, {
+        title: doctype,
+        titleScale: "moderate",
+        subtitle: countText,
+        actions: /* @__PURE__ */jsxs(XStack, {
+          gap: "$2",
+          alignItems: "center",
+          flexWrap: "wrap",
+          children: [/* @__PURE__ */jsx(ActionButton, {
+            size: "$3",
+            circular: true,
+            chromeless: true,
+            icon: ArrowsClockwiseIcon,
+            onPress: handleRefresh,
+            "aria-label": t("list.refresh", "Refresh")
+          }), showViewSwitcher ? /* @__PURE__ */jsx(ViewSwitcher, {
+            views,
+            currentView: "list",
+            onViewChange: handleViewChange
+          }) : null, showNew && /* @__PURE__ */jsx(ActionButton, {
+            size: "$2",
+            accent: true,
+            onPress: () => setQuickEntryOpen(true),
+            children: t("list.new", {
+              defaultValue: "New {{doctype}}",
+              doctype
+            })
+          })]
+        })
+      }), /* @__PURE__ */jsxs(XStack, {
+        gap: "$2",
+        alignItems: "flex-start",
+        children: [!fixtureMode &&
+        // Icon-only sidebar toggle: the bare "Hide sidebar" text read
+        // as a floating label, not a control, and its 28px box missed
+        // the press floor. House Button icon slot (LC-53) + circular
+        // sub-44 floor via the house channel (LC-54); aria-expanded
+        // carries the region state.
+        /* @__PURE__ */
+        jsx(ActionButton, {
+          size: "$3",
+          circular: true,
+          chromeless: true,
+          icon: SidebarSimpleIcon,
+          display: "none",
+          $sm: {
+            display: "flex"
+          },
+          onPress: () => setSidebarVisible(visible => !visible),
+          "aria-expanded": sidebarVisible,
+          "aria-label": sidebarVisible ? t("list.hideSidebar", "Hide sidebar") : t("list.showSidebar", "Show sidebar")
+        }), /* @__PURE__ */jsx(YStack, {
+          flex: 1,
+          children: /* @__PURE__ */jsx(ListFilterBar, {
+            doctype,
+            meta,
+            filters: baseFilters,
+            onFiltersChange: handleBaseFiltersChange,
+            sortField,
+            sortOrder,
+            onSortChange: handleSortChange
+          })
+        })]
+      })]
+    }), (() => {
+      const listBody = /* @__PURE__ */jsxs(XStack, {
+        flex: 1,
+        gap: "$2",
+        alignItems: "stretch",
+        children: [sidebarVisible && !fixtureMode && /* @__PURE__ */jsx(YStack, {
+          display: "none",
+          $sm: {
+            display: "flex"
+          },
+          children: /* @__PURE__ */jsx(ListSidebar, {
+            doctype,
+            meta,
+            filters: currentFilters,
+            onFiltersChange: handleBaseFiltersChange
+          })
+        }), /* @__PURE__ */jsx(YStack, {
+          flex: 1,
+          minWidth: 0,
+          children: showCreateFirst ? slots.renderListEmpty?.({
+            doctype
+          }) ?? /* @__PURE__ */jsx(EmptyState, {
+            title: t("list.emptyTitle", {
+              defaultValue: "No {{doctype}} yet",
+              doctype
+            }),
+            description: t("list.emptyDescription", {
+              defaultValue: "Create your first {{doctype}} to get started",
+              doctype
+            }),
+            action: showNew ? /* @__PURE__ */jsx(ActionButton, {
+              accent: true,
+              onPress: () => setQuickEntryOpen(true),
+              children: t("list.new", {
+                defaultValue: "New {{doctype}}",
+                doctype
+              })
+            }) : void 0
+          }) : /* @__PURE__ */jsx(ListTable, {
+            doctype,
+            columns,
+            fields,
+            serverSide: !fixtureMode,
+            ...(fixtureMode && withFixed(baseFilters).length > 0 ? {
+              filters: withFixed(baseFilters)
+            } : {}),
+            filterableFields,
+            initialState: {
+              sorting: [{
+                id: sortField,
+                desc: sortOrder === "desc"
+              }],
+              filters: initialTableFilters,
+              pagination: {
+                pageIndex: 0,
+                pageSize: pageSizeRef.current
+              }
+            },
+            enablePagination: true,
+            renderPagination: paginationProps => /* @__PURE__ */jsx(DataTablePagination, {
+              ...paginationProps,
+              pageSizeOptions: [...PAGE_SIZES],
+              compact: true
+            }),
+            enableFiltering: false,
+            enableSorting: true,
+            enableRowSelection: bulkActionsEnabled,
+            ...(bulkActionsEnabled ? {
+              bulkActions
+            } : {}),
+            onRowClick: handleRowClick,
+            onStateChange: handleStateChange
+          }, tableKey)
+        })]
+      });
+      return isWeb && !compactChrome ? listBody : /* @__PURE__ */jsx(ScrollView, {
+        flex: 1,
+        children: listBody
+      });
+    })(), showNew && /* @__PURE__ */jsx(QuickEntryDialog, {
+      doctype,
+      open: quickEntryOpen,
+      onOpenChange: setQuickEntryOpen,
+      onCreated: name => {
+        emitEvent({
+          type: "doc-opened",
+          doctype,
+          name
+        });
+        navigator.navigate(paths.form(doctype, name));
+      },
+      onEditFullForm: () => navigator.navigate(paths.newDoc(doctype))
+    }), /* @__PURE__ */jsx(AssignToDialog, {
+      doctype,
+      names: pendingDialog?.type === "assign" ? pendingDialog.names : [],
+      open: pendingDialog?.type === "assign",
+      onOpenChange: open => {
+        if (!open) setPendingDialog(null);
+      },
+      onDone: () => {
+        pendingDialog?.clear();
+        count.refresh();
+      }
+    }), /* @__PURE__ */jsx(AddTagsDialog, {
+      doctype,
+      names: pendingDialog?.type === "tag" ? pendingDialog.names : [],
+      open: pendingDialog?.type === "tag",
+      onOpenChange: open => {
+        if (!open) setPendingDialog(null);
+      },
+      onDone: () => {
+        pendingDialog?.clear();
+        count.refresh();
+      }
+    }), /* @__PURE__ */jsx(BulkEditDialog, {
+      doctype,
+      meta,
+      names: pendingDialog?.type === "edit" ? pendingDialog.names : [],
+      open: pendingDialog?.type === "edit",
+      onOpenChange: open => {
+        if (!open) setPendingDialog(null);
+      },
+      onDone: () => {
+        pendingDialog?.clear();
+        count.refresh();
+      }
+    })]
+  });
+}
+export { DoctypeListScreen };
+//# sourceMappingURL=DoctypeListScreen.mjs.map