@multiplatform.one/frappe 6.0.0

package/dist/cjs/doctype.cjs

@@ -0,0 +1,410 @@
+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 doctype_exports = {};
+__export(doctype_exports, {
+  parseDependsOn: () => parseDependsOn,
+  parseFormLayout: () => parseFormLayout,
+  useDocTypeMeta: () => useDocTypeMeta,
+  useDocTypeSearch: () => useDocTypeSearch,
+  useLinkSearch: () => useLinkSearch
+});
+module.exports = __toCommonJS(doctype_exports);
+var import_react = require("react");
+var import_http = require("./core/http.cjs");
+const metaCache = /* @__PURE__ */new Map();
+const docTypeListCache = /* @__PURE__ */new Map();
+function parseDependsOn(expression) {
+  if (!expression) return () => true;
+  const trimmed = expression.trim();
+  if (trimmed.startsWith("eval:")) {
+    const code = trimmed.slice(5).trim();
+    try {
+      const fn = new Function("doc", `return !!(${code})`);
+      return doc => {
+        try {
+          return fn(doc);
+        } catch {
+          return false;
+        }
+      };
+    } catch {
+      return () => false;
+    }
+  }
+  if (trimmed.includes("doc.")) {
+    try {
+      const fn = new Function("doc", `return !!(${trimmed})`);
+      return doc => {
+        try {
+          return fn(doc);
+        } catch {
+          return false;
+        }
+      };
+    } catch {
+      return () => false;
+    }
+  }
+  return doc => !!doc[trimmed];
+}
+function parseFormLayout(fields) {
+  const sections = [];
+  let currentSection = {
+    columns: [{
+      fields: []
+    }]
+  };
+  sections.push(currentSection);
+  for (const field of fields) {
+    switch (field.fieldtype) {
+      case "Section Break":
+        currentSection = {
+          label: field.label,
+          collapsible: field.collapsible,
+          columns: [{
+            fields: []
+          }]
+        };
+        sections.push(currentSection);
+        break;
+      case "Column Break":
+        currentSection.columns.push({
+          fields: []
+        });
+        break;
+      case "Tab Break":
+        currentSection = {
+          label: field.label,
+          tab: true,
+          columns: [{
+            fields: []
+          }]
+        };
+        sections.push(currentSection);
+        break;
+      default:
+        if (!field.hidden) {
+          const lastColumn = currentSection.columns[currentSection.columns.length - 1];
+          lastColumn.fields.push(field);
+        }
+        break;
+    }
+  }
+  return sections;
+}
+function createHttpClient(config) {
+  const authConfig = config.auth ? {
+    useToken: config.auth.useToken,
+    token: config.auth.token,
+    type: config.auth.type
+  } : void 0;
+  return new import_http.HttpClient(config.baseURL, authConfig);
+}
+function parseRawField(raw) {
+  return {
+    fieldname: raw.fieldname,
+    fieldtype: raw.fieldtype,
+    label: raw.label,
+    options: raw.options,
+    reqd: !!raw.reqd,
+    unique: !!raw.unique,
+    default: raw.default,
+    depends_on: raw.depends_on,
+    read_only: !!raw.read_only,
+    hidden: !!raw.hidden,
+    in_list_view: !!raw.in_list_view,
+    in_standard_filter: !!raw.in_standard_filter,
+    description: raw.description,
+    length: raw.length,
+    precision: raw.precision,
+    search_fields: raw.search_fields,
+    collapsible: !!raw.collapsible
+  };
+}
+function parseRawPermission(raw) {
+  return {
+    role: raw.role,
+    read: !!raw.read,
+    write: !!raw.write,
+    create: !!raw.create,
+    delete: !!raw.delete,
+    submit: !!raw.submit,
+    cancel: !!raw.cancel,
+    amend: !!raw.amend
+  };
+}
+function orderFields(fields, fieldOrder) {
+  const fieldMap = new Map(fields.map(f => [f.fieldname, f]));
+  const ordered = [];
+  const seen = /* @__PURE__ */new Set();
+  for (const name of fieldOrder) {
+    const field = fieldMap.get(name);
+    if (field) {
+      ordered.push(field);
+      seen.add(name);
+    }
+  }
+  for (const field of fields) {
+    if (!seen.has(field.fieldname)) {
+      ordered.push(field);
+    }
+  }
+  return ordered;
+}
+function parseRawDocTypeMeta(raw) {
+  const fields = raw.fields.map(parseRawField);
+  let fieldOrder;
+  if (typeof raw.field_order === "string") {
+    try {
+      fieldOrder = JSON.parse(raw.field_order);
+    } catch {
+      fieldOrder = void 0;
+    }
+  } else if (Array.isArray(raw.field_order)) {
+    fieldOrder = raw.field_order;
+  }
+  const orderedFields = fieldOrder ? orderFields(fields, fieldOrder) : fields;
+  const permissions = (raw.permissions ?? []).map(parseRawPermission);
+  const sections = parseFormLayout(orderedFields);
+  return {
+    name: raw.name,
+    module: raw.module,
+    title_field: raw.title_field,
+    image_field: raw.image_field,
+    is_tree: !!raw.is_tree,
+    sort_field: raw.sort_field || "modified",
+    sort_order: raw.sort_order || "DESC",
+    fields: orderedFields,
+    sections,
+    permissions
+  };
+}
+function useHttpClientRef(config) {
+  const httpRef = (0, import_react.useRef)(void 0);
+  const configKeyRef = (0, import_react.useRef)("");
+  const configKey = config ? `${config.baseURL}:${config.auth?.token ?? ""}` : "";
+  if (config && configKey !== configKeyRef.current) {
+    httpRef.current = createHttpClient(config);
+    configKeyRef.current = configKey;
+  }
+  if (!config) {
+    httpRef.current = void 0;
+    configKeyRef.current = "";
+  }
+  return httpRef;
+}
+function useDocTypeMeta(config, doctype) {
+  const cacheKey = config ? `${config.baseURL}:${doctype}` : "";
+  const [meta, setMeta] = (0, import_react.useState)(() => cacheKey ? metaCache.get(cacheKey) : void 0);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(() => !!config && !!doctype && !(cacheKey && metaCache.has(cacheKey)));
+  const [error, setError] = (0, import_react.useState)(null);
+  const [version, setVersion] = (0, import_react.useState)(0);
+  const prevCacheKeyRef = (0, import_react.useRef)(cacheKey);
+  if (cacheKey !== prevCacheKeyRef.current) {
+    prevCacheKeyRef.current = cacheKey;
+    const cached = cacheKey ? metaCache.get(cacheKey) : void 0;
+    if (cached) {
+      setMeta(cached);
+      setIsLoading(false);
+    } else {
+      setMeta(void 0);
+      setIsLoading(!!config && !!doctype);
+    }
+    setError(null);
+  }
+  const httpRef = useHttpClientRef(config);
+  (0, import_react.useEffect)(() => {
+    if (!config || !doctype) {
+      return;
+    }
+    const key = `${config.baseURL}:${doctype}`;
+    if (metaCache.has(key)) return;
+    const http = httpRef.current;
+    if (!http) return;
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+    (async () => {
+      try {
+        const response = await http.get(`/api/resource/DocType/${encodeURIComponent(doctype)}`);
+        if (cancelled) return;
+        const raw = response.payload?.data;
+        if (!raw) {
+          throw new Error(`No data returned for DocType "${doctype}"`);
+        }
+        const parsed = parseRawDocTypeMeta(raw);
+        metaCache.set(key, parsed);
+        setMeta(parsed);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setMeta(void 0);
+      } finally {
+        if (!cancelled) setIsLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [cacheKey, version]);
+  const refetch = (0, import_react.useCallback)(() => {
+    if (cacheKey) metaCache.delete(cacheKey);
+    setVersion(v => v + 1);
+  }, [cacheKey]);
+  return {
+    meta,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function useLinkSearch(config, doctype, options) {
+  const query = options?.query ?? "";
+  const searchFields = options?.searchFields;
+  const filters = options?.filters;
+  const limit = options?.limit ?? 20;
+  const [results, setResults] = (0, import_react.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const {
+    meta
+  } = useDocTypeMeta(config, doctype);
+  const httpRef = useHttpClientRef(config);
+  (0, import_react.useEffect)(() => {
+    const http = httpRef.current;
+    if (!http || !query) {
+      setResults([]);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+    const timer = setTimeout(async () => {
+      try {
+        const titleField = meta?.title_field || "name";
+        const effectiveSearchFields = searchFields ?? (titleField !== "name" ? [titleField, "name"] : ["name"]);
+        const orFilters = effectiveSearchFields.map(f => [f, "like", `%${query}%`]);
+        const requestFields = [... /* @__PURE__ */new Set(["name", titleField, ...effectiveSearchFields])];
+        const params = {
+          doctype,
+          fields: requestFields,
+          or_filters: orFilters,
+          limit_page_length: limit
+        };
+        if (filters) params.filters = filters;
+        const response = await http.get("/api/method/frappe.client.get_list", params);
+        if (cancelled) return;
+        const docs = response.payload?.message ?? [];
+        setResults(docs.map(doc => ({
+          value: String(doc.name ?? ""),
+          label: String(doc[titleField] ?? doc.name ?? ""),
+          description: void 0
+        })));
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setResults([]);
+      } finally {
+        if (!cancelled) setIsLoading(false);
+      }
+    }, 300);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [query, doctype, meta?.title_field, searchFields, filters, limit]);
+  return {
+    results,
+    isLoading,
+    error
+  };
+}
+function useDocTypeSearch(config, query) {
+  const [allDocTypes, setAllDocTypes] = (0, import_react.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const httpRef = useHttpClientRef(config);
+  (0, import_react.useEffect)(() => {
+    if (!config) {
+      setAllDocTypes([]);
+      setIsLoading(false);
+      return;
+    }
+    const key = config.baseURL;
+    const cached = docTypeListCache.get(key);
+    if (cached) {
+      setAllDocTypes(cached);
+      return;
+    }
+    const http = httpRef.current;
+    if (!http) return;
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+    (async () => {
+      try {
+        const response = await http.get("/api/resource/DocType", {
+          limit_page_length: 0,
+          fields: ["name", "module", "title"]
+        });
+        if (cancelled) return;
+        const list = response.payload?.data ?? [];
+        docTypeListCache.set(key, list);
+        setAllDocTypes(list);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (!cancelled) setIsLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [config]);
+  const results = (0, import_react.useMemo)(() => {
+    if (!query || allDocTypes.length === 0) return [];
+    const lowerQuery = query.toLowerCase();
+    const matching = allDocTypes.filter(dt => dt.name.toLowerCase().includes(lowerQuery) || dt.module.toLowerCase().includes(lowerQuery) || dt.title?.toLowerCase().includes(lowerQuery));
+    return matching.flatMap(dt => [{
+      label: `${dt.name} List`,
+      doctype: dt.name,
+      type: "list"
+    }, {
+      label: `${dt.name} Report`,
+      doctype: dt.name,
+      type: "report"
+    }, {
+      label: `New ${dt.name}`,
+      doctype: dt.name,
+      type: "new"
+    }]);
+  }, [query, allDocTypes]);
+  return {
+    results,
+    isLoading,
+    error
+  };
+}