@multiplatform.one/backoffice 6.4.3 → 6.7.0

package/dist/cjs/list/DoctypeListScreen.cjs

@@ -0,0 +1,840 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var DoctypeListScreen_exports = {};
+__export(DoctypeListScreen_exports, {
+  DoctypeListScreen: () => DoctypeListScreen
+});
+module.exports = __toCommonJS(DoctypeListScreen_exports);
+var import_components = require("@multiplatform.one/components");
+var import_theme = require("@multiplatform.one/theme");
+var import_forms = require("@multiplatform.one/forms");
+var import_react = require("@phosphor-icons/react");
+var import_frappe_ui = require("@multiplatform.one/frappe-ui");
+var import_table = require("@multiplatform.one/table");
+var import_react2 = require("react");
+var import_react_i18next = require("react-i18next");
+var import_BackofficeProvider = require("../config/BackofficeProvider.cjs");
+var import_i18n = require("../i18n/index.cjs");
+var import_paths = require("../navigation/paths.cjs");
+var import_QuickEntryDialog = require("../quickEntry/QuickEntryDialog.cjs");
+var import_useRecentVisit = require("../shared/useRecentVisit.cjs");
+var import_fieldPermissions = require("../form/fieldPermissions.cjs");
+var import_useDoctypeMeta = require("../shared/useDoctypeMeta.cjs");
+var import_useFrappeApp = require("../shared/useFrappeApp.cjs");
+var import_useUserRoles = require("../shared/useUserRoles.cjs");
+var import_AddTagsDialog = require("./AddTagsDialog.cjs");
+var import_AssignToDialog = require("./AssignToDialog.cjs");
+var import_bulkActions = require("./bulkActions.cjs");
+var import_bulk_edit_dialog = require("./bulk-edit-dialog.cjs");
+var import_bulk_export = require("./bulk-export.cjs");
+var import_bulk_submit_cancel = require("./bulk-submit-cancel.cjs");
+var import_filter_chips = require("./filter-chips.cjs");
+var import_filterConversion = require("./filterConversion.cjs");
+var import_ListFilterBar = require("./ListFilterBar.cjs");
+var import_ListSidebar = require("./ListSidebar.cjs");
+var import_listColumns = require("./listColumns.cjs");
+var import_listFields = require("./listFields.cjs");
+var import_listUrlState = require("./listUrlState.cjs");
+var import_useSessionUserId = require("../shared/useSessionUserId.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+const PAGE_SIZES = [20, 100, 500];
+const ListTable = import_frappe_ui.FrappeTable;
+function sameFilters(a, b) {
+  return a.length === b.length && a.every((tuple, index) => (0, import_filterConversion.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
+  } = (0, import_react_i18next.useTranslation)(import_i18n.BACKOFFICE_I18N_NAMESPACE);
+  const navigator = (0, import_BackofficeProvider.useBackofficeNavigator)();
+  const paths = (0, import_BackofficeProvider.useBackofficePaths)();
+  const capabilities = (0, import_BackofficeProvider.useBackofficeCapabilities)();
+  const {
+    actions,
+    emitEvent
+  } = (0, import_BackofficeProvider.useBackofficeConfig)();
+  const slots = (0, import_BackofficeProvider.useBackofficeSlots)();
+  const config = (0, import_frappe_ui.useFrappeConfig)();
+  const app = (0, import_useFrappeApp.useFrappeApp)();
+  const fixtureMode = Boolean(config?.fixtures);
+  const sessionUser = (0, import_useSessionUserId.useSessionUserId)();
+  const compactChrome = (0, import_theme.useLayoutSizeClass)() === "compact";
+  (0, import_useRecentVisit.useRecentVisit)(fixtureMode ? void 0 : {
+    label: doctype,
+    path: paths.list(doctype)
+  });
+  const {
+    meta: loadedMeta,
+    loading: metaLoading,
+    error: metaError
+  } = (0, import_useDoctypeMeta.useDoctypeMeta)(metaOverride ? void 0 : doctype);
+  const meta = metaOverride ?? loadedMeta;
+  (0, import_react2.useEffect)(() => {
+    if (metaError && !meta) emitEvent({
+      type: "error",
+      error: metaError,
+      context: "list-meta"
+    });
+  }, [metaError, meta, emitEvent]);
+  const showNew = !hideNewButton && capabilities.newDoc.enabled;
+  const [baseFilters, setBaseFilters] = (0, import_react2.useState)(() => {
+    const fromParam = (0, import_listUrlState.parseFiltersParam)(filtersParam);
+    if (fromParam.length > 0) return fromParam;
+    return initialFilters ? [...initialFilters] : fromParam;
+  });
+  const [filtersGen, setFiltersGen] = (0, import_react2.useState)(0);
+  const [effectiveFilters, setEffectiveFilters] = (0, import_react2.useState)(null);
+  const [sort, setSort] = (0, import_react2.useState)(() => (0, import_listUrlState.parseSortParam)(sortParam) ?? null);
+  const [sortGen, setSortGen] = (0, import_react2.useState)(0);
+  const [refreshGen, setRefreshGen] = (0, import_react2.useState)(0);
+  const [sidebarVisible, setSidebarVisible] = (0, import_react2.useState)(true);
+  const [quickEntryOpen, setQuickEntryOpen] = (0, import_react2.useState)(false);
+  const [pendingDialog, setPendingDialog] = (0, import_react2.useState)(null);
+  const [likeOverrides, setLikeOverrides] = (0, import_react2.useState)({});
+  const pageSizeRef = (0, import_react2.useRef)(pageSize ?? PAGE_SIZES[0]);
+  const fixedFiltersKey = JSON.stringify(fixedFilters ?? []);
+  const fixedTuples = (0, import_react2.useMemo)(() => JSON.parse(fixedFiltersKey), [fixedFiltersKey]);
+  const withFixed = (0, import_react2.useCallback)(filters => fixedTuples.length > 0 ? [...fixedTuples, ...filters] : filters, [fixedTuples]);
+  const initialFiltersRef = (0, import_react2.useRef)(initialFilters);
+  initialFiltersRef.current = initialFilters;
+  const baseFiltersRef = (0, import_react2.useRef)(baseFilters);
+  baseFiltersRef.current = baseFilters;
+  const sortRef = (0, import_react2.useRef)(sort);
+  sortRef.current = sort;
+  const writeUrlState = (0, import_react2.useCallback)((filters, sortState) => {
+    navigator.setParams?.({
+      f: (0, import_listUrlState.serializeFiltersParam)(filters),
+      sort: sortState ? (0, import_listUrlState.serializeSortParam)(sortState) : void 0
+    });
+  }, [navigator]);
+  const lastDoctype = (0, import_react2.useRef)(doctype);
+  const lastFiltersParam = (0, import_react2.useRef)(filtersParam);
+  const lastSortParam = (0, import_react2.useRef)(sortParam);
+  (0, import_react2.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 = (0, import_listUrlState.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((0, import_listUrlState.parseSortParam)(sortParam) ?? null);
+      setLikeOverrides({});
+      return;
+    }
+    if (sortParamChanged) {
+      const parsed = (0, import_listUrlState.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 = (0, import_react2.useRef)({
+    field: sortField,
+    order: sortOrder
+  });
+  effectiveSortRef.current = {
+    field: sortField,
+    order: sortOrder
+  };
+  const currentFilters = effectiveFilters ?? withFixed(baseFilters);
+  const connection = (0, import_react2.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 = (0, import_frappe_ui.useFrappeAggregate)(connection, {
+    doctype,
+    filters: currentFilters.length > 0 ? currentFilters : void 0
+  });
+  const handleToggleLike = (0, import_react2.useCallback)((name, nextLiked) => {
+    setLikeOverrides(previous => ({
+      ...previous,
+      [name]: nextLiked
+    }));
+    if (!app || fixtureMode) return;
+    (0, import_bulkActions.toggleLike)(app, doctype, name, nextLiked).catch(() => {
+      setLikeOverrides(previous => ({
+        ...previous,
+        [name]: !nextLiked
+      }));
+      (0, import_components.notify)({
+        severity: "error",
+        scope: "page",
+        body: t("list.likeFailed", "Could not update liked state")
+      });
+    });
+  }, [app, fixtureMode, doctype, t]);
+  const {
+    roles
+  } = (0, import_useUserRoles.useUserRoles)();
+  const permMatrix = (0, import_react2.useMemo)(() => (0, import_fieldPermissions.buildPermLevelMatrix)(meta?.permissions, roles), [meta?.permissions, roles]);
+  const columns = (0, import_react2.useMemo)(() => {
+    const built = (0, import_listColumns.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 = (0, import_react2.useMemo)(() => (0, import_listFields.listFieldsToFetch)(meta, permMatrix), [meta, permMatrix]);
+  const filterableFields = (0, import_react2.useMemo)(() => {
+    if (!meta?.fields) return void 0;
+    return [...(0, import_frappe_ui.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 = (0, import_react2.useMemo)(() => (0, import_filterConversion.frappeFiltersToTableFilters)(withFixed(baseFilters)), [baseFilters, withFixed]);
+  const handleBaseFiltersChange = (0, import_react2.useCallback)(next => {
+    setBaseFilters(next);
+    setEffectiveFilters(withFixed(next));
+    setFiltersGen(generation => generation + 1);
+    writeUrlState(next, sortRef.current);
+  }, [withFixed, writeUrlState]);
+  const handleSortChange = (0, import_react2.useCallback)((field, order) => {
+    setSort({
+      field,
+      order
+    });
+    setSortGen(generation => generation + 1);
+    writeUrlState(baseFiltersRef.current, {
+      field,
+      order
+    });
+  }, [writeUrlState]);
+  const handleStateChange = (0, import_react2.useCallback)(state => {
+    if (state.pagination?.pageSize) pageSizeRef.current = state.pagination.pageSize;
+    const nextFilters = (0, import_filterConversion.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 = (0, import_react2.useCallback)(() => {
+    setRefreshGen(generation => generation + 1);
+    count.refresh();
+  }, [count]);
+  const handleRowClick = (0, import_react2.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 = (0, import_react2.useCallback)(async names => {
+    if (!app) return;
+    try {
+      const result = await (0, import_bulk_export.bulkExportCsv)(app, doctype, names, meta);
+      if (!result.downloaded) {
+        (0, import_components.notify)({
+          severity: "warning",
+          scope: "page",
+          body: t("list.exportUnsupported", "CSV export needs a browser download \u2014 not available on this platform yet")
+        });
+      } else {
+        (0, import_components.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) {
+      (0, import_components.notify)({
+        severity: "error",
+        scope: "page",
+        body: error instanceof Error ? error.message : t("list.exportFailed", "CSV export failed")
+      });
+    }
+  }, [app, doctype, meta, t]);
+  const handleBulkDocstatus = (0, import_react2.useCallback)(async (names, action) => {
+    if (!app) return;
+    try {
+      const result = await (0, import_bulk_submit_cancel.bulkSubmitCancel)(app, doctype, names, action);
+      if (result.queued) {
+        (0, import_components.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) {
+        (0, import_components.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 {
+        (0, import_components.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) {
+      (0, import_components.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 = (0, import_react2.useMemo)(() => {
+    const injected = [...(0, import_BackofficeProvider.actionsForDoctype)(actions.list, doctype), ...(0, import_BackofficeProvider.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 = (0, import_react2.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 (0, import_bulkActions.bulkDelete)(app, doctype, names);
+      if (result.failed.length > 0) {
+        (0, import_components.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 {
+        (0, import_components.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 = (0, import_react2.useMemo)(() => {
+    if (!capabilities.views.enabled) return [];
+    return import_paths.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__ */(0, import_jsx_runtime.jsx)(import_components.YStack, {
+      flex: 1,
+      children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.EmptyState, {
+        intent: "error",
+        title: t("list.metaError", {
+          defaultValue: "Could not load {{doctype}}",
+          doctype
+        }),
+        description: metaError.message
+      })
+    });
+  }
+  if (!meta && metaLoading) {
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.YStack, {
+      flex: 1,
+      alignItems: "center",
+      justifyContent: "center",
+      padding: "$6",
+      children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.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__ */(0, import_jsx_runtime.jsxs)(import_components.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__ */
+    (0, import_jsx_runtime.jsxs)(import_components.PageHeader, {
+      heading: /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_components.XStack, {
+        gap: "$2",
+        alignItems: "baseline",
+        flexWrap: "wrap",
+        children: [/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.H1, {
+          size: "$7",
+          margin: 0,
+          flexShrink: 1,
+          minWidth: 0,
+          children: doctype
+        }), countText ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.Paragraph, {
+          size: "$2",
+          color: "$color10",
+          margin: 0,
+          children: countText
+        }) : null]
+      }),
+      actions: /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_components.XStack, {
+        gap: "$2",
+        alignItems: "center",
+        children: [/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_forms.Button, {
+          size: "$3",
+          circular: true,
+          chromeless: true,
+          icon: import_react.ArrowsClockwiseIcon,
+          onPress: handleRefresh,
+          "aria-label": t("list.refresh", "Refresh")
+        }), showNew && /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_forms.Button, {
+          size: "$3",
+          accent: true,
+          icon: import_react.PlusIcon,
+          onPress: () => setQuickEntryOpen(true),
+          "aria-label": t("list.new", {
+            defaultValue: "New {{doctype}}",
+            doctype
+          }),
+          children: t("list.newShort", "New")
+        })]
+      }),
+      children: [/* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_components.XStack, {
+        gap: "$2",
+        alignItems: "center",
+        children: [/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.ScrollView, {
+          horizontal: true,
+          flexGrow: 1,
+          flexShrink: 1,
+          minWidth: 0,
+          showsHorizontalScrollIndicator: false,
+          children: showViewSwitcher ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.ViewSwitcher, {
+            views,
+            currentView: "list",
+            onViewChange: handleViewChange
+          }) : null
+        }), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_ListFilterBar.ListFilterBar, {
+          compact: true,
+          doctype,
+          meta,
+          filters: baseFilters,
+          onFiltersChange: handleBaseFiltersChange,
+          sortField,
+          sortOrder,
+          onSortChange: handleSortChange
+        })]
+      }), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_filter_chips.FilterChips, {
+        meta,
+        filters: baseFilters,
+        onFiltersChange: handleBaseFiltersChange
+      })]
+    }) : /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+      children: [/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.PageHeader, {
+        title: doctype,
+        titleScale: "moderate",
+        subtitle: countText,
+        actions: /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_components.XStack, {
+          gap: "$2",
+          alignItems: "center",
+          flexWrap: "wrap",
+          children: [/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_forms.Button, {
+            size: "$3",
+            circular: true,
+            chromeless: true,
+            icon: import_react.ArrowsClockwiseIcon,
+            onPress: handleRefresh,
+            "aria-label": t("list.refresh", "Refresh")
+          }), showViewSwitcher ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.ViewSwitcher, {
+            views,
+            currentView: "list",
+            onViewChange: handleViewChange
+          }) : null, showNew && /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_forms.Button, {
+            size: "$2",
+            accent: true,
+            onPress: () => setQuickEntryOpen(true),
+            children: t("list.new", {
+              defaultValue: "New {{doctype}}",
+              doctype
+            })
+          })]
+        })
+      }), /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_components.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__ */
+        (0, import_jsx_runtime.jsx)(import_forms.Button, {
+          size: "$3",
+          circular: true,
+          chromeless: true,
+          icon: import_react.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__ */(0, import_jsx_runtime.jsx)(import_components.YStack, {
+          flex: 1,
+          children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_ListFilterBar.ListFilterBar, {
+            doctype,
+            meta,
+            filters: baseFilters,
+            onFiltersChange: handleBaseFiltersChange,
+            sortField,
+            sortOrder,
+            onSortChange: handleSortChange
+          })
+        })]
+      })]
+    }), (() => {
+      const listBody = /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_components.XStack, {
+        flex: 1,
+        gap: "$2",
+        alignItems: "stretch",
+        children: [sidebarVisible && !fixtureMode && /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.YStack, {
+          display: "none",
+          $sm: {
+            display: "flex"
+          },
+          children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_ListSidebar.ListSidebar, {
+            doctype,
+            meta,
+            filters: currentFilters,
+            onFiltersChange: handleBaseFiltersChange
+          })
+        }), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.YStack, {
+          flex: 1,
+          minWidth: 0,
+          children: showCreateFirst ? slots.renderListEmpty?.({
+            doctype
+          }) ?? /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.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__ */(0, import_jsx_runtime.jsx)(import_forms.Button, {
+              accent: true,
+              onPress: () => setQuickEntryOpen(true),
+              children: t("list.new", {
+                defaultValue: "New {{doctype}}",
+                doctype
+              })
+            }) : void 0
+          }) : /* @__PURE__ */(0, import_jsx_runtime.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__ */(0, import_jsx_runtime.jsx)(import_table.DataTablePagination, {
+              ...paginationProps,
+              pageSizeOptions: [...PAGE_SIZES],
+              compact: true
+            }),
+            enableFiltering: false,
+            enableSorting: true,
+            enableRowSelection: bulkActionsEnabled,
+            ...(bulkActionsEnabled ? {
+              bulkActions
+            } : {}),
+            onRowClick: handleRowClick,
+            onStateChange: handleStateChange
+          }, tableKey)
+        })]
+      });
+      return import_components.isWeb && !compactChrome ? listBody : /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_components.ScrollView, {
+        flex: 1,
+        children: listBody
+      });
+    })(), showNew && /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_QuickEntryDialog.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__ */(0, import_jsx_runtime.jsx)(import_AssignToDialog.AssignToDialog, {
+      doctype,
+      names: pendingDialog?.type === "assign" ? pendingDialog.names : [],
+      open: pendingDialog?.type === "assign",
+      onOpenChange: open => {
+        if (!open) setPendingDialog(null);
+      },
+      onDone: () => {
+        pendingDialog?.clear();
+        count.refresh();
+      }
+    }), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_AddTagsDialog.AddTagsDialog, {
+      doctype,
+      names: pendingDialog?.type === "tag" ? pendingDialog.names : [],
+      open: pendingDialog?.type === "tag",
+      onOpenChange: open => {
+        if (!open) setPendingDialog(null);
+      },
+      onDone: () => {
+        pendingDialog?.clear();
+        count.refresh();
+      }
+    }), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_bulk_edit_dialog.BulkEditDialog, {
+      doctype,
+      meta,
+      names: pendingDialog?.type === "edit" ? pendingDialog.names : [],
+      open: pendingDialog?.type === "edit",
+      onOpenChange: open => {
+        if (!open) setPendingDialog(null);
+      },
+      onDone: () => {
+        pendingDialog?.clear();
+        count.refresh();
+      }
+    })]
+  });
+}