@multiplatform.one/backoffice 7.22.0 → 7.23.1

package/src/list/DoctypeListScreen.auth.spec.tsx

@@ -0,0 +1,84 @@
+// A Keycloak-signed-in reader hands the provider its token as a getter
+// (MPO-399). Every request the list makes must carry that bearer: the bench
+// answers a tokenless call as Guest (403), which is how the header count
+// read "0 results" beside a full page of rows.
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BackofficeProvider } from "../config/BackofficeProvider";
+import { createMemoryNavigator } from "../navigation/navigator";
+import { DoctypeListScreen } from "./DoctypeListScreen";
+
+const doctype = "Pokemon";
+const bearer = "Bearer kc-access-token";
+
+const meta = {
+  name: doctype,
+  doctype: "DocType",
+  title_field: "pokemon_name",
+  fields: [
+    { fieldname: "pokemon_name", fieldtype: "Data", label: "Pokemon Name", in_list_view: 1 },
+  ],
+  permissions: [{ role: "Pokemon Reader", read: 1 }],
+};
+
+let run = 0;
+let calls: { path: string; authorization: string | null }[] = [];
+
+function json(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+beforeEach(() => {
+  run += 1;
+  calls = [];
+  vi.stubGlobal("fetch", async (input: string | URL | Request, init?: RequestInit) => {
+    const url = new URL(String(input instanceof Request ? input.url : input));
+    const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
+    const authorization = headers.get("Authorization");
+    calls.push({ path: `${url.pathname}${url.search}`, authorization });
+    if (authorization !== bearer) {
+      return json({ exc_type: "PermissionError" }, 403);
+    }
+    const method = url.pathname.replace(/^\/api\/method\//, "");
+    if (method === "frappe.auth.get_logged_user") return json({ message: "ash@pokemon.test" });
+    if (method === "frappe.core.doctype.user.user.get_roles") {
+      return json({ message: ["Pokemon Reader"] });
+    }
+    if (method === "frappe.desk.form.load.getdoctype") return json({ docs: [meta] });
+    if (method === "frappe.client.get_count") return json({ message: 21 });
+    if (url.pathname === `/api/resource/${doctype}`) {
+      return json({ data: [{ name: "bulbasaur", doctype, pokemon_name: "Bulbasaur" }] });
+    }
+    return json({ data: [], message: [] });
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+describe("DoctypeListScreen auth", () => {
+  it("sends the provider's token getter on every call, the header count included", async () => {
+    renderWithProviders(
+      <BackofficeProvider
+        frappe={{
+          baseURL: `https://list-auth-${run}.spec.test`,
+          auth: { useToken: true, type: "Bearer", token: async () => "kc-access-token" },
+        }}
+        navigation={createMemoryNavigator("/backoffice")}
+      >
+        <DoctypeListScreen doctype={doctype} />
+      </BackofficeProvider>,
+    );
+
+    await waitFor(() => expect(screen.getByText("21 results")).toBeTruthy(), { timeout: 5000 });
+    const counts = calls.filter((call) => call.path.includes("frappe.client.get_count"));
+    expect(counts.length).toBeGreaterThan(0);
+    expect(calls.filter((call) => call.authorization !== bearer)).toEqual([]);
+  });
+});

package/src/list/DoctypeListScreen.tsx

@@ -32,10 +32,14 @@ import {
 } from "@phosphor-icons/react";
 import {
   FrappeTable,
+  buildListColumns,
   docFieldsToFilterFields,
+  listFieldsToFetch,
   sessionDocRights,
   useFrappeAggregate,
   useFrappeConfig,
+  type ListDoc,
+  type ListRow,
 } from "@multiplatform.one/frappe-ui";
 import type {
   BulkAction,
@@ -86,8 +90,6 @@ import {
 import { toggleFacetFilter } from "./sidebar-stats";
 import { ListFilterBar } from "./ListFilterBar";
 import { ListSidebar } from "./ListSidebar";
-import { type ListDoc, type ListRow, buildListColumns } from "./listColumns";
-import { listFieldsToFetch } from "./listFields";
 import {
   parseFiltersParam,
   parseSortParam,
@@ -359,38 +361,11 @@ export function DoctypeListScreen({
   effectiveSortRef.current = { field: sortField, order: sortOrder };
   const currentFilters = effectiveFilters ?? withFixed(baseFilters);
 
-  const connection = useMemo(
-    () =>
-      config
-        ? {
-            baseURL: config.baseURL,
-            socketPort: config.socketPort,
-            siteName: config.siteName,
-            socketBaseURL: config.socketBaseURL,
-            auth: config.auth
-              ? {
-                  useToken: config.auth.useToken,
-                  token: typeof config.auth.token === "string" ? config.auth.token : undefined,
-                  type: config.auth.type,
-                }
-              : undefined,
-            // 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,
-          }
-        : undefined,
-    [config],
-  );
-
-  // Live result count — realtime refetch on doctype events.
-  const count = useFrappeAggregate(connection, {
+  // Live result count — realtime refetch on doctype events. It takes the
+  // provider config itself, never a copy: the SyncModule is shared per socket
+  // target and the first consumer's config wins, so a field a copy drops
+  // (syncOptions, a token getter) is gone for every screen.
+  const count = useFrappeAggregate(config, {
     doctype,
     filters: currentFilters.length > 0 ? currentFilters : undefined,
   });
@@ -453,23 +428,15 @@ export function DoctypeListScreen({
 
   const fields = useMemo(() => listFieldsToFetch(meta, permMatrix), [meta, permMatrix]);
 
-  // Filterable-field declarations (meta fields + the desk `_` facet
-  // columns). With the table's filter chrome suppressed these render no
-  // toolbar surface — they resolve filter TYPES for the injected tuples and
-  // keep FrappeTable from refetching meta to derive its own list.
-  const filterableFields = useMemo<FilterableField[] | undefined>(() => {
-    if (!meta?.fields) return undefined;
-    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]);
+  // Filterable-field declarations from the one vocabulary (meta fields, the
+  // standard doc fields and the desk `_` facet columns). With the table's
+  // filter chrome suppressed these render no toolbar surface — they resolve
+  // filter TYPES for the injected tuples and keep FrappeTable from
+  // refetching meta to derive its own list.
+  const filterableFields = useMemo<FilterableField[] | undefined>(
+    () => (meta?.fields ? docFieldsToFilterFields(meta.fields) : undefined),
+    [meta],
+  );
 
   const initialTableFilters = useMemo<TableFilter[]>(
     () => frappeFiltersToTableFilters(withFixed(baseFilters)),

package/src/list/filter-chips.tsx

@@ -10,7 +10,7 @@ import { useTranslation } from "react-i18next";
 import { BACKOFFICE_I18N_NAMESPACE } from "../i18n";
 import type { FrappeFilters } from "../shared/types";
 import type { DoctypeMeta } from "../shared/useDoctypeMeta";
-import { filterTupleLabel, filterableFieldsFromMeta } from "./filter-fields";
+import { filterTupleLabel, filterableFieldsFromMeta } from "@multiplatform.one/frappe-ui";
 
 export interface FilterChipsProps {
   meta?: DoctypeMeta;

package/src/list/filter-editor.tsx

@@ -16,7 +16,6 @@ import {
 // House Button: the raw tamagui Button (components re-export) never gets the
 // house 44px press floor (LC-54) — filter chrome takes the forms Button.
 import { Button, Input, Select } from "@multiplatform.one/forms";
-import { Link as LinkField } from "@multiplatform.one/frappe-ui";
 import { FunnelIcon, PlusIcon, XIcon } from "@phosphor-icons/react";
 import { useMemo, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
@@ -28,13 +27,14 @@ import {
   defaultOperatorForKind,
   draftToTuple,
   filterableFieldsFromMeta,
+  Link as LinkField,
   operatorsForKind,
   selectOptionsFromField,
   tupleToDraft,
   type DeskOperator,
   type FilterFieldDescriptor,
   type FilterRowDraft,
-} from "./filter-fields";
+} from "@multiplatform.one/frappe-ui";
 
 export interface FilterEditorButtonProps {
   meta?: DoctypeMeta;

package/src/list/filter-fields.tsx

@@ -1,359 +1,32 @@
 /**
- * Field + operator model for the list filter chrome (desk parity).
- *
- * Maps DoctypeMeta DocFields to kind-aware filter descriptors
- * (select/link/check/date/number/text) and defines desk's operator
- * vocabulary (=, !=, like, not like, in, not in, comparisons, between,
- * is set / is not set) with two-way tuple conversion. This model speaks
- * frappe tuples natively — the table package's FilterValue vocabulary is
- * bridged separately (filterConversion.ts) for the DataTable surface;
- * desk's own operator list is the parity target here.
+ * The filterable-field vocabulary — moved to
+ * `@multiplatform.one/frappe-ui/src/filterFields` (MPO-15), where it is the
+ * one vocabulary both list stacks read: this desk chrome and FrappeTable's
+ * toolbar (`docFieldsToFilterFields`). Re-exported here so the barrel and
+ * the `@multiplatform.one/backoffice/src/list/filter-fields` deep import
+ * keep resolving (the GNOME shim deep-imports this path). New code imports
+ * from `@multiplatform.one/frappe-ui`.
  */
-import type { FrappeFilter, FrappeFilters } from "../shared/types";
-import type { DocFieldMeta, DoctypeMeta } from "../shared/useDoctypeMeta";
 
-// ── Field descriptors ─────────────────────────────────────────
-
-export type FilterFieldKind = "select" | "link" | "check" | "date" | "number" | "text";
-
-export interface FilterFieldDescriptor {
-  fieldname: string;
-  label: string;
-  fieldtype: string;
-  kind: FilterFieldKind;
-  /** Link target doctype, or the raw Select options string. */
-  options?: string;
-}
-
-/** Layout / non-data fieldtypes that cannot meaningfully filter. */
-const NON_FILTERABLE_FIELDTYPES = new Set([
-  "Section Break",
-  "Column Break",
-  "Tab Break",
-  "Fold",
-  "Heading",
-  "HTML",
-  "Button",
-  "Image",
-  "Attach",
-  "Attach Image",
-  "Signature",
-  "Geolocation",
-  "Password",
-]);
-
-const NUMBER_FIELDTYPES = new Set(["Int", "Float", "Currency", "Percent", "Duration", "Rating"]);
-const DATE_FIELDTYPES = new Set(["Date", "Datetime", "Time"]);
-
-/** Editor kind for a frappe fieldtype (Dynamic Link has no static target → text). */
-export function fieldKind(fieldtype: string): FilterFieldKind {
-  if (fieldtype === "Select") return "select";
-  if (fieldtype === "Link") return "link";
-  if (fieldtype === "Check") return "check";
-  if (DATE_FIELDTYPES.has(fieldtype)) return "date";
-  if (NUMBER_FIELDTYPES.has(fieldtype)) return "number";
-  return "text";
-}
-
-function toDescriptor(field: DocFieldMeta): FilterFieldDescriptor {
-  return {
-    fieldname: field.fieldname,
-    label: field.label || field.fieldname,
-    fieldtype: field.fieldtype,
-    kind: fieldKind(field.fieldtype),
-    options: field.options,
-  };
-}
-
-/** Standard doc fields present on every doctype but absent from meta.fields. */
-export function standardDocFilterFields(): FilterFieldDescriptor[] {
-  return [
-    { fieldname: "name", label: "ID", fieldtype: "Data", kind: "text" },
-    { fieldname: "owner", label: "Created By", fieldtype: "Link", kind: "link", options: "User" },
-    { fieldname: "creation", label: "Created On", fieldtype: "Datetime", kind: "date" },
-    { fieldname: "modified", label: "Last Updated On", fieldtype: "Datetime", kind: "date" },
-    {
-      fieldname: "modified_by",
-      label: "Last Updated By",
-      fieldtype: "Link",
-      kind: "link",
-      options: "User",
-    },
-    // Desk `_` facet columns — the sidebar facets and heart column write
-    // tuples on these, so chips and the editor must label them (desk offers
-    // them in its filter field picker too). Never surface the raw
-    // underscore fieldname (no-raw-fieldname rule candidate).
-    { fieldname: "_assign", label: "Assigned To", fieldtype: "Data", kind: "text" },
-    { fieldname: "_user_tags", label: "Tags", fieldtype: "Data", kind: "text" },
-    { fieldname: "_liked_by", label: "Liked By", fieldtype: "Data", kind: "text" },
-    { fieldname: "_comments", label: "Comments", fieldtype: "Data", kind: "text" },
-  ];
-}
-
-/**
- * All fields offered by the filter editor's field picker — data fields from
- * meta (hidden ones included, desk parity) plus the standard doc fields.
- */
-export function filterableFieldsFromMeta(meta?: DoctypeMeta): FilterFieldDescriptor[] {
-  const out: FilterFieldDescriptor[] = [];
-  const seen = new Set<string>();
-  for (const field of meta?.fields ?? []) {
-    if (!field.fieldname || seen.has(field.fieldname)) continue;
-    const fieldtype = String(field.fieldtype);
-    if (NON_FILTERABLE_FIELDTYPES.has(fieldtype) || fieldtype.startsWith("Table")) continue;
-    seen.add(field.fieldname);
-    out.push(toDescriptor(field));
-  }
-  for (const standard of standardDocFilterFields()) {
-    if (!seen.has(standard.fieldname)) out.push(standard);
-  }
-  return out;
-}
-
-/** Fields flagged `in_standard_filter`, in meta order (the quick-filter row).
- *  Desk always offers ID plus the title field as live header inputs even when
- *  those flags are off — typing a fragment of ID/subject is the fastest
- *  narrowing habit list users have (audit E1). */
-export function standardFiltersFromMeta(meta?: DoctypeMeta): FilterFieldDescriptor[] {
-  const fromMeta = (meta?.fields ?? [])
-    .filter((field) => field.in_standard_filter === 1 && field.hidden !== 1 && field.fieldname)
-    .map(toDescriptor);
-  const seen = new Set(fromMeta.map((field) => field.fieldname));
-  const extras: FilterFieldDescriptor[] = [];
-  if (!seen.has("name")) {
-    extras.push({ fieldname: "name", label: "ID", fieldtype: "Data", kind: "text" });
-    seen.add("name");
-  }
-  const titleField = meta?.title_field;
-  if (titleField && !seen.has(titleField)) {
-    const titleMeta = meta?.fields?.find((field) => field.fieldname === titleField);
-    extras.push({
-      fieldname: titleField,
-      label: titleMeta?.label || "Title",
-      fieldtype: titleMeta?.fieldtype || "Data",
-      kind: fieldKind(titleMeta?.fieldtype || "Data"),
-    });
-  }
-  return extras.length > 0 ? [...extras, ...fromMeta] : fromMeta;
-}
-
-/** Select fieldtype options string → dropdown options (blank lines dropped). */
-export function selectOptionsFromField(options?: string): Array<{ label: string; value: string }> {
-  return (options ?? "")
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => ({ label: line, value: line }));
-}
-
-/**
- * Human label for a fieldname — descriptor label when known, else a
- * title-cased form. The raw identifier (underscores) never reaches chips or
- * editor rows (no-raw-fieldname rule candidate, parity audit pair 04/16).
- */
-export function fieldLabelFor(fields: FilterFieldDescriptor[], fieldname: string): string {
-  const known = fields.find((field) => field.fieldname === fieldname)?.label;
-  if (known) return known;
-  const pretty = fieldname
-    .replace(/^_+/, "")
-    .split("_")
-    .filter(Boolean)
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(" ");
-  return pretty || fieldname;
-}
-
-// ── Desk operator vocabulary ──────────────────────────────────
-
-export type DeskOperator =
-  | "="
-  | "!="
-  | "like"
-  | "not like"
-  | "in"
-  | "not in"
-  | ">"
-  | "<"
-  | ">="
-  | "<="
-  | "between"
-  | "is set"
-  | "is not set";
-
-/** English operator labels — translate at render time via t(). */
-export const DESK_OPERATOR_LABELS: Record<DeskOperator, string> = {
-  "=": "Equals",
-  "!=": "Not Equals",
-  like: "Like",
-  "not like": "Not Like",
-  in: "In",
-  "not in": "Not In",
-  ">": "Greater Than",
-  "<": "Less Than",
-  ">=": "Greater Than or Equal",
-  "<=": "Less Than or Equal",
-  between: "Between",
-  "is set": "Is Set",
-  "is not set": "Is Not Set",
-};
-
-const BASE_OPERATORS: DeskOperator[] = [
-  "=",
-  "!=",
-  "like",
-  "not like",
-  "in",
-  "not in",
-  "is set",
-  "is not set",
-];
-
-/** Operators offered for an editor kind (desk's list, comparisons gated). */
-export function operatorsForKind(kind: FilterFieldKind): DeskOperator[] {
-  switch (kind) {
-    case "check":
-      return ["=", "!="];
-    case "number":
-    case "date":
-      return ["=", "!=", ">", "<", ">=", "<=", "between", "in", "not in", "is set", "is not set"];
-    default:
-      return BASE_OPERATORS;
-  }
-}
-
-/** Initial operator when a field is picked (desk: text searches, others match). */
-export function defaultOperatorForKind(kind: FilterFieldKind): DeskOperator {
-  return kind === "text" ? "like" : "=";
-}
-
-// ── Editor row model + tuple conversion ───────────────────────
-
-export interface FilterRowDraft {
-  fieldname: string;
-  operator: DeskOperator;
-  /** Scalar editor value (single input / select / link / comma list). */
-  value: string;
-  /** Multi values: in / not in multi-select, or [from, to] for between. */
-  values: string[];
-}
-
-/**
- * Draft → frappe tuple; null while the draft is incomplete.
- * `like` wraps `%value%` unless the user typed their own wildcard;
- * `is set` / `is not set` become ["field", "is", "set" | "not set"].
- */
-export function draftToTuple(draft: FilterRowDraft, kind: FilterFieldKind): FrappeFilter | null {
-  const { fieldname, operator } = draft;
-  if (!fieldname) return null;
-  switch (operator) {
-    case "is set":
-      return [fieldname, "is", "set"];
-    case "is not set":
-      return [fieldname, "is", "not set"];
-    case "in":
-    case "not in": {
-      const values =
-        kind === "select"
-          ? draft.values.map((value) => value.trim()).filter(Boolean)
-          : draft.value
-              .split(",")
-              .map((value) => value.trim())
-              .filter(Boolean);
-      return values.length ? [fieldname, operator, values] : null;
-    }
-    case "between": {
-      const from = (draft.values[0] ?? "").trim();
-      const to = (draft.values[1] ?? "").trim();
-      return from && to ? [fieldname, "between", [from, to]] : null;
-    }
-    case "like":
-    case "not like": {
-      const text = draft.value.trim();
-      if (!text) return null;
-      return [fieldname, operator, text.includes("%") ? text : `%${text}%`];
-    }
-    default: {
-      const text = draft.value.trim();
-      return text ? [fieldname, operator, text] : null;
-    }
-  }
-}
-
-const SCALAR_OPERATORS: readonly string[] = ["=", "!=", "like", "not like", ">", "<", ">=", "<="];
-
-/** Frappe tuple → editable draft (inverse of draftToTuple). */
-export function tupleToDraft(tuple: FrappeFilter): FilterRowDraft {
-  const [fieldname, operator, raw] = tuple;
-  if (operator === "is") {
-    return {
-      fieldname,
-      operator: raw === "set" ? "is set" : "is not set",
-      value: "",
-      values: [],
-    };
-  }
-  if (operator === "in" || operator === "not in") {
-    const values = Array.isArray(raw)
-      ? raw.map(String)
-      : String(raw ?? "")
-          .split(",")
-          .map((value) => value.trim())
-          .filter(Boolean);
-    return { fieldname, operator, value: values.join(", "), values };
-  }
-  if (operator === "between") {
-    const values = Array.isArray(raw) ? raw.map(String) : [];
-    return {
-      fieldname,
-      operator: "between",
-      value: "",
-      values: [values[0] ?? "", values[1] ?? ""],
-    };
-  }
-  const known = SCALAR_OPERATORS.includes(operator) ? (operator as DeskOperator) : "=";
-  return {
-    fieldname,
-    operator: known,
-    value: raw === null || raw === undefined ? "" : String(raw),
-    values: [],
-  };
-}
-
-// ── Filter list helpers ───────────────────────────────────────
-
-/**
- * Quick-filter semantics: a standard filter control owns every tuple for its
- * fieldname — replace them with `tuple`, or clear when `tuple` is undefined.
- */
-export function setFieldFilter(
-  filters: FrappeFilters,
-  fieldname: string,
-  tuple?: FrappeFilter,
-): FrappeFilters {
-  const rest = filters.filter(([name]) => name !== fieldname);
-  return tuple ? [...rest, tuple] : rest;
-}
-
-/** The active quick-filter display value for a fieldname ("" when none). */
-export function quickFilterValue(filters: FrappeFilters, fieldname: string): string {
-  const tuple = filters.find(([name]) => name === fieldname);
-  if (!tuple) return "";
-  const [, operator, raw] = tuple;
-  if (operator === "like") {
-    const text = String(raw ?? "");
-    return text.startsWith("%") && text.endsWith("%") && text.length >= 2
-      ? text.slice(1, -1)
-      : text;
-  }
-  if (operator === "=") return raw === null || raw === undefined ? "" : String(raw);
-  return "";
-}
-
-/** Chip label: "Status = Open", "Due Date between a, b", "Owner is set". */
-export function filterTupleLabel(fields: FilterFieldDescriptor[], tuple: FrappeFilter): string {
-  const [fieldname, operator, raw] = tuple;
-  const label = fieldLabelFor(fields, fieldname);
-  if (operator === "is") return `${label} ${raw === "set" ? "is set" : "is not set"}`;
-  const value = Array.isArray(raw) ? raw.map(String).join(", ") : String(raw ?? "");
-  return `${label} ${operator} ${value}`;
-}
+export {
+  defaultOperatorForKind,
+  DESK_OPERATOR_LABELS,
+  draftToTuple,
+  fieldKind,
+  fieldLabelFor,
+  filterableFieldsFromMeta,
+  filterTupleLabel,
+  operatorsForKind,
+  quickFilterValue,
+  selectOptionsFromField,
+  setFieldFilter,
+  standardDocFilterFields,
+  standardFiltersFromMeta,
+  tupleToDraft,
+} from "@multiplatform.one/frappe-ui";
+export type {
+  DeskOperator,
+  FilterFieldDescriptor,
+  FilterFieldKind,
+  FilterRowDraft,
+} from "@multiplatform.one/frappe-ui";

package/src/list/filter-standard.tsx

@@ -9,17 +9,17 @@
  */
 import { XStack, YStack } from "@multiplatform.one/components";
 import { Checkbox, Input, Select } from "@multiplatform.one/forms";
-import { Link as LinkField } from "@multiplatform.one/frappe-ui";
 import { useEffect, useRef, useState } from "react";
 import type { FrappeFilter, FrappeFilters } from "../shared/types";
 import type { DoctypeMeta } from "../shared/useDoctypeMeta";
 import {
+  Link as LinkField,
   quickFilterValue,
   selectOptionsFromField,
   setFieldFilter,
   standardFiltersFromMeta,
   type FilterFieldDescriptor,
-} from "./filter-fields";
+} from "@multiplatform.one/frappe-ui";
 
 export interface StandardFiltersProps {
   meta?: DoctypeMeta;

package/src/list/list-tools-sheet.tsx

@@ -19,7 +19,7 @@ import { BACKOFFICE_I18N_NAMESPACE } from "../i18n";
 import type { FrappeFilters } from "../shared/types";
 import type { DoctypeMeta } from "../shared/useDoctypeMeta";
 import { FilterEditorPanel } from "./filter-editor";
-import { standardFiltersFromMeta } from "./filter-fields";
+import { standardFiltersFromMeta } from "@multiplatform.one/frappe-ui";
 import { SavedFiltersControl } from "./filter-saved";
 import { SortControl } from "./filter-sort";
 import { StandardFilters } from "./filter-standard";