@multiplatform.one/frappe-ui 6.7.0 → 7.1.0

package/dist/cjs/useFrappeFacets.cjs

@@ -0,0 +1,329 @@
+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 useFrappeFacets_exports = {};
+__export(useFrappeFacets_exports, {
+  NO_TAGS_LABEL: () => NO_TAGS_LABEL,
+  filtersExcludingField: () => filtersExcludingField,
+  isFacetFilterActive: () => isFacetFilterActive,
+  scrubUserFacetRows: () => scrubUserFacetRows,
+  toggleFacetFilter: () => toggleFacetFilter,
+  useFrappeFacets: () => useFrappeFacets
+});
+module.exports = __toCommonJS(useFrappeFacets_exports);
+var import_frappe = require("@multiplatform.one/frappe");
+var import_react = require("react");
+var import_FrappeProvider = require("./FrappeProvider.cjs");
+const NO_TAGS_LABEL = "No Tags";
+function filtersExcludingField(filters, fieldname) {
+  return filters.filter(filter => filter[0] !== fieldname);
+}
+function isFacetFilterActive(filters, tuple) {
+  return filters.some(filter => filter[0] === tuple[0] && String(filter[1]).toLowerCase() === String(tuple[1]).toLowerCase() && String(filter[2]) === String(tuple[2]));
+}
+function toggleFacetFilter(filters, tuple) {
+  const active = isFacetFilterActive(filters, tuple);
+  const rest = filtersExcludingField(filters, tuple[0]);
+  return active ? rest : [...rest, tuple];
+}
+function scrubUserFacetRows(rows, sessionUser) {
+  if (!sessionUser) return rows;
+  const current = rows.find(row => row.value === sessionUser);
+  const rest = rows.filter(row => !["Guest", "Administrator", sessionUser].includes(row.value));
+  return current ? [current, ...rest] : rest;
+}
+const callCache = /* @__PURE__ */new Map();
+function getCall(connection) {
+  const key = `${connection.baseURL}:${connection.auth?.token ?? ""}:${connection.auth?.type ?? ""}`;
+  let call = callCache.get(key);
+  if (!call) {
+    const authConfig = connection.auth ? {
+      useToken: connection.auth.useToken,
+      token: connection.auth.token,
+      type: connection.auth.type
+    } : void 0;
+    call = new import_frappe.CallModule(new import_frappe.HttpClient(connection.baseURL, authConfig));
+    callCache.set(key, call);
+  }
+  return call;
+}
+async function fetchGroupByCount(call, doctype, currentFilters, field) {
+  const res = await call.post("frappe.desk.listview.get_group_by_count", {
+    doctype,
+    current_filters: JSON.stringify(currentFilters),
+    field
+  });
+  const rows = res.payload?.message ?? [];
+  return rows.filter(row => !!row.name && row.count !== 0).map(row => ({
+    value: row.name,
+    count: Number(row.count) || 0
+  }));
+}
+async function fetchColumnStats(call, doctype, fieldname, currentFilters) {
+  const res = await call.post("frappe.desk.reportview.get_sidebar_stats", {
+    doctype,
+    stats: JSON.stringify([fieldname]),
+    filters: JSON.stringify(currentFilters)
+  });
+  return res.payload?.message?.stats?.[fieldname] ?? [];
+}
+function mapTagStats(entries) {
+  return entries.map(([label, count]) => ({
+    value: String(label),
+    count: Number(count) || 0,
+    isNoTags: String(label) === NO_TAGS_LABEL
+  })).filter(row => row.value !== "" && (!row.isNoTags || row.count > 0));
+}
+function mapColumnStats(entries) {
+  return entries.map(([value, count]) => ({
+    value: String(value),
+    count: Number(count) || 0
+  })).filter(row => row.value !== "").sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
+}
+function parseAssignedUsers(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter(user => typeof user === "string" && !!user);
+  }
+  if (typeof raw !== "string" || !raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter(user => typeof user === "string" && !!user) : [];
+  } catch {
+    return [];
+  }
+}
+function toSortedCounts(counts) {
+  return [...counts.entries()].map(([value, count]) => ({
+    value,
+    count
+  })).sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
+}
+async function fetchFixtureFacets(fixtures, doctype, filters, statusFieldname, columnFieldnames) {
+  const all = await fixtures.getList(doctype);
+  const rowsFor = fieldname => {
+    const others = filtersExcludingField(filters, fieldname);
+    if (others.length === 0) return all;
+    return all.filter(row => (0, import_frappe.matchesFilters)(row, others));
+  };
+  const assignedCounts = /* @__PURE__ */new Map();
+  for (const row of rowsFor("_assign")) {
+    for (const user of parseAssignedUsers(row._assign)) {
+      assignedCounts.set(user, (assignedCounts.get(user) ?? 0) + 1);
+    }
+  }
+  const ownerCounts = /* @__PURE__ */new Map();
+  for (const row of rowsFor("owner")) {
+    if (typeof row.owner === "string" && row.owner) {
+      ownerCounts.set(row.owner, (ownerCounts.get(row.owner) ?? 0) + 1);
+    }
+  }
+  const tagCounts = /* @__PURE__ */new Map();
+  let noTagCount = 0;
+  for (const row of rowsFor("_user_tags")) {
+    const tags2 = String(row._user_tags ?? "").split(",").map(tag => tag.trim()).filter(Boolean);
+    if (tags2.length === 0) {
+      noTagCount += 1;
+      continue;
+    }
+    for (const tag of tags2) tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+  }
+  const tags = toSortedCounts(tagCounts);
+  if (tags.length > 0 && noTagCount > 0) {
+    tags.push({
+      value: NO_TAGS_LABEL,
+      count: noTagCount,
+      isNoTags: true
+    });
+  }
+  const countColumn = fieldname => {
+    const counts = /* @__PURE__ */new Map();
+    for (const row of rowsFor(fieldname)) {
+      const value = row[fieldname];
+      if (value !== void 0 && value !== null && value !== "") {
+        counts.set(String(value), (counts.get(String(value)) ?? 0) + 1);
+      }
+    }
+    return toSortedCounts(counts);
+  };
+  const columns = {};
+  for (const fieldname of columnFieldnames ?? []) {
+    columns[fieldname] = countColumn(fieldname);
+  }
+  return {
+    assigned: toSortedCounts(assignedCounts),
+    owner: toSortedCounts(ownerCounts),
+    tags,
+    status: statusFieldname ? countColumn(statusFieldname) : void 0,
+    columns
+  };
+}
+const IDLE_FACET = {
+  isLoading: false,
+  isStale: false
+};
+function initialState(columnFieldnames) {
+  return {
+    assigned: {
+      isLoading: true,
+      isStale: false
+    },
+    owner: {
+      isLoading: true,
+      isStale: false
+    },
+    tags: {
+      isLoading: true,
+      isStale: false
+    },
+    status: IDLE_FACET,
+    columns: Object.fromEntries(columnFieldnames.map(fieldname => [fieldname, {
+      isLoading: true,
+      isStale: false
+    }]))
+  };
+}
+function useFrappeFacets(doctype, filters, options) {
+  const ambient = (0, import_FrappeProvider.useFrappeConfig)();
+  const connection = options?.connection ?? ambient;
+  const statusFieldname = options?.statusFieldname;
+  const enabled = options?.enabled !== false && !!doctype && !!connection;
+  const filtersKey = JSON.stringify(filters ?? []);
+  const columnsKey = JSON.stringify(options?.columns ?? []);
+  const columnFieldnames = (0, import_react.useMemo)(() => JSON.parse(columnsKey), [columnsKey]);
+  const [state, setState] = (0, import_react.useState)(() => initialState(columnFieldnames));
+  const [generation, setGeneration] = (0, import_react.useState)(0);
+  const identity = `${connection?.baseURL ?? ""}:${doctype}:${statusFieldname ?? ""}:${columnsKey}`;
+  const identityRef = (0, import_react.useRef)(identity);
+  const fetchSeq = (0, import_react.useRef)(0);
+  const connectionRef = (0, import_react.useRef)(connection);
+  connectionRef.current = connection;
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    const conn = connectionRef.current;
+    if (!conn) return;
+    const seq = ++fetchSeq.current;
+    const activeFilters = JSON.parse(filtersKey);
+    if (identityRef.current !== identity) {
+      identityRef.current = identity;
+      setState(initialState(columnFieldnames));
+    } else {
+      setState(prev => {
+        const revalidate = facet => facet.options !== void 0 ? {
+          ...facet,
+          isStale: true,
+          error: void 0
+        } : {
+          ...facet,
+          isLoading: true,
+          error: void 0
+        };
+        return {
+          assigned: revalidate(prev.assigned),
+          owner: revalidate(prev.owner),
+          tags: revalidate(prev.tags),
+          status: statusFieldname ? revalidate(prev.status) : IDLE_FACET,
+          columns: Object.fromEntries(columnFieldnames.map(fieldname => [fieldname, revalidate(prev.columns[fieldname] ?? {
+            isLoading: true,
+            isStale: false
+          })]))
+        };
+      });
+    }
+    const done = (key, rows) => {
+      if (seq !== fetchSeq.current) return;
+      setState(prev => Array.isArray(key) ? {
+        ...prev,
+        columns: {
+          ...prev.columns,
+          [key[1]]: {
+            options: rows,
+            isLoading: false,
+            isStale: false
+          }
+        }
+      } : {
+        ...prev,
+        [key]: {
+          options: rows,
+          isLoading: false,
+          isStale: false
+        }
+      });
+    };
+    const fail = (key, error) => {
+      if (seq !== fetchSeq.current) return;
+      const failed = facet => ({
+        ...facet,
+        isLoading: false,
+        isStale: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      setState(prev => Array.isArray(key) ? {
+        ...prev,
+        columns: {
+          ...prev.columns,
+          [key[1]]: failed(prev.columns[key[1]] ?? IDLE_FACET)
+        }
+      } : {
+        ...prev,
+        [key]: failed(prev[key])
+      });
+    };
+    if (conn.fixtures) {
+      fetchFixtureFacets(conn.fixtures, doctype, activeFilters, statusFieldname, columnFieldnames).then(facets => {
+        done("assigned", facets.assigned);
+        done("owner", facets.owner);
+        done("tags", facets.tags);
+        if (statusFieldname) done("status", facets.status ?? []);
+        for (const fieldname of columnFieldnames) {
+          done(["columns", fieldname], facets.columns[fieldname] ?? []);
+        }
+      }).catch(error => {
+        fail("assigned", error);
+        fail("owner", error);
+        fail("tags", error);
+        if (statusFieldname) fail("status", error);
+        for (const fieldname of columnFieldnames) fail(["columns", fieldname], error);
+      });
+      return;
+    }
+    const call = getCall(conn);
+    fetchGroupByCount(call, doctype, filtersExcludingField(activeFilters, "_assign"), "assigned_to").then(rows => done("assigned", rows)).catch(error => fail("assigned", error));
+    fetchGroupByCount(call, doctype, filtersExcludingField(activeFilters, "owner"), "owner").then(rows => done("owner", rows)).catch(error => fail("owner", error));
+    fetchColumnStats(call, doctype, "_user_tags", filtersExcludingField(activeFilters, "_user_tags")).then(entries => done("tags", mapTagStats(entries))).catch(error => fail("tags", error));
+    if (statusFieldname) {
+      fetchColumnStats(call, doctype, statusFieldname, filtersExcludingField(activeFilters, statusFieldname)).then(entries => done("status", mapColumnStats(entries))).catch(error => fail("status", error));
+    }
+    for (const fieldname of columnFieldnames) {
+      fetchColumnStats(call, doctype, fieldname, filtersExcludingField(activeFilters, fieldname)).then(entries => done(["columns", fieldname], mapColumnStats(entries))).catch(error => fail(["columns", fieldname], error));
+    }
+  }, [enabled, identity, filtersKey, generation]);
+  const refresh = (0, import_react.useCallback)(() => setGeneration(current => current + 1), []);
+  return (0, import_react.useMemo)(() => ({
+    assigned: state.assigned,
+    owner: state.owner,
+    tags: state.tags,
+    status: state.status,
+    columns: state.columns,
+    refresh
+  }), [state, refresh]);
+}