@burgantech/pseudo-ui 0.1.0

package/dist/adapters/vue/ErrorBoundary.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    label?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/adapters/vue/ErrorBoundary.vue.js

@@ -0,0 +1,7 @@
+import o from "./ErrorBoundary.vue2.js";
+/* empty css                   */
+import r from "../../_virtual/_plugin-vue_export-helper.js";
+const f = /* @__PURE__ */ r(o, [["__scopeId", "data-v-d8e1bfd2"]]);
+export {
+  f as default
+};

package/dist/adapters/vue/ErrorBoundary.vue2.js

@@ -0,0 +1,27 @@
+import { defineComponent as a, ref as s, onErrorCaptured as i, openBlock as u, createElementBlock as d, createElementVNode as o, toDisplayString as t, createTextVNode as p, renderSlot as c } from "vue";
+const m = {
+  key: 0,
+  class: "d-error-boundary",
+  role: "alert"
+}, g = /* @__PURE__ */ a({
+  __name: "ErrorBoundary",
+  props: {
+    label: {}
+  },
+  setup(l) {
+    const r = s(null);
+    return i((e) => (r.value = e instanceof Error ? e.message : String(e), !1)), (e, n) => r.value ? (u(), d("div", m, [
+      n[0] || (n[0] = o("i", {
+        class: "pi pi-exclamation-triangle",
+        style: { "margin-right": "0.5rem", color: "var(--p-red-500)" }
+      }, null, -1)),
+      o("span", null, [
+        o("strong", null, t(l.label || "Component") + " render error:", 1),
+        p(" " + t(r.value), 1)
+      ])
+    ])) : c(e.$slots, "default", { key: 1 }, void 0, !0);
+  }
+});
+export {
+  g as default
+};

package/dist/adapters/vue/NestedComponentWrapper.vue.d.ts

@@ -0,0 +1,15 @@
+import type { DataSchema, ViewDefinition } from '../../engine/types';
+type __VLS_Props = {
+    schema: DataSchema;
+    view: ViewDefinition;
+    lang: string;
+    boundValues?: Record<string, unknown>;
+    boundInstanceValues?: Record<string, unknown>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    update: (data: Record<string, unknown>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onUpdate?: ((data: Record<string, unknown>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/adapters/vue/NestedComponentWrapper.vue.js

@@ -0,0 +1,96 @@
+import { defineComponent as k, watch as p, onMounted as w, nextTick as y, openBlock as O, createBlock as j } from "vue";
+import { createFormContext as C, provideFormContext as x } from "./useFormContext.js";
+import { resolveFilterParams as V } from "../../engine/expressionResolver.js";
+import { useLookups as F } from "./useLookups.js";
+import { fetchLovData as f } from "../../engine/dataClient.js";
+import { useDelegate as L } from "./injection.js";
+import $ from "./DynamicRenderer.vue.js";
+const B = /* @__PURE__ */ k({
+  __name: "NestedComponentWrapper",
+  props: {
+    schema: {},
+    view: {},
+    lang: {},
+    boundValues: {},
+    boundInstanceValues: {}
+  },
+  emits: ["update"],
+  setup(d, { emit: v }) {
+    const t = d, b = v, u = L(), r = u.onLog ?? (() => {
+    });
+    r("debug", "NestedComponent initializing", void 0, { source: "NestedComponent", boundKeys: [...Object.keys(t.boundValues ?? {}), ...Object.keys(t.boundInstanceValues ?? {})] });
+    const o = C(t.schema, t.lang);
+    x(o), t.view.uiState && (Object.assign(o.uiState, t.view.uiState), r("info", "Nested component UI state initialized", void 0, { keys: Object.keys(t.view.uiState) }));
+    const l = {
+      ...t.boundValues,
+      ...t.boundInstanceValues
+    };
+    Object.assign(o.params, l), Object.assign(o.formData, l), Object.assign(o.instanceData, l), g();
+    function g() {
+      if (!t.schema.properties) return;
+      const e = Object.keys(l);
+      for (const [s, a] of Object.entries(t.schema.properties))
+        a["x-binding"] === "required" && !e.includes(s) && r("warn", `Missing required input "${s}". Parent must bind this property.`, void 0, { source: "Component", field: s });
+    }
+    p(() => t.lang, (e) => {
+      o.lang = e;
+    }), p(() => o.formData, (e) => {
+      b("update", { ...e });
+    }, { deep: !0 }), p([() => t.boundValues, () => t.boundInstanceValues], ([e, s]) => {
+      const a = { ...e, ...s }, i = [];
+      for (const [c, n] of Object.entries(a))
+        o.params[c] !== n && (i.push(c), o.params[c] = n, o.formData[c] = n, o.instanceData[c] = n);
+      i.length > 0 && h(i);
+    }, { deep: !0 });
+    async function m(e, s) {
+      const a = t.schema.properties?.[e];
+      if (!a?.["x-lov"]) return;
+      const i = a["x-lov"], c = i.filter;
+      try {
+        if (c?.length) {
+          const n = V(c, o.formData, o.instanceData, o.params);
+          if (n === null) {
+            o.lovData[e] = [];
+            return;
+          }
+          const D = await f(u.requestData, i, n, r);
+          o.lovData[e] = D;
+        } else {
+          const n = await f(u.requestData, i, void 0, r);
+          o.lovData[e] = n;
+        }
+      } catch (n) {
+        r("error", `Failed to load LOV for field "${e}"`, n, { source: "NestedComponent", field: e }), o.lovData[e] = [];
+      }
+    }
+    function h(e) {
+      if (t.schema.properties)
+        for (const [s, a] of Object.entries(t.schema.properties)) {
+          const i = a["x-lov"];
+          if (!i?.filter) continue;
+          i.filter.some(
+            (n) => n.value.startsWith("$param.") && e.includes(n.value.slice(7)) || n.value.startsWith("$form.") && e.includes(n.value.slice(6)) || n.value.startsWith("$instance.") && e.includes(n.value.slice(10))
+          ) && (o.formData[s] = void 0, m(s));
+        }
+    }
+    return w(async () => {
+      if (t.schema.properties) {
+        for (const [e, s] of Object.entries(t.schema.properties))
+          if (s["x-lov"])
+            try {
+              await m(e);
+            } catch (a) {
+              r("warn", `Failed to load LOV for ${e}`, a, { source: "NestedComponent", field: e });
+            }
+        y(() => {
+          t.view.lookups?.length && (r("debug", `NestedComponent initializing ${t.view.lookups.length} lookup(s)`, void 0, { source: "NestedComponent", lookups: t.view.lookups }), F(t.view.lookups, o, u.requestData, r));
+        });
+      }
+    }), (e, s) => (O(), j($, {
+      node: d.view.view
+    }, null, 8, ["node"]));
+  }
+});
+export {
+  B as default
+};

package/dist/adapters/vue/NestedComponentWrapper.vue2.js

@@ -0,0 +1,4 @@
+import f from "./NestedComponentWrapper.vue.js";
+export {
+  f as default
+};

package/dist/adapters/vue/PseudoView.vue.d.ts

@@ -0,0 +1,18 @@
+import type { DataSchema, ViewDefinition, PseudoViewDelegate } from '../../engine/types';
+type __VLS_Props = {
+    schema: DataSchema;
+    view: ViewDefinition;
+    formData?: Record<string, unknown>;
+    instanceData?: Record<string, unknown>;
+    lang?: string;
+    delegate: PseudoViewDelegate;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    formChange: (data: Record<string, unknown>) => any;
+    validationChange: (errors: Record<string, string>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFormChange?: ((data: Record<string, unknown>) => any) | undefined;
+    onValidationChange?: ((errors: Record<string, string>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/adapters/vue/PseudoView.vue.js

@@ -0,0 +1,59 @@
+import { defineComponent as p, watch as n, onMounted as h, nextTick as v, openBlock as k, createBlock as D } from "vue";
+import { createFormContext as y, provideFormContext as b } from "./useFormContext.js";
+import { provideDelegate as j } from "./injection.js";
+import { useLookups as O } from "./useLookups.js";
+import x from "./DynamicRenderer.vue.js";
+const S = /* @__PURE__ */ p({
+  __name: "PseudoView",
+  props: {
+    schema: {},
+    view: {},
+    formData: {},
+    instanceData: {},
+    lang: {},
+    delegate: {}
+  },
+  emits: ["formChange", "validationChange"],
+  setup(r, { emit: u }) {
+    const e = r, f = u, i = e.delegate.onLog ?? (() => {
+    });
+    j(e.delegate), i("info", "PseudoView initializing", void 0, { schema: e.schema.$id, lang: e.lang });
+    const a = y(e.schema, e.lang ?? "tr");
+    b(a), e.view.uiState && (Object.assign(a.uiState, e.view.uiState), i("info", "UI state initialized from view definition", void 0, { keys: Object.keys(e.view.uiState) })), e.formData && (Object.assign(a.formData, e.formData), i("info", "Initial form data applied", void 0, { keys: Object.keys(e.formData) })), e.instanceData && (Object.assign(a.instanceData, e.instanceData), i("info", "Instance data applied", void 0, { keys: Object.keys(e.instanceData) }), m("instanceData", e.instanceData));
+    function m(t, o) {
+      if (!e.schema.properties) return;
+      const l = Object.keys(e.schema.properties), g = Object.keys(o), s = l.filter((d) => !g.includes(d)), c = g.filter((d) => !l.includes(d));
+      s.length > 0 && i("info", `${t}: ${s.length} schema field(s) not present in data`, void 0, {
+        source: "Diagnostics",
+        missing: s
+      }), c.length > 0 && i("info", `${t}: ${c.length} field(s) in data not defined in schema`, void 0, {
+        source: "Diagnostics",
+        extra: c
+      });
+    }
+    return n(() => e.lang, (t) => {
+      t && (a.lang = t, i("info", `Language changed to "${t}"`));
+    }), n(() => e.schema, (t) => {
+      a.schema = t, i("info", "Schema updated", void 0, { schema: t.$id });
+    }), n(() => e.formData, (t) => {
+      t && (Object.assign(a.formData, t), i("info", "Form data updated", void 0, { keys: Object.keys(t) }));
+    }, { deep: !0 }), n(() => e.instanceData, (t) => {
+      for (const o of Object.keys(a.instanceData))
+        delete a.instanceData[o];
+      t && (Object.assign(a.instanceData, t), m("instanceData", t)), i("info", "Instance data updated", void 0, { keys: t ? Object.keys(t) : [] });
+    }, { deep: !0 }), n(() => a.formData, (t) => {
+      f("formChange", { ...t });
+    }, { deep: !0 }), n(() => a.errors, (t) => {
+      f("validationChange", { ...t });
+    }, { deep: !0 }), h(() => {
+      i("info", "PseudoView mounted"), v(() => {
+        e.view.lookups?.length && (i("debug", `Initializing ${e.view.lookups.length} lookup(s)`, void 0, { lookups: e.view.lookups }), O(e.view.lookups, a, e.delegate.requestData, i));
+      });
+    }), (t, o) => (k(), D(x, {
+      node: r.view.view
+    }, null, 8, ["node"]));
+  }
+});
+export {
+  S as default
+};

package/dist/adapters/vue/PseudoView.vue2.js

@@ -0,0 +1,4 @@
+import f from "./PseudoView.vue.js";
+export {
+  f as default
+};

package/dist/adapters/vue/index.d.ts

@@ -0,0 +1,6 @@
+export { default as PseudoView } from './PseudoView.vue';
+export { default as DynamicRenderer } from './DynamicRenderer.vue';
+export { default as NestedComponentWrapper } from './NestedComponentWrapper.vue';
+export { createFormContext, provideFormContext, useFormContext } from './useFormContext';
+export { useLookups } from './useLookups';
+export { provideDelegate, useDelegate } from './injection';

package/dist/adapters/vue/index.js

@@ -0,0 +1,17 @@
+import { default as r } from "./PseudoView.vue.js";
+import { default as p } from "./DynamicRenderer.vue.js";
+import { default as m } from "./NestedComponentWrapper.vue.js";
+import { createFormContext as s, provideFormContext as x, useFormContext as d } from "./useFormContext.js";
+import { useLookups as n } from "./useLookups.js";
+import { provideDelegate as i, useDelegate as C } from "./injection.js";
+export {
+  p as DynamicRenderer,
+  m as NestedComponentWrapper,
+  r as PseudoView,
+  s as createFormContext,
+  i as provideDelegate,
+  x as provideFormContext,
+  C as useDelegate,
+  d as useFormContext,
+  n as useLookups
+};

package/dist/adapters/vue/injection.d.ts

@@ -0,0 +1,3 @@
+import type { PseudoViewDelegate } from '../../engine/types';
+export declare function provideDelegate(delegate: PseudoViewDelegate): void;
+export declare function useDelegate(): PseudoViewDelegate;

package/dist/adapters/vue/injection.js

@@ -0,0 +1,14 @@
+import { inject as t, provide as r } from "vue";
+const o = /* @__PURE__ */ Symbol("PseudoViewDelegate");
+function n(e) {
+  r(o, e);
+}
+function d() {
+  const e = t(o);
+  if (!e) throw new Error("PseudoViewDelegate not provided. Wrap your component tree with <PseudoView>.");
+  return e;
+}
+export {
+  n as provideDelegate,
+  d as useDelegate
+};

package/dist/adapters/vue/useFormContext.d.ts

@@ -0,0 +1,4 @@
+import type { DataSchema, FormContext } from '../../engine/types';
+export declare function createFormContext(schema: DataSchema, lang?: string): FormContext;
+export declare function provideFormContext(ctx: FormContext): void;
+export declare function useFormContext(): FormContext;

package/dist/adapters/vue/useFormContext.js

@@ -0,0 +1,35 @@
+import { inject as i, reactive as a, provide as c } from "vue";
+const n = /* @__PURE__ */ Symbol("FormContext");
+function f(t, o = "tr") {
+  return a({
+    schema: t,
+    formData: p(t),
+    instanceData: {},
+    params: {},
+    uiState: {},
+    lovData: {},
+    lookupData: {},
+    lang: o,
+    errors: {}
+  });
+}
+function d(t) {
+  c(n, t);
+}
+function m() {
+  const t = i(n);
+  if (!t) throw new Error("FormContext not provided. Wrap your component tree with a FormContext provider.");
+  return t;
+}
+function p(t) {
+  const o = {};
+  if (!t.properties) return o;
+  for (const [r, e] of Object.entries(t.properties))
+    e.default !== void 0 && (o[r] = e.default);
+  return o;
+}
+export {
+  f as createFormContext,
+  d as provideFormContext,
+  m as useFormContext
+};

package/dist/adapters/vue/useLookups.d.ts

@@ -0,0 +1,4 @@
+import type { FormContext, RequestDataFn, PseudoViewDelegate } from '../../engine/types';
+type LogFn = NonNullable<PseudoViewDelegate['onLog']>;
+export declare function useLookups(lookupNames: string[], ctx: FormContext, requestData: RequestDataFn, log?: LogFn): void;
+export {};

package/dist/adapters/vue/useLookups.js

@@ -0,0 +1,38 @@
+import { watch as m } from "vue";
+import { extractDynamicFilterFields as d, areRequiredFiltersMet as k, resolveFilterParams as c } from "../../engine/expressionResolver.js";
+import { fetchLookupData as h } from "../../engine/dataClient.js";
+function g(n, e, f, t = () => {
+}) {
+  if (!(!n.length || !e.schema.properties))
+    for (const o of n) {
+      const u = e.schema.properties[o];
+      if (!u?.["x-lookup"]) continue;
+      const i = u["x-lookup"];
+      async function p() {
+        const a = i.filter?.length ? c(i.filter, e.formData, e.instanceData, e.params) : {};
+        if (a === null) {
+          t("debug", `Lookup "${o}" skipped — required filter params not met`, void 0, { source: "Lookup", field: o }), delete e.lookupData[o];
+          return;
+        }
+        t("debug", `Fetching lookup "${o}"`, void 0, { source: "Lookup", field: o, params: a });
+        const r = await h(f, i, a, t);
+        r ? (e.lookupData[o] = r, t("info", `Lookup "${o}" loaded`, void 0, { source: "Lookup", field: o, keys: Object.keys(r) })) : delete e.lookupData[o];
+      }
+      if (i.filter?.length) {
+        const { formFields: a, instanceFields: r, paramFields: l } = d(i.filter);
+        a.length > 0 || r.length > 0 || l.length > 0 ? (t("debug", `Lookup "${o}" watching fields`, void 0, { source: "Lookup", field: o, formFields: a, instanceFields: r, paramFields: l }), m(
+          () => [
+            ...a.map((s) => e.formData[s]),
+            ...r.map((s) => e.instanceData[s]),
+            ...l.map((s) => e.params[s])
+          ],
+          () => p(),
+          { immediate: k(i.filter, e.formData, e.instanceData, e.params) }
+        )) : p();
+      } else
+        p();
+    }
+}
+export {
+  g as useLookups
+};

package/dist/engine/conditionalEngine.d.ts

@@ -0,0 +1,6 @@
+import type { ConditionalDefinition } from './types';
+export interface ConditionalState {
+    visible: boolean;
+    enabled: boolean;
+}
+export declare function evaluateConditional(conditional: ConditionalDefinition | undefined, formData: Record<string, unknown>, instanceData?: Record<string, unknown>, params?: Record<string, unknown>): ConditionalState;

package/dist/engine/conditionalEngine.js

@@ -0,0 +1,56 @@
+function l(e, t, r = {}, a = {}) {
+  if (!e) return { visible: !0, enabled: !0 };
+  const s = { ...a, ...r, ...t };
+  let u = !0, i = !0;
+  return e.showIf && (u = n(e.showIf, s)), e.hideIf && (u = !n(e.hideIf, s)), e.enableIf && (i = n(e.enableIf, s)), e.disableIf && (i = !n(e.disableIf, s)), { visible: u, enabled: i };
+}
+function n(e, t) {
+  if (e.allOf)
+    return e.allOf.every((s) => n(s, t));
+  if (e.anyOf)
+    return e.anyOf.some((s) => n(s, t));
+  if (e.not)
+    return !n(e.not, t);
+  if (!e.field) return !0;
+  const r = f(t, e.field);
+  switch (e.operator || "equals") {
+    case "equals":
+      return r === e.value;
+    case "notEquals":
+      return r !== e.value;
+    case "in":
+      return Array.isArray(e.value) && e.value.includes(r);
+    case "notIn":
+      return Array.isArray(e.value) && !e.value.includes(r);
+    case "greaterThan":
+      return Number(r) > Number(e.value);
+    case "lessThan":
+      return Number(r) < Number(e.value);
+    case "greaterThanOrEquals":
+      return Number(r) >= Number(e.value);
+    case "lessThanOrEquals":
+      return Number(r) <= Number(e.value);
+    case "contains":
+      return typeof r == "string" && r.includes(String(e.value));
+    case "startsWith":
+      return typeof r == "string" && r.startsWith(String(e.value));
+    case "endsWith":
+      return typeof r == "string" && r.endsWith(String(e.value));
+    case "isEmpty":
+      return r == null || r === "";
+    case "isNotEmpty":
+      return r != null && r !== "";
+    default:
+      return !0;
+  }
+}
+function f(e, t) {
+  if (t)
+    return t.split(".").reduce((r, a) => {
+      if (!(r == null || typeof r != "object"))
+        return r[a];
+    }, e);
+}
+export {
+  l as evaluateConditional
+};

package/dist/engine/dataClient.d.ts

@@ -0,0 +1,5 @@
+import type { LovDefinition, LovItem, LookupDefinition, RequestDataFn, PseudoViewDelegate } from './types';
+type LogFn = NonNullable<PseudoViewDelegate['onLog']>;
+export declare function fetchLovData(requestData: RequestDataFn, lov: LovDefinition, queryParams?: Record<string, string>, log?: LogFn): Promise<LovItem[]>;
+export declare function fetchLookupData(requestData: RequestDataFn, lookup: LookupDefinition, queryParams?: Record<string, string>, log?: LogFn): Promise<Record<string, unknown> | null>;
+export {};

package/dist/engine/dataClient.js

@@ -0,0 +1,39 @@
+import { navigatePath as y } from "./expressionResolver.js";
+function o() {
+}
+function d(s, e) {
+  return y(s, e.replace(/^\$\./, "").split("."));
+}
+async function p(s, e, u, r = o) {
+  try {
+    r("debug", `requestData → ${e.source}`, void 0, { source: "LOV", ref: e.source, params: u });
+    const c = await s(e.source, u);
+    r("debug", `requestData ← ${e.source} responded`, void 0, { source: "LOV", ref: e.source });
+    const t = d(c, e.valueField.replace(/\.[^.]+$/, ""));
+    if (!Array.isArray(t))
+      return r("warn", `Expected array at data path for ${e.source}, got ${typeof t}`, void 0, { source: "LOV", ref: e.source }), [];
+    const i = e.valueField.split(".").pop(), f = e.displayField.split(".").pop(), a = t.map((n) => ({
+      ...n,
+      value: String(n[i] ?? ""),
+      display: String(n[f] ?? "")
+    }));
+    return r("debug", `LOV "${e.source}" extracted ${a.length} item(s)`, void 0, { source: "LOV", ref: e.source, count: a.length }), a;
+  } catch (c) {
+    return r("error", `Failed to fetch LOV: ${e.source}`, c, { source: "LOV", ref: e.source }), [];
+  }
+}
+async function $(s, e, u, r = o) {
+  try {
+    r("debug", `requestData → ${e.source}`, void 0, { source: "LOOKUP", ref: e.source, params: u });
+    const c = await s(e.source, u);
+    r("debug", `requestData ← ${e.source} responded`, void 0, { source: "LOOKUP", ref: e.source });
+    const t = d(c, e.resultField);
+    return t == null || typeof t != "object" ? (r("warn", `Expected object at ${e.resultField} for ${e.source}, got ${typeof t}`, void 0, { source: "LOOKUP", ref: e.source }), null) : (r("debug", `Lookup "${e.source}" extracted`, void 0, { source: "LOOKUP", ref: e.source, keys: Object.keys(t) }), t);
+  } catch (c) {
+    return r("error", `Failed to fetch lookup: ${e.source}`, c, { source: "LOOKUP", ref: e.source }), null;
+  }
+}
+export {
+  $ as fetchLookupData,
+  p as fetchLovData
+};

package/dist/engine/expressionResolver.d.ts

@@ -0,0 +1,13 @@
+import type { FormContext, MultiLangText, LovFilterParam } from './types';
+export declare function resolveExpression(expr: string, ctx: FormContext, item?: Record<string, unknown>): unknown;
+export declare function resolveTextContent(content: string | MultiLangText | undefined, ctx: FormContext, item?: Record<string, unknown>): string;
+export declare function resolveMultiLang(text: MultiLangText | undefined, lang: string): string;
+export declare function resolveFilterParams(filter: LovFilterParam[], formData: Record<string, unknown>, instanceData?: Record<string, unknown>, params?: Record<string, unknown>): Record<string, string> | null;
+export interface DynamicFilterFields {
+    formFields: string[];
+    instanceFields: string[];
+    paramFields: string[];
+}
+export declare function extractDynamicFilterFields(filter: LovFilterParam[]): DynamicFilterFields;
+export declare function areRequiredFiltersMet(filter: LovFilterParam[], formData: Record<string, unknown>, instanceData: Record<string, unknown>, params?: Record<string, unknown>): boolean;
+export declare function navigatePath(obj: unknown, path: string[]): unknown;

package/dist/engine/expressionResolver.js

@@ -0,0 +1,136 @@
+function p(l, e, r) {
+  if (!l || !l.startsWith("$")) return l;
+  const i = l.split("."), t = i[0], a = i.slice(1);
+  let s;
+  switch (t) {
+    case "$schema": {
+      const u = a[0], o = u ? e.schema.properties?.[u] : void 0;
+      o && a[1] === "label" ? s = o["x-labels"] : o ? s = n(o, a.slice(1)) : s = n(e.schema, a);
+      break;
+    }
+    case "$form":
+      s = n(e.formData, a);
+      break;
+    case "$instance":
+      s = n(e.instanceData, a);
+      break;
+    case "$param":
+      s = n(e.params, a);
+      break;
+    case "$lov": {
+      if (a.length === 0) {
+        s = e.lovData;
+        break;
+      }
+      const u = a[0], o = e.lovData[u];
+      if (a.length >= 2 && a[1] === "display") {
+        const f = e.params[u] ?? e.formData[u] ?? e.instanceData[u];
+        o && f != null ? s = o.find((v) => v.value === f)?.display ?? String(f) : s = f;
+      } else
+        s = o;
+      break;
+    }
+    case "$lookup":
+      if (a.length > 0) {
+        const u = e.lookupData[a[0]];
+        s = a.length > 1 ? n(u, a.slice(1)) : u;
+      } else
+        s = e.lookupData;
+      break;
+    case "$ui":
+      s = n(e.uiState, a);
+      break;
+    case "$item":
+      s = r ? n(r, a) : void 0;
+      break;
+    case "$context":
+      a[0] === "lang" && (s = e.lang);
+      break;
+    default:
+      s = l;
+  }
+  return s;
+}
+function $(l, e, r) {
+  if (!l) return "";
+  if (typeof l == "string") {
+    if (l.startsWith("$")) {
+      const i = p(l, e, r);
+      if (typeof i == "object" && i !== null)
+        return c(i, e.lang);
+      const t = String(i ?? "");
+      return m(l, t, e) ?? t;
+    }
+    return l;
+  }
+  return c(l, e.lang);
+}
+function m(l, e, r) {
+  if (!e || !r.schema.properties) return null;
+  const i = l.split(".");
+  if (i.length < 2) return null;
+  const t = i[1], a = r.schema.properties[t];
+  return a?.["x-enum"]?.[e] ? c(a["x-enum"][e], r.lang) : null;
+}
+function c(l, e) {
+  return l && (l[e] || l.en || l.tr || Object.values(l)[0]) || "";
+}
+function b(l, e, r = {}, i = {}) {
+  const t = {};
+  for (const a of l) {
+    let s;
+    if (a.value.startsWith("$param."))
+      s = n(i, a.value.slice(7).split("."));
+    else if (a.value.startsWith("$form."))
+      s = n(e, a.value.slice(6).split("."));
+    else if (a.value.startsWith("$instance."))
+      s = n(r, a.value.slice(10).split("."));
+    else {
+      t[a.param] = a.value;
+      continue;
+    }
+    if (s != null && s !== "")
+      t[a.param] = String(s);
+    else if (a.required)
+      return null;
+  }
+  return t;
+}
+function d(l) {
+  return {
+    formFields: l.filter((e) => e.value.startsWith("$form.")).map((e) => e.value.slice(6)),
+    instanceFields: l.filter((e) => e.value.startsWith("$instance.")).map((e) => e.value.slice(10)),
+    paramFields: l.filter((e) => e.value.startsWith("$param.")).map((e) => e.value.slice(7))
+  };
+}
+function g(l, e, r, i = {}) {
+  return l.filter((t) => t.required).every((t) => {
+    let a;
+    if (t.value.startsWith("$param."))
+      a = i[t.value.slice(7)];
+    else if (t.value.startsWith("$form."))
+      a = e[t.value.slice(6)];
+    else if (t.value.startsWith("$instance."))
+      a = r[t.value.slice(10)];
+    else
+      return !0;
+    return a != null && a !== "";
+  });
+}
+function n(l, e) {
+  let r = l;
+  for (const i of e) {
+    if (r == null || typeof r != "object") return;
+    r = r[i];
+  }
+  return r;
+}
+export {
+  g as areRequiredFiltersMet,
+  d as extractDynamicFilterFields,
+  n as navigatePath,
+  p as resolveExpression,
+  b as resolveFilterParams,
+  c as resolveMultiLang,
+  $ as resolveTextContent
+};

package/dist/engine/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export { resolveExpression, resolveTextContent, resolveMultiLang, resolveFilterParams, extractDynamicFilterFields, areRequiredFiltersMet, navigatePath } from './expressionResolver';
+export type { DynamicFilterFields } from './expressionResolver';
+export { evaluateConditional } from './conditionalEngine';
+export type { ConditionalState } from './conditionalEngine';
+export { getSchemaProperty, getFieldLabel, getFieldErrorMessage, isFieldRequired, getEnumOptions, mapLovItemsToOptions, validateField } from './schemaResolver';
+export { fetchLovData, fetchLookupData } from './dataClient';