@multiplatform.one/frappe-ui 7.28.1 → 7.29.0

package/dist/cjs/useFrappeForm.cjs

@@ -0,0 +1,558 @@
+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 useFrappeForm_exports = {};
+__export(useFrappeForm_exports, {
+  useFrappeForm: () => useFrappeForm
+});
+module.exports = __toCommonJS(useFrappeForm_exports);
+var import_frappe = require("@multiplatform.one/frappe");
+var import_db = require("@tanstack/db");
+var import_react = require("react");
+var import_react_i18next = require("react-i18next");
+var import_FrappeProvider = require("./FrappeProvider.cjs");
+var import_createPrefill = require("./formEngine/createPrefill.cjs");
+var import_dirtyTracking = require("./formEngine/dirtyTracking.cjs");
+var import_docLifecycle = require("./formEngine/docLifecycle.cjs");
+var import_fetchFrom = require("./formEngine/fetchFrom.cjs");
+var import_fieldPermissions = require("./formEngine/fieldPermissions.cjs");
+var import_formActions = require("./formEngine/formActions.cjs");
+var import_formLayout = require("./formEngine/formLayout.cjs");
+var import_useAmendedAs = require("./formEngine/useAmendedAs.cjs");
+var import_useDocRights = require("./formEngine/useDocRights.cjs");
+var import_useFormEngine = require("./formEngine/useFormEngine.cjs");
+function sectionsToLayoutFields(sections) {
+  const fields = [];
+  sections.forEach((section, sectionIndex) => {
+    fields.push({
+      fieldname: `__section_${sectionIndex}`,
+      fieldtype: section.tab ? "Tab Break" : "Section Break",
+      label: section.label,
+      collapsible: section.collapsible ? 1 : 0
+    });
+    section.columns.forEach((column, columnIndex) => {
+      if (columnIndex > 0) {
+        fields.push({
+          fieldname: `__column_${sectionIndex}_${columnIndex}`,
+          fieldtype: "Column Break"
+        });
+      }
+      fields.push(...column.fields);
+    });
+  });
+  return fields;
+}
+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 useFrappeForm(options) {
+  const {
+    doctype,
+    name,
+    baseURL,
+    auth,
+    syncOptions,
+    fields,
+    sections,
+    hideFields,
+    hideSections,
+    roles,
+    rights: rightsOverride,
+    shares: sharesOverride,
+    readShares = true,
+    disabled = false,
+    initialDoc,
+    meta: metaSource
+  } = options;
+  const config = (0, import_FrappeProvider.useFrappeConfig)();
+  const {
+    t
+  } = (0, import_react_i18next.useTranslation)();
+  const isCreate = !name;
+  const seedDoc = name && initialDoc && initialDoc.name === name ? initialDoc : void 0;
+  const seedRef = (0, import_react.useRef)(seedDoc);
+  seedRef.current = seedDoc;
+  const [localDoc, setLocalDoc] = (0, import_react.useState)(() => seedDoc ?? {});
+  const [baselineDoc, setBaselineDoc] = (0, import_react.useState)(() => seedDoc);
+  const [docError, setDocError] = (0, import_react.useState)(null);
+  const [conflictFields, setConflictFields] = (0, import_react.useState)([]);
+  const [saveConflict, setSaveConflict] = (0, import_react.useState)(false);
+  const [wasDeleted, setWasDeleted] = (0, import_react.useState)(false);
+  const [isSubmitting, setIsSubmitting] = (0, import_react.useState)(false);
+  const [errors, setErrors] = (0, import_react.useState)({});
+  const [activeTab, setActiveTab] = (0, import_react.useState)(void 0);
+  const everLoadedRef = (0, import_react.useRef)(false);
+  const localDocRef = (0, import_react.useRef)(localDoc);
+  localDocRef.current = localDoc;
+  const baselineRef = (0, import_react.useRef)(baselineDoc);
+  baselineRef.current = baselineDoc;
+  const createDraftRef = (0, import_react.useRef)(void 0);
+  const createSeededRef = (0, import_react.useRef)(void 0);
+  const finalBaseURL = baseURL ?? config?.baseURL;
+  const finalAuth = auth ?? config?.auth;
+  const finalSyncOptions = syncOptions ?? config?.syncOptions;
+  const frappeConfig = (0, import_react.useMemo)(() => finalBaseURL ? {
+    baseURL: finalBaseURL,
+    socketPort: config?.socketPort,
+    siteName: config?.siteName,
+    socketBaseURL: config?.socketBaseURL,
+    auth: finalAuth,
+    syncOptions: finalSyncOptions,
+    realtime: config?.realtime,
+    fixtures: config?.fixtures
+  } : void 0, [finalBaseURL, config?.socketPort, config?.siteName, config?.socketBaseURL, config?.realtime, finalAuth, finalSyncOptions, config?.fixtures]);
+  const ownMeta = (0, import_frappe.useDocTypeMeta)(metaSource ? void 0 : frappeConfig, doctype);
+  const meta = metaSource ? metaSource.meta : ownMeta.meta;
+  const isMetaLoading = metaSource ? metaSource.isLoading : ownMeta.isLoading;
+  const metaError = metaSource ? metaSource.error : ownMeta.error;
+  const isSubmittable = !!meta?.is_submittable;
+  const docstatus = Number(baselineDoc?.docstatus ?? 0);
+  const layoutFields = (0, import_react.useMemo)(() => {
+    if (!meta) return void 0;
+    return sections ? sectionsToLayoutFields(sections) : meta.fields;
+  }, [meta, sections]);
+  const amendedAs = (0, import_useAmendedAs.useAmendedAs)(isSubmittable && docstatus === 2 ? frappeConfig : void 0, doctype, name);
+  const promptNamed = isCreate && !!meta && (0, import_formLayout.isPromptNamed)(meta.autoname, meta.naming_rule);
+  const fetchMap = (0, import_react.useMemo)(() => meta ? (0, import_fetchFrom.buildFetchMap)(meta.fields) : void 0, [meta]);
+  const handleDocSyncError = (0, import_react.useCallback)(err => {
+    setDocError(err instanceof Error ? err : new Error(String(err)));
+  }, []);
+  const docCollection = (0, import_frappe.useFrappeCollection)(name ? frappeConfig : void 0, doctype, {
+    fields,
+    filters: name ? {
+      name
+    } : void 0,
+    onSyncError: handleDocSyncError
+  });
+  const {
+    data: rawDocData,
+    isLoading: isDocLoading
+  } = (0, import_frappe.useLiveQuery)(q => {
+    if (!docCollection || !name) return null;
+    return q.from({
+      _doc: docCollection
+    }).where(({
+      _doc
+    }) => {
+      if (!_doc) return (0, import_db.eq)(name, name);
+      return (0, import_db.eq)(_doc.name, name);
+    });
+  }, [docCollection, name]);
+  const liveDoc = (0, import_react.useMemo)(() => {
+    const arr = Array.isArray(rawDocData) ? rawDocData : rawDocData ? [rawDocData] : [];
+    const doc = arr[0] ?? null;
+    return doc ? {
+      data: doc,
+      isLoading: isDocLoading
+    } : name ? {
+      data: null,
+      isLoading: isDocLoading
+    } : null;
+  }, [rawDocData, isDocLoading, name]);
+  const collection = (0, import_frappe.useFrappeCollection)(name ? void 0 : frappeConfig, doctype, {
+    fields
+  });
+  const shareCollection = (0, import_frappe.useFrappeCollection)(readShares && !sharesOverride && name ? frappeConfig : void 0, "DocShare", {
+    fields: ["name", "user", "everyone", "read", "write", "share"],
+    filters: {
+      share_doctype: doctype,
+      share_name: name
+    }
+  });
+  const {
+    data: rawShareRows
+  } = (0, import_frappe.useLiveQuery)(q => shareCollection ? q.from({
+    _share: shareCollection
+  }) : null, [shareCollection]);
+  const shareRows = (0, import_react.useMemo)(() => sharesOverride ?? (shareCollection ? rawShareRows ?? [] : void 0), [sharesOverride, shareCollection, rawShareRows]);
+  const owner = baselineDoc?.owner;
+  const {
+    rights: sessionRights,
+    pending: sessionPending,
+    roles: effectiveRoles,
+    user
+  } = (0, import_useDocRights.useDocRights)(frappeConfig, meta, {
+    roles,
+    owner: typeof owner === "string" ? owner : void 0,
+    shares: shareRows
+  });
+  const rights = rightsOverride ?? sessionRights;
+  const rightsPending = rightsOverride ? false : sessionPending;
+  const permLevels = (0, import_react.useMemo)(() => (0, import_fieldPermissions.buildPermLevelMatrix)(meta?.permissions, effectiveRoles), [meta?.permissions, effectiveRoles]);
+  const tabs = (0, import_react.useMemo)(() => {
+    if (!layoutFields) return void 0;
+    return (0, import_formLayout.buildFormTabs)({
+      fields: layoutFields,
+      doc: {
+        ...localDoc,
+        __islocal: isCreate ? 1 : 0,
+        ...(user ? {
+          __session_user: user
+        } : {})
+      },
+      docstatus,
+      formReadOnly: !!meta?.read_only,
+      isCreate,
+      detailsLabel: t("Details"),
+      permLevels,
+      hiddenFields: hideFields,
+      hiddenSections: hideSections
+    });
+  }, [layoutFields, localDoc, isCreate, user, docstatus, meta?.read_only, permLevels, hideFields, hideSections, t]);
+  (0, import_react.useEffect)(() => {
+    everLoadedRef.current = false;
+    if (name) createDraftRef.current = void 0;
+    createSeededRef.current = void 0;
+    setWasDeleted(false);
+    setConflictFields([]);
+    setSaveConflict(false);
+    setDocError(null);
+    const seed = seedRef.current;
+    setBaselineDoc(seed);
+    if (seed) setLocalDoc(seed);
+  }, [doctype, name]);
+  (0, import_frappe.useFrappeDoctypeEvents)(name ? frappeConfig : void 0, doctype, event => {
+    if (event.type !== "doc_deleted") return;
+    const payload = event.payload;
+    if (payload?.name === name) setWasDeleted(true);
+  }, Boolean(name));
+  (0, import_react.useEffect)(() => {
+    const incoming = liveDoc?.data;
+    if (incoming) {
+      everLoadedRef.current = true;
+      setWasDeleted(false);
+      const baseline = baselineRef.current;
+      if (!baseline) {
+        setBaselineDoc(incoming);
+        setLocalDoc(incoming);
+        return;
+      }
+      const local = localDocRef.current;
+      const merged = {
+        ...incoming
+      };
+      const newConflicts = [];
+      for (const key of Object.keys(local)) {
+        const localValue = local[key];
+        if ((0, import_dirtyTracking.isSameValue)(localValue, baseline[key])) continue;
+        merged[key] = localValue;
+        const remote = incoming[key];
+        if (!(0, import_dirtyTracking.isSameValue)(remote, baseline[key]) && !(0, import_dirtyTracking.isSameValue)(remote, localValue)) {
+          newConflicts.push(key);
+        }
+      }
+      setBaselineDoc(incoming);
+      setLocalDoc(merged);
+      if (newConflicts.length > 0) {
+        setConflictFields(prev => Array.from(/* @__PURE__ */new Set([...prev, ...newConflicts])));
+      }
+    } else if (name && everLoadedRef.current && !liveDoc?.isLoading) {
+      setWasDeleted(true);
+    }
+  }, [liveDoc?.data, liveDoc?.isLoading, doctype, name]);
+  (0, import_react.useEffect)(() => {
+    if (name) return;
+    if (createDraftRef.current?.doctype !== doctype) {
+      createDraftRef.current = {
+        doctype,
+        values: (0, import_createPrefill.takeCreatePrefill)(doctype)
+      };
+    }
+    const draft = createDraftRef.current.values;
+    const defaults = meta ? (0, import_formLayout.buildCreateDefaults)(meta.fields, user) : {};
+    const fresh = createSeededRef.current !== doctype;
+    createSeededRef.current = doctype;
+    setLocalDoc(prev => ({
+      ...defaults,
+      ...draft,
+      ...(fresh ? {} : prev),
+      doctype
+    }));
+  }, [name, doctype, meta, user]);
+  const dirtyFields = (0, import_react.useMemo)(() => (0, import_dirtyTracking.computeDirtyFields)(localDoc, baselineDoc), [localDoc, baselineDoc]);
+  const isDirty = dirtyFields.length > 0;
+  const runFetchFrom = (field, value) => {
+    const rules = fetchMap?.get(field);
+    if (!rules || rules.length === 0 || !frappeConfig) return;
+    const applyPatch = fetched2 => {
+      setLocalDoc(prev => {
+        const current = prev;
+        if (current[field] !== value) return prev;
+        const patch = (0, import_fetchFrom.applyFetchedValues)(rules, fetched2, current);
+        return Object.keys(patch).length > 0 ? {
+          ...current,
+          ...patch
+        } : prev;
+      });
+    };
+    if ((0, import_dirtyTracking.isEmptyValue)(value)) {
+      applyPatch({});
+      return;
+    }
+    const linkField = meta?.fields.find(metaField => metaField.fieldname === field);
+    const targetDoctype = typeof linkField?.options === "string" ? linkField.options : "";
+    if (!targetDoctype) return;
+    const sources = Array.from(new Set(rules.map(rule => rule.source)));
+    const fixtures = frappeConfig.fixtures;
+    const fetched = fixtures ? fixtures.getDoc(targetDoctype, String(value), sources).then(doc => doc ?? {}) : (0, import_formActions.validateLink)((0, import_formActions.createHttpClient)(frappeConfig), targetDoctype, String(value), sources);
+    fetched.then(applyPatch).catch(() => void 0);
+  };
+  const setValue = (field, value) => {
+    setLocalDoc(prev => ({
+      ...prev,
+      [field]: value
+    }));
+    setErrors(prev => {
+      if (!(String(field) in prev)) return prev;
+      const next = {
+        ...prev
+      };
+      delete next[String(field)];
+      return next;
+    });
+    runFetchFrom(String(field), value);
+  };
+  const validate = () => {
+    if (!tabs) return {};
+    const validationErrors = {};
+    const doc = localDoc;
+    if (promptNamed && (0, import_dirtyTracking.isEmptyValue)(doc.name)) {
+      validationErrors.name = t("Name is required");
+    }
+    for (const tab of tabs) {
+      for (const field of tab.schema.fields) {
+        if (!field.required) continue;
+        if ((0, import_dirtyTracking.isEmptyValue)(doc[field.name])) {
+          validationErrors[field.name] = t("{{label}} is required", {
+            label: field.label || field.name
+          });
+        }
+      }
+    }
+    return validationErrors;
+  };
+  const canWrite = isCreate ? rights.create : rights.write;
+  const save = async () => {
+    if (wasDeleted || !canWrite || disabled) return void 0;
+    const requiredErrors = validate();
+    if (Object.keys(requiredErrors).length > 0) {
+      setErrors(requiredErrors);
+      return void 0;
+    }
+    setIsSubmitting(true);
+    setErrors({});
+    try {
+      if (name) {
+        if (!docCollection) return void 0;
+        if (dirtyFields.length > 0) {
+          const local = localDoc;
+          const tx2 = docCollection.update(name, draft => {
+            for (const key of dirtyFields) {
+              draft[key] = local[key];
+            }
+          });
+          await tx2.isPersisted.promise;
+        }
+        setConflictFields([]);
+        setSaveConflict(false);
+        return name;
+      }
+      if (!collection || !frappeConfig) return void 0;
+      const temporaryName = localDoc.name ?? `new-${Date.now()}`;
+      const docToInsert = {
+        ...localDoc,
+        doctype,
+        name: temporaryName
+      };
+      const tx = collection.insert(docToInsert);
+      await tx.isPersisted.promise;
+      return (0, import_frappe.getFrappeSyncModule)(frappeConfig)?.createdName(temporaryName) ?? temporaryName;
+    } catch (err) {
+      const e = err;
+      if (isConflictError(err)) setSaveConflict(true);
+      if (e?.exc_type === "ValidationError") {
+        const validationErrors = {};
+        if (e._server_messages) {
+          try {
+            const messages = JSON.parse(e._server_messages);
+            for (const msg of messages) {
+              const parsed = typeof msg === "string" ? JSON.parse(msg) : msg;
+              if (parsed.message) {
+                validationErrors.general = parsed.message;
+              }
+            }
+          } catch {
+            validationErrors.general = t("Validation error occurred");
+          }
+        }
+        setErrors(validationErrors);
+      } else {
+        setErrors({
+          general: e?.message || t("Failed to save document")
+        });
+      }
+      return void 0;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const reset = () => {
+    if (baselineDoc) {
+      setLocalDoc(baselineDoc);
+    } else if (liveDoc?.data) {
+      setLocalDoc(liveDoc.data);
+    } else {
+      setLocalDoc({
+        doctype
+      });
+    }
+    setConflictFields([]);
+    setSaveConflict(false);
+    setErrors({});
+  };
+  const remove = async () => {
+    if (!docCollection || !name || wasDeleted || !rights.delete) return false;
+    setIsSubmitting(true);
+    setErrors({});
+    try {
+      const tx = docCollection.delete(name);
+      await tx.isPersisted.promise;
+      return true;
+    } catch (err) {
+      setErrors({
+        general: err?.message || t("Failed to delete")
+      });
+      return false;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const transitionDocstatus = async (to, failure) => {
+    if (!docCollection || !name || wasDeleted || !rights[to === 1 ? "submit" : "cancel"]) {
+      return false;
+    }
+    if (to === 1) {
+      const requiredErrors = validate();
+      if (Object.keys(requiredErrors).length > 0) {
+        setErrors(requiredErrors);
+        return false;
+      }
+    }
+    setIsSubmitting(true);
+    setErrors({});
+    try {
+      const tx = docCollection.update(name, draft => {
+        draft.docstatus = to;
+      });
+      await tx.isPersisted.promise;
+      return true;
+    } catch (err) {
+      if (isConflictError(err)) setSaveConflict(true);
+      setErrors({
+        general: (0, import_useFormEngine.extractServerError)(err, failure)
+      });
+      return false;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const submitDocument = () => transitionDocstatus(1, t("Failed to submit"));
+  const cancelDocument = () => transitionDocstatus(2, t("Failed to cancel"));
+  const amend = () => {
+    if (!meta || !name || !rights.amend) return void 0;
+    const draft = (0, import_docLifecycle.buildAmendValues)(meta.fields, localDoc, name);
+    (0, import_createPrefill.setCreatePrefill)(doctype, draft);
+    return draft;
+  };
+  const duplicate = () => {
+    if (!meta) return void 0;
+    const values = (0, import_formLayout.buildCopyValues)(meta.fields, localDoc);
+    (0, import_createPrefill.setCreatePrefill)(doctype, values);
+    return values;
+  };
+  const fieldTargets = (0, import_react.useMemo)(() => (tabs ?? []).flatMap(tab => tab.schema.fields.map(field => ({
+    name: field.name,
+    label: field.label || field.name,
+    tabKey: tab.key,
+    tabLabel: tab.label
+  }))), [tabs]);
+  const revealField = fieldName => {
+    const target = fieldTargets.find(field => field.name === fieldName);
+    if (!target) return false;
+    setActiveTab(target.tabKey);
+    return true;
+  };
+  const isDocReading = Boolean(name) && (!docCollection || Boolean(liveDoc?.isLoading));
+  const showsSeed = Boolean(seedDoc) && isDocReading;
+  const status = !name ? "ready" : docError && !liveDoc?.data && !wasDeleted ? "error" : isDocReading && !showsSeed && !wasDeleted ? "loading" : !isDocReading && !liveDoc?.data && !wasDeleted ? "notFound" : "ready";
+  return {
+    doctype,
+    name,
+    isCreate,
+    connection: frappeConfig,
+    meta,
+    metaLoading: isMetaLoading,
+    metaError,
+    doc: localDoc,
+    baseline: baselineDoc,
+    setValue,
+    errors,
+    setErrors,
+    dirtyFields,
+    isDirty,
+    isSubmitting,
+    docstatus,
+    isSubmittable,
+    rights,
+    rightsPending,
+    roles: effectiveRoles,
+    user,
+    shareRows,
+    canWrite,
+    readOnly: disabled || wasDeleted || !!meta?.read_only || !canWrite,
+    wasDeleted,
+    conflictFields,
+    conflict: saveConflict || conflictFields.length > 0,
+    status,
+    docError,
+    showsSeed,
+    tabs,
+    promptNamed,
+    fieldTargets,
+    activeTab,
+    setActiveTab,
+    revealField,
+    amendedAs,
+    validate,
+    save,
+    submitDocument,
+    cancelDocument,
+    remove,
+    reset,
+    amend,
+    duplicate
+  };
+}