@multiplatform.one/frappe-ui 7.6.3 → 7.7.0

package/dist/cjs/formEngine/useFormEngine.cjs

@@ -0,0 +1,387 @@
+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 useFormEngine_exports = {};
+__export(useFormEngine_exports, {
+  useFormEngine: () => useFormEngine
+});
+module.exports = __toCommonJS(useFormEngine_exports);
+var import_frappe = require("@multiplatform.one/frappe");
+var import_react = require("react");
+var import_formActions = require("./formActions.cjs");
+var import_formLayout = require("./formLayout.cjs");
+var import_createPrefill = require("./createPrefill.cjs");
+var import_dependsOn = require("../dependsOn.cjs");
+var import_dirtyTracking = require("./dirtyTracking.cjs");
+var import_fetchFrom = require("./fetchFrom.cjs");
+const LAYOUT_TYPES = /* @__PURE__ */new Set(["Section Break", "Column Break", "Tab Break", "Fold"]);
+function isConflictError(err) {
+  const e = err;
+  if (!e) return false;
+  if (e.status === 409) return true;
+  if (e.exc_type === "TimestampMismatchError") return true;
+  return /TimestampMismatch|has been modified/i.test(e.message ?? "");
+}
+function extractServerError(err, fallback) {
+  const e = err;
+  if (e?._server_messages) {
+    try {
+      const messages = JSON.parse(e._server_messages);
+      const parsed = messages.map(msg => {
+        try {
+          return JSON.parse(msg).message ?? "";
+        } catch {
+          return msg;
+        }
+      }).filter(Boolean);
+      if (parsed.length > 0) return parsed.join("\n");
+    } catch {}
+  }
+  return e?.message || fallback;
+}
+function useFormEngine(connection, doctype, name, meta, translate) {
+  const isCreate = !name;
+  const [localDoc, setLocalDoc] = (0, import_react.useState)({});
+  const [baseline, setBaseline] = (0, import_react.useState)(void 0);
+  const [isSaving, setIsSaving] = (0, import_react.useState)(false);
+  const [errors, setErrors] = (0, import_react.useState)({});
+  const [conflict, setConflict] = (0, import_react.useState)(false);
+  const [wasDeleted, setWasDeleted] = (0, import_react.useState)(false);
+  const [currentUser, setCurrentUser] = (0, import_react.useState)("");
+  const everLoadedRef = (0, import_react.useRef)(false);
+  const seededRef = (0, import_react.useRef)(false);
+  const localDocRef = (0, import_react.useRef)(localDoc);
+  localDocRef.current = localDoc;
+  const baselineRef = (0, import_react.useRef)(baseline);
+  baselineRef.current = baseline;
+  const docCollection = (0, import_frappe.useFrappeCollection)(name ? connection : void 0, doctype, {
+    filters: name ? {
+      name
+    } : void 0
+  });
+  const {
+    data: rawDocData,
+    isLoading: isDocLoading
+  } = (0, import_frappe.useLiveQuery)(q => {
+    if (!docCollection || !name) return null;
+    return q.from({
+      _doc: docCollection
+    }).where(({
+      _doc
+    }) => (0, import_frappe.eq)(_doc.name, name));
+  }, [docCollection, name]);
+  const liveDoc = (0, import_react.useMemo)(() => {
+    const arr = Array.isArray(rawDocData) ? rawDocData : rawDocData ? [rawDocData] : [];
+    return arr[0] ?? null;
+  }, [rawDocData]);
+  (0, import_react.useEffect)(() => {
+    if (!connection) return;
+    let cancelled = false;
+    (0, import_formActions.getLoggedUser)((0, import_formActions.createHttpClient)(connection)).then(user => {
+      if (!cancelled) setCurrentUser(user);
+    }).catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+  }, [connection?.baseURL]);
+  (0, import_react.useEffect)(() => {
+    everLoadedRef.current = false;
+    seededRef.current = false;
+    setWasDeleted(false);
+    setConflict(false);
+    setErrors({});
+    setBaseline(void 0);
+    setLocalDoc({});
+  }, [doctype, name]);
+  (0, import_react.useEffect)(() => {
+    if (!isCreate || !meta || seededRef.current) return;
+    seededRef.current = true;
+    const defaults = (0, import_formLayout.buildCreateDefaults)(meta.fields, currentUser || void 0);
+    const prefill = (0, import_createPrefill.takeCreatePrefill)(doctype);
+    setLocalDoc({
+      ...defaults,
+      ...prefill,
+      doctype
+    });
+  }, [isCreate, meta, doctype]);
+  (0, import_react.useEffect)(() => {
+    if (!name) return;
+    if (liveDoc) {
+      everLoadedRef.current = true;
+      setWasDeleted(false);
+      const incoming = liveDoc;
+      const prevBaseline = baselineRef.current;
+      if (!prevBaseline) {
+        setBaseline(incoming);
+        setLocalDoc(incoming);
+        return;
+      }
+      const local = localDocRef.current;
+      const merged = {
+        ...incoming
+      };
+      for (const key of Object.keys(local)) {
+        if (!(0, import_dirtyTracking.isSameValue)(local[key], prevBaseline[key])) merged[key] = local[key];
+      }
+      setBaseline(incoming);
+      setLocalDoc(merged);
+    } else if (everLoadedRef.current && !isDocLoading) {
+      setWasDeleted(true);
+    }
+  }, [liveDoc, isDocLoading, name]);
+  const dirtyFields = (0, import_react.useMemo)(() => (0, import_dirtyTracking.computeDirtyFields)(localDoc, baseline), [localDoc, baseline]);
+  const isDirty = dirtyFields.length > 0;
+  const fetchMap = (0, import_react.useMemo)(() => meta ? (0, import_fetchFrom.buildFetchMap)(meta.fields) : void 0, [meta]);
+  const fetchStateRef = (0, import_react.useRef)({
+    meta: void 0,
+    connection: void 0
+  });
+  fetchStateRef.current = {
+    meta,
+    connection
+  };
+  const fetchMapRef = (0, import_react.useRef)(fetchMap);
+  fetchMapRef.current = fetchMap;
+  const runFetchFrom = (0, import_react.useCallback)((field, value) => {
+    const rules = fetchMapRef.current?.get(field);
+    if (!rules || rules.length === 0) return;
+    const {
+      meta: currentMeta,
+      connection: currentConnection
+    } = fetchStateRef.current;
+    const linkField = currentMeta?.fields.find(f => f.fieldname === field);
+    const targetDoctype = typeof linkField?.options === "string" ? linkField.options : "";
+    const applyPatch = fetched => {
+      setLocalDoc(prev => {
+        if (prev[field] !== value) return prev;
+        const patch = (0, import_fetchFrom.applyFetchedValues)(rules, fetched, prev);
+        return Object.keys(patch).length > 0 ? {
+          ...prev,
+          ...patch
+        } : prev;
+      });
+    };
+    if (value === void 0 || value === null || value === "") {
+      applyPatch({});
+      return;
+    }
+    if (!currentConnection || !targetDoctype || currentConnection.fixtures) return;
+    const sources = Array.from(new Set(rules.map(rule => rule.source)));
+    (0, import_formActions.validateLink)((0, import_formActions.createHttpClient)(currentConnection), targetDoctype, String(value), sources).then(applyPatch).catch(() => {});
+  }, []);
+  const setValue = (0, import_react.useCallback)((field, value) => {
+    setLocalDoc(prev => ({
+      ...prev,
+      [field]: value
+    }));
+    setErrors(prev => {
+      if (!(field in prev)) return prev;
+      const next = {
+        ...prev
+      };
+      delete next[field];
+      return next;
+    });
+    runFetchFrom(field, value);
+  }, [runFetchFrom]);
+  const validate = (0, import_react.useCallback)(() => {
+    if (!meta) return {};
+    const doc = {
+      ...localDocRef.current,
+      __islocal: isCreate ? 1 : 0,
+      ...(currentUser ? {
+        __session_user: currentUser
+      } : {})
+    };
+    const validationErrors = {};
+    if (isCreate && (0, import_formLayout.isPromptNamed)(meta.autoname, meta.naming_rule) && (0, import_dirtyTracking.isEmptyValue)(doc.name)) {
+      validationErrors.name = translate("nameRequired", {
+        defaultValue: "Name is required"
+      });
+    }
+    for (const field of meta.fields) {
+      if (field.hidden || LAYOUT_TYPES.has(field.fieldtype)) continue;
+      if (!(0, import_dependsOn.evaluateDependsOn)(field.depends_on, doc, true)) continue;
+      const required = !!field.reqd || !!field.mandatory_depends_on && (0, import_dependsOn.evaluateDependsOn)(field.mandatory_depends_on, doc, false);
+      if (!required) continue;
+      if ((0, import_dirtyTracking.isEmptyValue)(doc[field.fieldname])) {
+        validationErrors[field.fieldname] = translate("fieldRequired", {
+          defaultValue: "{{label}} is required",
+          label: field.label || field.fieldname
+        });
+      }
+    }
+    return validationErrors;
+  }, [meta, isCreate, currentUser, translate]);
+  const save = (0, import_react.useCallback)(async () => {
+    if (wasDeleted || !connection) return void 0;
+    const requiredErrors = validate();
+    if (Object.keys(requiredErrors).length > 0) {
+      setErrors(requiredErrors);
+      return void 0;
+    }
+    setIsSaving(true);
+    setErrors({});
+    try {
+      if (name) {
+        if (!docCollection) return void 0;
+        const local = localDocRef.current;
+        const base = baselineRef.current ?? {};
+        const changed = Object.keys(local).filter(key => key !== "doctype" && key !== "name" && !(0, import_dirtyTracking.isSameValue)(local[key], base[key]));
+        if (changed.length > 0) {
+          const tx = docCollection.update(name, draft => {
+            for (const key of changed) {
+              draft[key] = local[key];
+            }
+          });
+          await tx.isPersisted.promise;
+        }
+        setConflict(false);
+        return name;
+      }
+      const {
+        doctype: _dt,
+        name: newName,
+        ...values
+      } = localDocRef.current;
+      if (typeof newName === "string" && newName.trim()) {
+        values.name = newName.trim();
+      }
+      const created = await (0, import_formActions.insertDoc)((0, import_formActions.createHttpClient)(connection), doctype, values);
+      return String(created.name ?? "");
+    } catch (err) {
+      if (isConflictError(err)) {
+        setConflict(true);
+        setErrors({
+          general: translate("conflictError", {
+            defaultValue: "This document was modified on the server after you opened it. Reload to get the latest version \u2014 your unsaved edits will be discarded."
+          })
+        });
+      } else {
+        setErrors({
+          general: extractServerError(err, translate("saveFailed", {
+            defaultValue: "Failed to save"
+          }))
+        });
+      }
+      return void 0;
+    } finally {
+      setIsSaving(false);
+    }
+  }, [wasDeleted, connection, validate, name, docCollection, doctype, translate]);
+  const submit = (0, import_react.useCallback)(async () => {
+    if (!connection || !name) return false;
+    setIsSaving(true);
+    setErrors({});
+    try {
+      const base = baselineRef.current;
+      if (!base) return false;
+      await (0, import_formActions.submitDoc)((0, import_formActions.createHttpClient)(connection), {
+        ...base,
+        doctype
+      });
+      return true;
+    } catch (err) {
+      if (isConflictError(err)) setConflict(true);
+      setErrors({
+        general: extractServerError(err, translate("submitFailed", {
+          defaultValue: "Failed to submit"
+        }))
+      });
+      return false;
+    } finally {
+      setIsSaving(false);
+    }
+  }, [connection, name, doctype, translate]);
+  const cancel = (0, import_react.useCallback)(async () => {
+    if (!connection || !name) return false;
+    setIsSaving(true);
+    setErrors({});
+    try {
+      await (0, import_formActions.cancelDoc)((0, import_formActions.createHttpClient)(connection), doctype, name);
+      return true;
+    } catch (err) {
+      setErrors({
+        general: extractServerError(err, translate("cancelFailed", {
+          defaultValue: "Failed to cancel"
+        }))
+      });
+      return false;
+    } finally {
+      setIsSaving(false);
+    }
+  }, [connection, name, doctype, translate]);
+  const remove = (0, import_react.useCallback)(async () => {
+    if (!docCollection || !name || wasDeleted) return false;
+    setIsSaving(true);
+    setErrors({});
+    try {
+      const tx = docCollection.delete(name);
+      await tx.isPersisted.promise;
+      return true;
+    } catch (err) {
+      setErrors({
+        general: extractServerError(err, translate("deleteFailed", {
+          defaultValue: "Failed to delete"
+        }))
+      });
+      return false;
+    } finally {
+      setIsSaving(false);
+    }
+  }, [docCollection, name, wasDeleted, translate]);
+  const reload = (0, import_react.useCallback)(() => {
+    setConflict(false);
+    setErrors({});
+    if (baselineRef.current) {
+      setLocalDoc(baselineRef.current);
+    } else if (!name) {
+      seededRef.current = false;
+      setLocalDoc({
+        doctype
+      });
+    }
+  }, [doctype, name]);
+  const docstatus = Number(baseline?.docstatus ?? 0);
+  return {
+    doc: localDoc,
+    baseline,
+    isLoading: !!name && isDocLoading && !everLoadedRef.current,
+    notFound: !!name && !isDocLoading && !liveDoc && !everLoadedRef.current,
+    wasDeleted,
+    isCreate,
+    isDirty,
+    dirtyFields,
+    isSaving,
+    errors,
+    conflict,
+    currentUser,
+    docstatus,
+    setValue,
+    save,
+    submit,
+    cancel,
+    remove,
+    reload,
+    validate
+  };
+}