@ram_28/kf-ai-sdk 1.0.10 → 1.0.12

package/dist/form.mjs

@@ -0,0 +1,1346 @@
+var Ue = Object.defineProperty;
+var _e = (t, e, r) => e in t ? Ue(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var U = (t, e, r) => _e(t, typeof e != "symbol" ? e + "" : e, r);
+import { useState as M, useRef as Y, useEffect as z, useMemo as $, useCallback as S } from "react";
+import { useForm as $e } from "react-hook-form";
+import { useQuery as ue } from "@tanstack/react-query";
+import { a as I } from "./client-CfvLiGfP.js";
+import { g as qe } from "./metadata-DBcoDth-.js";
+function Be() {
+  const t = /* @__PURE__ */ new Date();
+  return {
+    NOW: t,
+    TODAY: new Date(t.getFullYear(), t.getMonth(), t.getDate()),
+    CURRENT_USER: {
+      // These would typically come from auth context
+      EmpId: 1,
+      Email: "user@example.com",
+      FirstName: "John",
+      LastName: "Doe",
+      Role: "User"
+    },
+    CURRENT_USER_ID: 1
+  };
+}
+const je = {
+  // String functions
+  CONCAT: (...t) => t.map((e) => String(e || "")).join(""),
+  TRIM: (t) => String(t || "").trim(),
+  LENGTH: (t) => String(t || "").length,
+  UPPER: (t) => String(t || "").toUpperCase(),
+  LOWER: (t) => String(t || "").toLowerCase(),
+  SUBSTRING: (t, e, r) => {
+    const s = String(t || "");
+    return r !== void 0 ? s.substring(e, e + r) : s.substring(e);
+  },
+  CONTAINS: (t, e) => String(t || "").includes(String(e || "")),
+  // Date functions
+  YEAR: (t) => new Date(t).getFullYear(),
+  MONTH: (t) => new Date(t).getMonth() + 1,
+  // 1-based
+  DAY: (t) => new Date(t).getDate(),
+  DATE_DIFF: (t, e) => {
+    const r = new Date(t), s = new Date(e), a = Math.abs(r.getTime() - s.getTime());
+    return Math.ceil(a / (1e3 * 60 * 60 * 24));
+  },
+  ADD_DAYS: (t, e) => {
+    const r = new Date(t);
+    return r.setDate(r.getDate() + e), r;
+  },
+  ADD_MONTHS: (t, e) => {
+    const r = new Date(t);
+    return r.setMonth(r.getMonth() + e), r;
+  },
+  // Math functions
+  SUM: (...t) => t.reduce((e, r) => e + (Number(r) || 0), 0),
+  AVG: (...t) => {
+    const e = t.filter((r) => !isNaN(Number(r)));
+    return e.length > 0 ? e.reduce((r, s) => r + Number(s), 0) / e.length : 0;
+  },
+  MIN: (...t) => Math.min(...t.map((e) => Number(e) || 0)),
+  MAX: (...t) => Math.max(...t.map((e) => Number(e) || 0)),
+  ROUND: (t) => Math.round(Number(t) || 0),
+  FLOOR: (t) => Math.floor(Number(t) || 0),
+  CEIL: (t) => Math.ceil(Number(t) || 0),
+  ABS: (t) => Math.abs(Number(t) || 0),
+  // Conditional functions
+  IF: (t, e, r) => t ? e : r,
+  // Validation functions
+  IS_NULL: (t) => t == null,
+  IS_EMPTY: (t) => !t || String(t).trim() === "",
+  IS_NUMBER: (t) => !isNaN(Number(t)) && t !== "" && t !== null && t !== void 0,
+  IS_DATE: (t) => {
+    const e = new Date(t);
+    return !isNaN(e.getTime());
+  },
+  // System functions
+  AUTO_NUMBER: () => Math.floor(Math.random() * 1e4) + 1e3,
+  // Mock implementation
+  UUID: () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (t) => {
+    const e = Math.random() * 16 | 0;
+    return (t == "x" ? e : e & 3 | 8).toString(16);
+  }),
+  // Array functions
+  ARRAY_LENGTH: (t) => Array.isArray(t) ? t.length : 0,
+  ARRAY_CONTAINS: (t, e) => Array.isArray(t) ? t.includes(e) : !1,
+  ARRAY_JOIN: (t, e = ",") => Array.isArray(t) ? t.join(e) : ""
+};
+function x(t, e) {
+  var r;
+  switch (t.Type) {
+    case "Literal":
+      return t.Value;
+    case "SystemIdentifier":
+      if (t.Property) {
+        const f = e.systemValues[t.Name];
+        return W(f, t.Property.Name);
+      }
+      return e.systemValues[t.Name];
+    case "Identifier":
+      if (t.Property) {
+        const f = ce(t, e);
+        return W(f, t.Property.Name);
+      }
+      return ce(t, e);
+    case "MemberExpression":
+      if (!t.Arguments || t.Arguments.length === 0)
+        throw new Error("MemberExpression requires Arguments array");
+      const s = x(t.Arguments[0], e), a = (r = t.Arguments[0].Property) == null ? void 0 : r.Name;
+      return a ? W(s, a) : s;
+    case "BinaryExpression":
+      if (!t.Arguments || t.Arguments.length !== 2)
+        throw new Error("BinaryExpression requires exactly 2 arguments");
+      const n = x(t.Arguments[0], e), o = x(t.Arguments[1], e);
+      return Pe(t.Operator, n, o);
+    case "LogicalExpression":
+      if (!t.Arguments || t.Arguments.length < 2)
+        throw new Error("LogicalExpression requires at least 2 arguments");
+      return ke(t.Operator, t.Arguments, e);
+    case "CallExpression":
+      if (!t.Callee)
+        throw new Error("CallExpression requires Callee");
+      const u = je[t.Callee];
+      if (!u)
+        throw new Error(`Unknown function: ${t.Callee}`);
+      const p = (t.Arguments || []).map(
+        (f) => x(f, e)
+      );
+      return u(...p);
+    case "AssignmentExpression":
+      if (!t.Arguments || t.Arguments.length !== 1)
+        throw new Error("AssignmentExpression requires exactly 1 argument");
+      return x(t.Arguments[0], e);
+    default:
+      throw new Error(`Unknown expression type: ${t.Type}`);
+  }
+}
+function ce(t, e) {
+  const { Name: r, Source: s } = t;
+  if (!r)
+    throw new Error("Identifier requires Name");
+  switch (s) {
+    case "Input":
+    default:
+      return e.formValues[r];
+  }
+}
+function W(t, e) {
+  if (!(!t || typeof t != "object"))
+    return t[e];
+}
+function Pe(t, e, r) {
+  const s = (a) => a == null ? 0 : typeof a == "number" ? a : typeof a == "object" && a !== null && "value" in a ? Number(a.value) || 0 : Number(a) || 0;
+  switch (t) {
+    case "==":
+      return e == r;
+    case "!=":
+      return e != r;
+    case ">":
+      return s(e) > s(r);
+    case "<":
+      return s(e) < s(r);
+    case ">=":
+      return s(e) >= s(r);
+    case "<=":
+      return s(e) <= s(r);
+    case "+":
+      return s(e) + s(r);
+    case "-":
+      return s(e) - s(r);
+    case "*":
+      return s(e) * s(r);
+    case "/":
+      const a = s(r);
+      return a !== 0 ? s(e) / a : 0;
+    default:
+      throw new Error(`Unknown binary operator: ${t}`);
+  }
+}
+function ke(t, e, r) {
+  switch (t) {
+    case "AND":
+      return e.every((s) => !!x(s, r));
+    case "OR":
+      return e.some((s) => !!x(s, r));
+    default:
+      throw new Error(`Unknown logical operator: ${t}`);
+  }
+}
+function pe(t, e, r = {}) {
+  const s = {
+    formValues: e,
+    systemValues: Be(),
+    referenceData: r
+  };
+  try {
+    return x(t, s);
+  } catch (a) {
+    return console.warn("Expression evaluation failed:", a), !1;
+  }
+}
+function le(t, e, r = {}) {
+  const s = [];
+  for (const a of t)
+    try {
+      pe(
+        a.Condition.ExpressionTree,
+        e,
+        r
+      ) || s.push({
+        isValid: !1,
+        message: a.Message,
+        fieldName: a.Id
+      });
+    } catch (n) {
+      console.warn(`Cross-field validation rule ${a.Id} failed:`, n);
+    }
+  return s;
+}
+function Ye(t, e = {}, r = {}) {
+  try {
+    return pe(t, e, r);
+  } catch (s) {
+    return console.warn("Default value calculation failed:", s), null;
+  }
+}
+function de(t, e) {
+  var u, p, f;
+  const r = ((u = t.Expression) == null ? void 0 : u.toLowerCase()) || "", s = ((p = t.Name) == null ? void 0 : p.toLowerCase()) || "", a = ((f = t.Id) == null ? void 0 : f.toLowerCase()) || "", n = e.toLowerCase();
+  return s.includes("required") || a.includes("required") ? !0 : [
+    `${n} != null`,
+    `${n} != ''`,
+    `trim(${n}) != ''`,
+    `${n}!=null`,
+    `${n}!=''`
+  ].some((N) => r.includes(N));
+}
+function ze(t) {
+  const e = { ...t };
+  e.Rules || (e.Rules = {
+    Validation: {},
+    Computation: {},
+    BusinessLogic: {}
+  }), e.Rules.Validation || (e.Rules.Validation = {}), e.Rules.Computation || (e.Rules.Computation = {}), e.Rules.BusinessLogic || (e.Rules.BusinessLogic = {});
+  const r = { ...e.Fields };
+  return Object.entries(r).forEach(([s, a]) => {
+    let n = a.Required || !1;
+    if (a.Validation && Array.isArray(a.Validation))
+      if (a.Validation.length > 0 && typeof a.Validation[0] == "object") {
+        const o = [];
+        a.Validation.forEach((u) => {
+          e.Rules.Validation[u.Id] = u, o.push(u.Id), de(u, s) && (n = !0);
+        }), r[s] = {
+          ...a,
+          Validation: o,
+          Required: n
+        };
+      } else
+        a.Validation.forEach((u) => {
+          var f;
+          const p = (f = e.Rules.Validation) == null ? void 0 : f[u];
+          p && de(p, s) && (n = !0);
+        }), n && !a.Required && (r[s] = {
+          ...a,
+          Required: !0
+        });
+    if (a.Formula) {
+      const o = `RULE_COMPUTE_${s.toUpperCase()}`;
+      e.Rules.Computation[o] = {
+        Id: o,
+        Name: a.Formula.Id || `Compute ${s}`,
+        Description: a.Formula.Description || `Computes value for ${s}`,
+        Expression: a.Formula.Expression,
+        ExpressionTree: a.Formula.ExpressionTree,
+        ResultType: a.Type
+      };
+    }
+  }), e.Fields = r, e;
+}
+function Ke(t) {
+  var r, s, a;
+  const e = {
+    validation: {},
+    computation: {},
+    businessLogic: {}
+  };
+  return (r = t.Rules) != null && r.Validation && (e.validation = { ...t.Rules.Validation }), (s = t.Rules) != null && s.Computation && (e.computation = { ...t.Rules.Computation }), (a = t.Rules) != null && a.BusinessLogic && (e.businessLogic = { ...t.Rules.BusinessLogic }), e;
+}
+function Je(t) {
+  var s;
+  const e = {};
+  if (!((s = t.Rules) != null && s.Computation)) return e;
+  const r = Object.entries(t.Fields).filter(([a, n]) => n.Computed).map(([a]) => a);
+  return r.sort((a, n) => n.length - a.length), Object.entries(t.Rules.Computation).forEach(([a, n]) => {
+    const o = a.toUpperCase().replace(/[_-]/g, "");
+    for (const p of r) {
+      const f = p.toUpperCase().replace(/[_-]/g, "");
+      if (o.includes(f)) {
+        e[a] = p;
+        return;
+      }
+    }
+    const u = `${n.Name || ""} ${n.Description || ""}`.toLowerCase();
+    for (const p of r)
+      if (u.includes(p.toLowerCase())) {
+        e[a] = p;
+        return;
+      }
+  }), e;
+}
+function We(t, e) {
+  const r = {};
+  Object.keys(t.Fields).forEach((a) => {
+    r[a] = {
+      validation: [],
+      computation: [],
+      businessLogic: []
+    };
+  }), Object.entries(t.Fields).forEach(([a, n]) => {
+    n.Validation && Array.isArray(n.Validation) && n.Validation.forEach((u) => {
+      e.validation[u] ? r[a].validation.push(u) : e.computation[u] ? r[a].computation.push(u) : e.businessLogic[u] && r[a].businessLogic.push(u);
+    }), n.Formula && Object.entries(e.computation).forEach(([o, u]) => {
+      var p;
+      u.Expression === ((p = n.Formula) == null ? void 0 : p.Expression) && (r[a].computation.includes(o) || r[a].computation.push(o));
+    });
+  });
+  const s = Je(t);
+  return Object.entries(s).forEach(([a, n]) => {
+    r[n] && !r[n].computation.includes(a) && r[n].computation.push(a);
+  }), r;
+}
+function He(t, e) {
+  const r = {}, s = {
+    editable: !0,
+    readable: !0,
+    hidden: !1
+  };
+  return Object.keys(t.Fields).forEach((a) => {
+    var p, f, N, L, b, i;
+    if (!e || !((p = t.RolePermission) != null && p[e])) {
+      r[a] = s;
+      return;
+    }
+    const n = t.RolePermission[e], o = ((f = n.Editable) == null ? void 0 : f.includes(a)) || ((N = n.Editable) == null ? void 0 : N.includes("*")) || !1, u = ((L = n.ReadOnly) == null ? void 0 : L.includes(a)) || ((b = n.ReadOnly) == null ? void 0 : b.includes("*")) || o;
+    r[a] = {
+      editable: o && !((i = n.ReadOnly) != null && i.includes(a)),
+      readable: u,
+      hidden: !u
+    };
+  }), r;
+}
+function Ge(t, e) {
+  switch (t) {
+    case "String":
+      return e.toLowerCase().includes("email") ? "email" : e.toLowerCase().includes("password") ? "password" : "text";
+    case "Number":
+      return "number";
+    case "Boolean":
+      return "checkbox";
+    case "Date":
+      return "date";
+    case "DateTime":
+      return "datetime-local";
+    case "Reference":
+      return "reference";
+    case "Array":
+    case "Object":
+      return "textarea";
+    default:
+      return "text";
+  }
+}
+function he(t) {
+  return t.replace(/([A-Z])/g, " $1").replace(/^./, (e) => e.toUpperCase()).replace(/_/g, " ").trim();
+}
+function Xe(t, e, r) {
+  const s = {};
+  switch (e.Required && (s.required = {
+    value: !0,
+    message: `${he(t)} is required`
+  }), e.Type) {
+    case "Number":
+      s.valueAsNumber = !0;
+      break;
+    case "Date":
+    case "DateTime":
+      s.valueAsDate = !0;
+      break;
+  }
+  return e.Validation && e.Validation.length > 0 && (s.validate = () => !0), s;
+}
+function Qe(t) {
+  return t.Values ? t.Values.Mode === "Static" && t.Values.Items ? t.Values.Items.map((e) => ({
+    value: e.Value,
+    label: e.Label
+  })) : t.Values.Mode === "Dynamic" && t.Values.Reference ? [] : [] : [];
+}
+function Ze(t, e = {}) {
+  if (!t.DefaultValue)
+    switch (t.Type) {
+      case "Boolean":
+        return !1;
+      case "Number":
+        return 0;
+      case "String":
+        return "";
+      case "Array":
+        return [];
+      case "Object":
+        return {};
+      default:
+        return;
+    }
+  return Ye(
+    t.DefaultValue.ExpressionTree,
+    e
+  );
+}
+function et(t, e, r, s = {}, a, n) {
+  const o = {
+    editable: !0,
+    readable: !0,
+    hidden: !1
+  }, p = n || {
+    validation: [],
+    computation: [],
+    businessLogic: []
+  }, f = e.Computed || !!e.Formula || p.computation.length > 0, N = Xe(t, e);
+  return f && (N.disabled = !0), {
+    name: t,
+    type: Ge(e.Type, t),
+    label: e.Name || he(t),
+    required: e.Required || !1,
+    computed: f,
+    defaultValue: Ze(e, s),
+    options: Qe(e),
+    validation: N,
+    description: e.Description,
+    _bdoField: e,
+    permission: a || o,
+    rules: p
+  };
+}
+function tt(t, e = {}, r) {
+  let s = t;
+  s = ze(s);
+  const a = {}, n = [], o = [], u = [], p = [], f = Ke(s), N = We(s, f), L = He(s, r);
+  for (const [b, i] of Object.entries(s.Fields)) {
+    if (b.startsWith("_") && !["_id"].includes(b))
+      continue;
+    const q = L[b];
+    if (q.hidden)
+      continue;
+    const C = et(
+      b,
+      i,
+      s.Fields,
+      e,
+      q,
+      N[b] || {
+        validation: [],
+        computation: [],
+        businessLogic: []
+      }
+    );
+    a[b] = C, n.push(b), C.computed && o.push(b), C.required && u.push(b);
+  }
+  return {
+    fields: a,
+    fieldOrder: n,
+    computedFields: o,
+    requiredFields: u,
+    crossFieldValidation: p,
+    rules: f,
+    fieldRules: N,
+    rolePermissions: s.RolePermission
+  };
+}
+function rt(t) {
+  var r;
+  if (t.type !== "reference" || !((r = t._bdoField.Values) != null && r.Reference))
+    return null;
+  const e = t._bdoField.Values.Reference;
+  return {
+    businessObject: e.BusinessObject,
+    fields: e.Fields || ["_id"],
+    // Default to ID field
+    filters: e.Filters,
+    sort: e.Sort
+  };
+}
+function st(t) {
+  const e = {};
+  for (const [r, s] of Object.entries(t.fields))
+    if (s.type === "reference") {
+      const a = rt(s);
+      a && (e[r] = a);
+    }
+  return e;
+}
+async function at(t) {
+  try {
+    const r = (await qe(t)).BOBlob;
+    if (!r || typeof r != "object" || !r.Fields)
+      throw new Error(`Invalid BDO schema response for ${t}`);
+    return r;
+  } catch (e) {
+    throw console.error(`Schema fetch error for ${t}:`, e), new Error(
+      `Failed to load form schema: ${e instanceof Error ? e.message : "Unknown error"}`
+    );
+  }
+}
+async function nt(t, e = 3) {
+  let r;
+  for (let s = 1; s <= e; s++)
+    try {
+      return await at(t);
+    } catch (a) {
+      if (r = a, s < e) {
+        const n = Math.min(1e3 * Math.pow(2, s - 1), 5e3);
+        await new Promise((o) => setTimeout(o, n));
+        continue;
+      }
+    }
+  throw r;
+}
+async function it(t, e) {
+  try {
+    return await I(t).get(e);
+  } catch (r) {
+    throw console.error(`Record fetch error for ${t}/${e}:`, r), new Error(
+      `Failed to load record: ${r instanceof Error ? r.message : "Unknown error"}`
+    );
+  }
+}
+async function ot(t, e, r, s) {
+  try {
+    let a;
+    if (e === "create")
+      return a = await I(t).create(r), {
+        success: !0,
+        data: a,
+        recordId: a._id || s
+      };
+    if (e === "update") {
+      if (!s)
+        throw new Error("Record ID is required for update operations");
+      return a = await I(t).update(s, r), {
+        success: !0,
+        data: a,
+        recordId: a._id || s
+      };
+    } else
+      throw new Error(`Unsupported operation: ${e}`);
+  } catch (a) {
+    return console.error("Form submission error:", a), {
+      success: !1,
+      error: new Error(
+        `Failed to ${e} record: ${a instanceof Error ? a.message : "Unknown error"}`
+      )
+    };
+  }
+}
+async function ut(t, e = ["_id"], r, s) {
+  try {
+    const a = {};
+    return r && (a.Filter = r), s && (a.Sort = s), e.length > 0 && (a.Field = e), (await I(t).list(a)).Data || [];
+  } catch (a) {
+    return console.error(`Reference data fetch error for ${t}:`, a), [];
+  }
+}
+async function ct(t) {
+  const e = {}, r = Object.entries(t).map(
+    async ([a, n]) => {
+      try {
+        const o = await ut(
+          n.businessObject,
+          n.fields,
+          n.filters,
+          n.sort
+        );
+        return [a, o];
+      } catch (o) {
+        return console.warn(`Failed to fetch reference data for ${a}:`, o), [a, []];
+      }
+    }
+  );
+  return (await Promise.allSettled(r)).forEach((a) => {
+    if (a.status === "fulfilled") {
+      const [n, o] = a.value;
+      e[n] = Array.isArray(o) ? o : [];
+    }
+  }), e;
+}
+function lt(t, e, r = "create", s) {
+  const a = {};
+  return Object.keys(t).forEach((n) => {
+    const o = n, u = t[o];
+    if (!e.includes(n) && u !== void 0) {
+      if (r === "create") {
+        a[o] = u;
+        return;
+      }
+      if (r === "update") {
+        if (!s) {
+          a[o] = u;
+          return;
+        }
+        const p = s[o];
+        JSON.stringify(u) !== JSON.stringify(p) && (a[o] = u);
+      }
+    }
+  }), a;
+}
+function At(t) {
+  var e, r, s, a;
+  return typeof t == "string" ? t : t != null && t.message ? t.message : (r = (e = t == null ? void 0 : t.response) == null ? void 0 : e.data) != null && r.message ? t.response.data.message : (a = (s = t == null ? void 0 : t.response) == null ? void 0 : s.data) != null && a.error ? t.response.data.error : "An unexpected error occurred";
+}
+function Ct(t) {
+  var e, r;
+  return !navigator.onLine || (t == null ? void 0 : t.code) === "NETWORK_ERROR" || ((e = t == null ? void 0 : t.message) == null ? void 0 : e.toLowerCase().includes("network")) || ((r = t == null ? void 0 : t.message) == null ? void 0 : r.toLowerCase().includes("fetch"));
+}
+function Dt(t) {
+  var e, r, s;
+  return (t == null ? void 0 : t.status) === 400 || ((e = t == null ? void 0 : t.response) == null ? void 0 : e.status) === 400 || ((r = t == null ? void 0 : t.message) == null ? void 0 : r.toLowerCase().includes("validation")) || ((s = t == null ? void 0 : t.message) == null ? void 0 : s.toLowerCase().includes("invalid"));
+}
+const _ = /* @__PURE__ */ new Map();
+function dt(t, e, r = 10) {
+  _.set(t, {
+    data: e,
+    timestamp: Date.now(),
+    ttl: r * 60 * 1e3
+  });
+}
+function ft(t) {
+  const e = _.get(t);
+  return e ? Date.now() - e.timestamp > e.ttl ? (_.delete(t), null) : e.data : null;
+}
+function Ot(t) {
+  t ? Array.from(_.keys()).filter(
+    (r) => r.startsWith(t)
+  ).forEach((r) => _.delete(r)) : _.clear();
+}
+async function mt(t) {
+  const e = `schema:${t}`, r = ft(e);
+  if (r)
+    return r;
+  const s = await nt(t);
+  return dt(e, s, 30), s;
+}
+class fe {
+  constructor(e = 1e3) {
+    U(this, "cache", /* @__PURE__ */ new Map());
+    U(this, "maxSize");
+    this.maxSize = e;
+  }
+  get(e) {
+    const r = this.cache.get(e);
+    return r !== void 0 && (this.cache.delete(e), this.cache.set(e, r)), r;
+  }
+  set(e, r) {
+    if (this.cache.has(e))
+      this.cache.delete(e);
+    else if (this.cache.size >= this.maxSize) {
+      const s = this.cache.keys().next().value;
+      this.cache.delete(s);
+    }
+    this.cache.set(e, r);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+function pt(t) {
+  const e = /* @__PURE__ */ new Set();
+  function r(s) {
+    switch (s.Type) {
+      case "Identifier":
+        s.Name && !s.Name.startsWith("$") && e.add(s.Name);
+        break;
+      case "MemberExpression":
+        s.Arguments && s.Arguments.forEach(r);
+        break;
+      case "CallExpression":
+      case "BinaryExpression":
+      case "LogicalExpression":
+        s.Arguments && s.Arguments.forEach(r);
+        break;
+    }
+  }
+  return r(t), e;
+}
+class ht {
+  constructor() {
+    U(this, "resultCache", new fe(500));
+    U(this, "dependencyCache", new fe(200));
+    U(this, "compiledExpressions", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Create cache key from expression and context
+   */
+  createCacheKey(e, r) {
+    const s = JSON.stringify(e), a = JSON.stringify(r);
+    return `${s}:${a}`;
+  }
+  /**
+   * Get expression dependencies (cached)
+   */
+  getDependencies(e) {
+    const r = JSON.stringify(e);
+    let s = this.dependencyCache.get(r);
+    return s || (s = pt(e), this.dependencyCache.set(r, s)), s;
+  }
+  /**
+   * Check if expression result is cached and context hasn't changed
+   */
+  getCachedResult(e, r, s) {
+    if (!s) return;
+    const a = this.getDependencies(e);
+    for (const o of a)
+      if (r[o] !== s[o])
+        return;
+    const n = this.createCacheKey(e, r);
+    return this.resultCache.get(n);
+  }
+  /**
+   * Evaluate expression with caching
+   */
+  evaluate(e, r, s) {
+    const a = this.getCachedResult(e, r, s);
+    if (a !== void 0)
+      return a;
+    const n = this.evaluateNode(e, r), o = this.createCacheKey(e, r);
+    return this.resultCache.set(o, n), n;
+  }
+  /**
+   * Core expression evaluation logic
+   */
+  evaluateNode(e, r) {
+    switch (e.Type) {
+      case "Literal":
+        return e.Value;
+      case "Identifier":
+        return this.getIdentifierValue(e, r);
+      case "BinaryExpression":
+        return this.evaluateBinaryExpression(e, r);
+      case "LogicalExpression":
+        return this.evaluateLogicalExpression(e, r);
+      case "CallExpression":
+        return this.evaluateCallExpression(e, r);
+      case "MemberExpression":
+        return this.evaluateMemberExpression(e, r);
+      default:
+        throw new Error(`Unsupported expression type: ${e.Type}`);
+    }
+  }
+  /**
+   * Get identifier value with system context support
+   */
+  getIdentifierValue(e, r) {
+    if (e.Name) {
+      if (e.Name === "NOW") return /* @__PURE__ */ new Date();
+      if (e.Name === "TODAY") {
+        const s = /* @__PURE__ */ new Date();
+        return new Date(s.getFullYear(), s.getMonth(), s.getDate());
+      }
+      return e.Name === "CURRENT_USER_ID" ? 1 : e.Name === "CURRENT_USER" ? {
+        EmpId: 1,
+        Email: "user@example.com",
+        FirstName: "John",
+        LastName: "Doe",
+        Role: "User"
+      } : r[e.Name];
+    }
+  }
+  /**
+   * Evaluate binary expressions with type coercion
+   */
+  evaluateBinaryExpression(e, r) {
+    if (!e.Arguments || e.Arguments.length !== 2)
+      throw new Error("Binary expression requires exactly 2 arguments");
+    const s = this.evaluateNode(e.Arguments[0], r), a = this.evaluateNode(e.Arguments[1], r);
+    switch (e.Operator) {
+      case "==":
+        return s == a;
+      case "!=":
+        return s != a;
+      case "===":
+        return s === a;
+      case "!==":
+        return s !== a;
+      case "<":
+        return Number(s) < Number(a);
+      case "<=":
+        return Number(s) <= Number(a);
+      case ">":
+        return Number(s) > Number(a);
+      case ">=":
+        return Number(s) >= Number(a);
+      case "+":
+        return Number(s) + Number(a);
+      case "-":
+        return Number(s) - Number(a);
+      case "*":
+        return Number(s) * Number(a);
+      case "/":
+        return Number(s) / Number(a);
+      case "%":
+        return Number(s) % Number(a);
+      default:
+        throw new Error(`Unsupported binary operator: ${e.Operator}`);
+    }
+  }
+  /**
+   * Evaluate logical expressions with short-circuiting
+   */
+  evaluateLogicalExpression(e, r) {
+    if (!e.Arguments || e.Arguments.length < 2)
+      throw new Error("Logical expression requires at least 2 arguments");
+    switch (e.Operator) {
+      case "AND":
+        for (const s of e.Arguments)
+          if (!this.evaluateNode(s, r)) return !1;
+        return !0;
+      case "OR":
+        for (const s of e.Arguments)
+          if (this.evaluateNode(s, r)) return !0;
+        return !1;
+      default:
+        throw new Error(`Unsupported logical operator: ${e.Operator}`);
+    }
+  }
+  /**
+   * Evaluate function calls with built-in functions
+   */
+  evaluateCallExpression(e, r) {
+    var a;
+    if (!e.Callee)
+      throw new Error("Call expression requires a function name");
+    const s = ((a = e.Arguments) == null ? void 0 : a.map((n) => this.evaluateNode(n, r))) || [];
+    switch (e.Callee) {
+      case "CONCAT":
+        return s.map((f) => String(f || "")).join("");
+      case "TRIM":
+        return String(s[0] || "").trim();
+      case "LENGTH":
+        return String(s[0] || "").length;
+      case "UPPER":
+        return String(s[0] || "").toUpperCase();
+      case "LOWER":
+        return String(s[0] || "").toLowerCase();
+      case "CONTAINS":
+        return String(s[0] || "").includes(String(s[1] || ""));
+      case "MATCHES":
+        return new RegExp(String(s[1])).test(String(s[0] || ""));
+      case "SUM":
+        return s.reduce((f, N) => f + (Number(N) || 0), 0);
+      case "AVG":
+        const n = s.filter((f) => !isNaN(Number(f)));
+        return n.length > 0 ? n.reduce((f, N) => f + Number(N), 0) / n.length : 0;
+      case "MIN":
+        return Math.min(...s.map((f) => Number(f) || 0));
+      case "MAX":
+        return Math.max(...s.map((f) => Number(f) || 0));
+      case "ROUND":
+        return Math.round(Number(s[0]) || 0);
+      case "FLOOR":
+        return Math.floor(Number(s[0]) || 0);
+      case "CEIL":
+        return Math.ceil(Number(s[0]) || 0);
+      case "ABS":
+        return Math.abs(Number(s[0]) || 0);
+      case "YEAR":
+        return new Date(s[0]).getFullYear();
+      case "MONTH":
+        return new Date(s[0]).getMonth() + 1;
+      case "DAY":
+        return new Date(s[0]).getDate();
+      case "DATE_DIFF":
+        const o = new Date(s[0]), u = new Date(s[1]), p = Math.abs(o.getTime() - u.getTime());
+        return Math.ceil(p / (1e3 * 60 * 60 * 24));
+      case "IF":
+        return s[0] ? s[1] : s[2];
+      case "AUTO_NUMBER":
+        return Math.floor(Math.random() * 1e4);
+      default:
+        throw new Error(`Unknown function: ${e.Callee}`);
+    }
+  }
+  /**
+   * Evaluate member expressions
+   */
+  evaluateMemberExpression(e, r) {
+    var n;
+    if (!e.Arguments || e.Arguments.length === 0)
+      throw new Error("Member expression requires arguments");
+    const s = this.evaluateNode(e.Arguments[0], r), a = (n = e.Arguments[0].Property) == null ? void 0 : n.Name;
+    return a && s && typeof s == "object" ? s[a] : s;
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.resultCache.clear(), this.dependencyCache.clear(), this.compiledExpressions.clear();
+  }
+}
+const ge = new ht();
+function gt(t, e, r, s, a) {
+  if (!r || r.length === 0)
+    return { isValid: !0 };
+  const n = { ...s, [t]: e };
+  for (const o of r)
+    try {
+      if (!ge.evaluate(
+        o.ExpressionTree,
+        n,
+        a
+      ))
+        return {
+          isValid: !1,
+          message: o.Message || `Validation failed for ${o.Name}`,
+          fieldName: t
+        };
+    } catch (u) {
+      console.warn(`Validation rule ${o.Id} failed to evaluate:`, u);
+    }
+  return { isValid: !0 };
+}
+function me(t) {
+  return Array.from(ge.getDependencies(t));
+}
+function xt(t) {
+  const {
+    source: e,
+    operation: r,
+    recordId: s,
+    defaultValues: a = {},
+    mode: n = "onBlur",
+    // Validation mode - controls when errors are shown (see types.ts for details)
+    enabled: o = !0,
+    userRole: u,
+    onSchemaError: p,
+    skipSchemaFetch: f = !1,
+    schema: N,
+    interactionMode: L = "interactive"
+  } = t, b = L === "interactive", [i, q] = M(null), [C, be] = M({}), [H, G] = M(!1), [we] = M({}), [V, X] = M(null), [Q, Z] = M(!1), [ye, ee] = M(null), B = Y(!1), K = Y(null), j = Y(null), v = Y(p);
+  z(() => {
+    v.current = p;
+  }, [p]);
+  const {
+    data: P,
+    isLoading: Ee,
+    error: k,
+    refetch: te
+  } = ue({
+    queryKey: ["form-schema", e],
+    queryFn: () => f ? Promise.resolve(N || {}) : mt(e),
+    enabled: o && (!f || !!N),
+    retry: 3,
+    staleTime: 30 * 60 * 1e3,
+    // 30 minutes - schemas don't change frequently
+    gcTime: 60 * 60 * 1e3,
+    // 1 hour - keep schemas in cache longer
+    throwOnError: !1
+  }), {
+    data: O,
+    isLoading: re,
+    error: Ne
+  } = ue({
+    queryKey: ["form-record", e, s],
+    queryFn: () => it(e, s),
+    enabled: o && r === "update" && !!s,
+    retry: 3,
+    staleTime: 5 * 60 * 1e3,
+    // 5 minutes - records can change more frequently
+    gcTime: 15 * 60 * 1e3,
+    // 15 minutes - keep records for a reasonable time
+    throwOnError: !1
+  }), Fe = $(() => {
+    const c = { ...a };
+    if (r === "update" && O && Object.assign(c, O), i)
+      for (const [d, l] of Object.entries(i.fields))
+        l.defaultValue !== void 0 && !(d in c) && (c[d] = l.defaultValue);
+    return c;
+  }, [a, O, r, i]), m = $e({
+    mode: n,
+    defaultValues: a,
+    values: r === "update" && O ? Fe : void 0
+  });
+  z(() => {
+    var c;
+    if (P)
+      try {
+        const d = tt(
+          P,
+          {},
+          // Pass empty object - validation functions get live values from react-hook-form
+          u
+        );
+        q(d);
+        const l = st(d);
+        Object.keys(l).length > 0 && ct(l).then(be).catch(console.warn);
+      } catch (d) {
+        console.error("Schema processing failed:", d), (c = v.current) == null || c.call(v, d);
+      }
+  }, [P, u]), z(() => {
+    var c;
+    k && ((c = v.current) == null || c.call(v, k));
+  }, [k]), z(() => {
+    if (!b || r !== "create" || !i || !o || V)
+      return;
+    (async () => {
+      Z(!0), ee(null);
+      try {
+        const l = await I(e).draftInteraction({});
+        X(l._id), l && typeof l == "object" && Object.entries(l).forEach(([h, g]) => {
+          if (h === "_id") return;
+          m.getValues(h) !== g && m.setValue(h, g, {
+            shouldDirty: !1,
+            shouldValidate: !1
+          });
+        });
+      } catch (d) {
+        console.error("Failed to create initial draft:", d), ee(d);
+      } finally {
+        Z(!1);
+      }
+    })();
+  }, [b, r, i, o, V, e, m]);
+  const J = $(() => {
+    if (!i) return [];
+    const c = /* @__PURE__ */ new Set(), d = new Set(i.computedFields);
+    return Object.entries(i.fieldRules).forEach(([l, h]) => {
+      h.computation.forEach((g) => {
+        const w = i.rules.computation[g];
+        w != null && w.ExpressionTree && me(w.ExpressionTree).forEach((y) => {
+          i.fields[y] && y !== l && !d.has(y) && c.add(y);
+        });
+      });
+    }), i.computedFields.forEach((l) => {
+      const h = i.fields[l];
+      h._bdoField.Formula && me(
+        h._bdoField.Formula.ExpressionTree
+      ).forEach((w) => {
+        i.fields[w] && w !== l && !d.has(w) && c.add(w);
+      });
+    }), Array.from(c);
+  }, [i]), se = S(
+    async (c) => {
+      if (!(!i || !(b || J.length > 0 && J.includes(c)))) {
+        if (b && r === "create" && !V) {
+          console.warn("Interactive create mode: waiting for draft ID");
+          return;
+        }
+        B.current || (K.current && clearTimeout(K.current), K.current = setTimeout(() => {
+          if (!i || B.current)
+            return;
+          const l = m.getValues();
+          (async () => {
+            B.current = !0;
+            try {
+              const g = I(e), w = {};
+              r === "update" && s && "_id" in l && (w._id = l._id), b && r === "create" && V && (w._id = V);
+              const R = j.current ?? (r === "update" ? O : null) ?? {}, y = new Set(
+                i.computedFields || []
+              );
+              Object.keys(l).forEach((F) => {
+                if (F === "_id" || y.has(F)) return;
+                const A = l[F], oe = R[F];
+                JSON.stringify(A) !== JSON.stringify(oe) && (A !== "" && A !== null && A !== void 0) && (w[F] = A);
+              });
+              const E = w, D = {
+                ...j.current
+              };
+              Object.keys(l).forEach((F) => {
+                y.has(F) || (D[F] = l[F]);
+              }), j.current = D;
+              let T;
+              r === "update" && s ? T = await g.draftPatch(s, E) : b && V ? T = await g.draftInteraction(E) : T = await g.draft(E), T && typeof T == "object" && (Object.entries(T).forEach(
+                ([F, A]) => {
+                  l[F] !== A && m.setValue(F, A, {
+                    shouldDirty: !1,
+                    shouldValidate: !1
+                  });
+                }
+              ), Object.entries(T).forEach(
+                ([F, A]) => {
+                  y.has(F) && (j.current[F] = A);
+                }
+              ));
+            } catch (g) {
+              console.warn("Failed to compute fields via API:", g);
+            } finally {
+              B.current = !1;
+            }
+          })();
+        }, 300));
+      }
+    },
+    [
+      i,
+      r,
+      s,
+      O,
+      e,
+      m,
+      J,
+      b,
+      V
+    ]
+  ), Re = S(async () => {
+    if (!i)
+      return !1;
+    const c = m.getValues();
+    if (!await m.trigger())
+      return !1;
+    const l = i.crossFieldValidation.map(
+      (g) => ({
+        Id: g.Id,
+        Condition: { ExpressionTree: g.ExpressionTree },
+        Message: g.Message || `Validation failed for ${g.Name}`
+      })
+    ), h = le(
+      l,
+      c,
+      C
+    );
+    return h.length > 0 ? (h.forEach((g, w) => {
+      m.setError(`root.crossField${w}`, {
+        type: "validate",
+        message: g.message
+      });
+    }), !1) : !0;
+  }, [
+    i,
+    m.getValues,
+    m.trigger,
+    m.setError,
+    C
+  ]), Ve = S(
+    (c, d) => m.handleSubmit(
+      // RHF onValid handler - validation passed, now do cross-field + API
+      async (l, h) => {
+        if (!i) {
+          const g = new Error("Schema not loaded");
+          d == null || d(g, h);
+          return;
+        }
+        G(!0);
+        try {
+          const g = i.crossFieldValidation.map(
+            (E) => ({
+              Id: E.Id,
+              Condition: { ExpressionTree: E.ExpressionTree },
+              Message: E.Message || `Validation failed for ${E.Name}`
+            })
+          ), w = le(
+            g,
+            l,
+            C
+          );
+          if (w.length > 0) {
+            w.forEach((E, D) => {
+              m.setError(`root.crossField${D}`, {
+                type: "validate",
+                message: E.message
+              });
+            }), d == null || d(m.formState.errors, h);
+            return;
+          }
+          const R = lt(
+            l,
+            i.computedFields,
+            r,
+            O
+          );
+          let y;
+          if (b) {
+            const E = I(e);
+            if (r === "create") {
+              if (!V)
+                throw new Error(
+                  "Interactive create mode requires a draft ID. Draft creation may have failed."
+                );
+              y = { success: !0, data: await E.draft({
+                ...R,
+                _id: V
+              }) };
+            } else
+              y = { success: !0, data: await E.draftUpdate(s, R) };
+          } else if (y = await ot(
+            e,
+            r,
+            R,
+            s
+          ), !y.success)
+            throw y.error || new Error("Submission failed");
+          r === "create" && (m.reset(), b && X(null)), await (c == null ? void 0 : c(y.data || l, h));
+        } catch (g) {
+          d == null || d(g, h);
+        } finally {
+          G(!1);
+        }
+      },
+      // RHF onInvalid handler - validation failed
+      (l, h) => {
+        d == null || d(l, h);
+      }
+    ),
+    [
+      m,
+      i,
+      C,
+      e,
+      r,
+      s,
+      O,
+      b,
+      V
+    ]
+  ), Se = S(
+    (c) => (i == null ? void 0 : i.fields[c]) || null,
+    [i]
+  ), Ae = S(() => {
+    if (!i) return {};
+    const c = {};
+    return Object.entries(i.fields).forEach(([d, l]) => {
+      c[d] = l;
+    }), c;
+  }, [i]), Ce = S(
+    (c) => !!(i != null && i.fields[c]),
+    [i]
+  ), De = S(
+    (c) => (i == null ? void 0 : i.requiredFields.includes(c)) || !1,
+    [i]
+  ), Oe = S(
+    (c) => (i == null ? void 0 : i.computedFields.includes(c)) || !1,
+    [i]
+  ), xe = S(async () => {
+    await te();
+  }, [te]), ve = S(() => {
+    m.clearErrors();
+  }, [m]), ae = Ee || r === "update" && re || b && r === "create" && Q, Te = ae || H, ne = k || Ne || ye, Me = !!ne, Ie = $(
+    () => (i == null ? void 0 : i.computedFields) || [],
+    [i]
+  ), Le = $(
+    () => (i == null ? void 0 : i.requiredFields) || [],
+    [i]
+  ), ie = $(() => {
+    if (!i) return {};
+    const c = {};
+    return Object.entries(i.fields).forEach(([d, l]) => {
+      const h = {};
+      switch (l.required && (h.required = `${l.label} is required`), l.permission.editable || (h.disabled = !0), l.type) {
+        case "number":
+          h.valueAsNumber = !0;
+          break;
+        case "date":
+        case "datetime-local":
+          h.valueAsDate = !0;
+          break;
+      }
+      const g = l.rules.validation;
+      g.length > 0 && (h.validate = {
+        expressionValidation: (w) => {
+          const R = m.getValues();
+          for (const y of g) {
+            const E = i.rules.validation[y];
+            if (E) {
+              const D = gt(
+                d,
+                w,
+                [E],
+                R,
+                we
+              );
+              if (!D.isValid)
+                return D.message || E.Message || "Invalid value";
+            }
+          }
+          return !0;
+        }
+      }), c[d] = h;
+    }), c;
+  }, [i, m, C]);
+  return {
+    // Form methods with strict typing
+    register: S(
+      (c, d) => {
+        const l = ie[c], h = d == null ? void 0 : d.onBlur, g = async (w) => {
+          h && await h(w);
+          let R = !0;
+          n === "onBlur" || n === "onTouched" || n === "all" ? R = await m.trigger(c) : R = !m.getFieldState(c, m.formState).error, R && await se(c);
+        };
+        return m.register(c, {
+          ...l,
+          ...d,
+          onBlur: g
+        });
+      },
+      [m, ie, se, n]
+    ),
+    handleSubmit: Ve,
+    watch: m.watch,
+    // Type assertion for complex generic constraints
+    setValue: m.setValue,
+    reset: m.reset,
+    // Flattened form state (NEW - direct access, no nested formState)
+    errors: m.formState.errors,
+    isValid: m.formState.isValid,
+    isDirty: m.formState.isDirty,
+    isSubmitting: m.formState.isSubmitting || H,
+    isSubmitSuccessful: m.formState.isSubmitSuccessful,
+    // Loading states
+    isLoadingInitialData: ae,
+    isLoadingRecord: re,
+    isLoading: Te,
+    // Interactive mode state
+    draftId: V,
+    isCreatingDraft: Q,
+    // Error handling
+    loadError: ne,
+    hasError: Me,
+    // Schema information
+    schema: P,
+    schemaConfig: i,
+    computedFields: Ie,
+    requiredFields: Le,
+    // Field helpers
+    getField: Se,
+    getFields: Ae,
+    hasField: Ce,
+    isFieldRequired: De,
+    isFieldComputed: Oe,
+    // Operations
+    refreshSchema: xe,
+    validateForm: Re,
+    clearErrors: ve
+  };
+}
+export {
+  Ot as clearFormCache,
+  Ct as isNetworkError,
+  Dt as isValidationError,
+  At as parseApiError,
+  xt as useForm
+};