@wavemaker-ai/react-runtime 1.0.0-rc.647712 → 12.0.0-rc.647733

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavemaker-ai/react-runtime",
-  "version": "1.0.0-rc.647712",
+  "version": "12.0.0-rc.647733",
   "description": "React runtime package for Wavemaker",
   "license": "MIT",
   "repository": {
@@ -58,8 +58,8 @@
     "@mui/x-date-pickers": "8.5.3",
     "@reduxjs/toolkit": "2.9.1",
     "@tanstack/react-table": "8.21.3",
-    "@wavemaker-ai/react-codegen": "1.0.0-rc.647712",
-    "@wavemaker-ai/variables": "1.0.0-rc.647712",
+    "@wavemaker-ai/react-codegen": "12.0.0-rc.647733",
+    "@wavemaker-ai/variables": "12.0.0-rc.647733",
     "@wavemaker/nvd3": "1.8.16",
     "axios": "1.15.1",
     "d3": "7.8.5",

package/runtime-dynamic/App.js

@@ -1,3 +1,22 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { Fragment, jsx } from "react/jsx-runtime";
 import { Provider } from "react-redux";
 import { RouterProvider } from "react-router-dom";
@@ -93,7 +112,7 @@ function initPreviewRuntimeRouter(router) {
       pathname: pathname || "/",
       search: search ? `?${search}` : ""
     };
-    router.navigate(navigationPayload, options);
+    router.navigate(navigationPayload, __spreadProps(__spreadValues({}, options), { flushSync: true }));
   }
   setRouter({
     push: (path) => navigateWithSearchParams(path),
@@ -108,7 +127,7 @@ function App() {
       "initPreviewRuntimeRouter() must be called after initializeApp() and before render."
     );
   }
-  return /* @__PURE__ */ jsx(Provider, { store, children: /* @__PURE__ */ jsx(LocalizationProvider, { children: /* @__PURE__ */ jsx(WmThemeProvider, { children: /* @__PURE__ */ jsx(ToastProvider, { children: /* @__PURE__ */ jsx(WmApp, { children: /* @__PURE__ */ jsx(RouterProvider, { router: previewRouter }) }) }) }) }) });
+  return /* @__PURE__ */ jsx(Provider, { store, children: /* @__PURE__ */ jsx(LocalizationProvider, { children: /* @__PURE__ */ jsx(WmThemeProvider, { children: /* @__PURE__ */ jsx(WmApp, { children: /* @__PURE__ */ jsx(ToastProvider, { children: /* @__PURE__ */ jsx(RouterProvider, { router: previewRouter }) }) }) }) }) });
 }
 export {
   App,

package/runtime-dynamic/app-initializer.js

@@ -228,11 +228,18 @@ async function initializeApp() {
   }
 }
 function getIconCssPathsFromFontConfig() {
+  var _a;
   const source = projectConfig.fontConfig;
   if (!source) {
     return [];
   }
-  return [...source.matchAll(/"csspath":\s*"([^"]+)"/g)].map((match) => match[1]);
+  try {
+    const normalized = source.replace(/^\s*export\s+default\s+/m, "").replace(/;?\s*$/, "");
+    const fontConfig = new Function(`return (${normalized});`)();
+    return ((_a = fontConfig == null ? void 0 : fontConfig.fonts) != null ? _a : []).filter((font) => !!font.csspath).map((font) => font.csspath);
+  } catch (e) {
+    return [];
+  }
 }
 function resolvePreviewIconStylesheetUrl(csspath) {
   if (/^https?:\/\//i.test(csspath) || csspath.startsWith("//")) {

package/runtime-dynamic/factories/dynamic-component.js

@@ -18,7 +18,7 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { jsx } from "react/jsx-runtime";
-import React, { useEffect, useReducer, useRef } from "react";
+import React, { useEffect, useId, useReducer, useRef } from "react";
 import WmPrefab from "../../components/prefab";
 import { useAppState } from "../../context/WidgetProvider";
 import { useAppContext } from "../../context/AppContext";
@@ -76,12 +76,13 @@ function createDynamicComponent({
   const InnerComponent = (props) => {
     const appState = useAppState();
     usePageEvents(appState, componentType);
+    const uniqueId = useId();
     const appContext = useAppContext();
     useCrossScopeDataRefresh(appContext, componentType);
     const notification = appContext == null ? void 0 : appContext.notification;
     useEffect(() => {
       if (styles) {
-        scopeComponentStyles(componentName, componentType, styles);
+        scopeComponentStyles(componentName, componentType, styles, uniqueId);
       }
       let id = null;
       if (appState) {
@@ -89,7 +90,7 @@ function createDynamicComponent({
       }
       return () => {
         if (id) clearTimeout(id);
-        removeComponentStyles(componentName, componentType);
+        removeComponentStyles(`${componentType}-${componentName}-${uniqueId}`, componentType);
       };
     }, []);
     if (!transpiled) return null;

package/runtime-dynamic/main.d.ts

@@ -1,2 +1,3 @@
+export { __wmxShared } from "./wmx-shared";
 declare const noop: () => void;
 export default noop;

package/runtime-dynamic/main.js

@@ -4,11 +4,18 @@ import wmGlobalsCss from "@wavemaker-ai/react-codegen/styles/wm-styles.css";
 import { App, initPreviewRuntimeRouter } from "./App";
 import { initializeApp } from "./app-initializer";
 import { registerCustomWidget, getCustomWidget, hasCustomWidget } from "./registry";
+import { registerWmxComponents } from "../utils/wmx.utils";
 import { createAppRouter } from "./routes";
+import { __wmxShared } from "./wmx-shared";
 window.WMPreview = {
   registerCustomWidget,
   getCustomWidget,
-  hasCustomWidget
+  hasCustomWidget,
+  registerWmxComponents
+  // React,
+  // ReactDOM,
+  // ReactDOMClient,
+  // jsxRuntime: ReactJsxRuntime,
 };
 function injectGlobalStyles() {
   if (document.querySelector('style[data-wm-scope="globals"]')) return;
@@ -56,5 +63,6 @@ const noop = () => {
 };
 var main_default = noop;
 export {
+  __wmxShared,
   main_default as default
 };

package/runtime-dynamic/services/compile-render.js

@@ -24,6 +24,7 @@ import { getCustomWidget } from "../registry/custom-widget-registry";
 import {
   WmxComponentPlaceholder
 } from "../components/wmx-placeholder";
+import WmxRenderer from "../../components/wmx/WmxRenderer";
 import { formatMessage, _get, toNumber } from "../../core/util";
 import { getPartialNames } from "../app-initializer";
 import { createLazyPartial } from "./variable-registry";
@@ -75,6 +76,12 @@ function tryAddWmxScopeComponent(scopeName, seen, names, values) {
     values.push(registered);
     return true;
   }
+  if (scopeName === "WmxRenderer") {
+    seen.add(scopeName);
+    names.push(scopeName);
+    values.push(WmxRenderer);
+    return true;
+  }
   const component = (props) => {
     var _a, _b;
     return React.createElement(WmxComponentPlaceholder, __spreadProps(__spreadValues({}, props), {

package/runtime-dynamic/services/css-scoping.d.ts

@@ -1,4 +1,4 @@
 /** Resolves the prefab name used for CSS scope classes and `app-prefab-{name}` wrappers. */
 export declare function resolvePrefabScopeName(componentName: string, prefabname?: string): string;
-export declare function scopeComponentStyles(componentName: string, componentType: string, styles: string): string;
+export declare function scopeComponentStyles(componentName: string, componentType: string, styles: string, uniqueId: string): string;
 export declare function removeComponentStyles(componentName: string, componentType: string): void;

package/runtime-dynamic/services/css-scoping.js

@@ -35,7 +35,7 @@ function getCssScopeOptions(componentType, componentName) {
   }
   return void 0;
 }
-function scopeComponentStyles(componentName, componentType, styles) {
+function scopeComponentStyles(componentName, componentType, styles, uniqueId) {
   var _a;
   if (!styles) return "";
   const scopeOptions = getCssScopeOptions(componentType, componentName);
@@ -48,7 +48,7 @@ function scopeComponentStyles(componentName, componentType, styles) {
     scopedCssCache.set(cacheKey, scopedCss);
   }
   const styleElement = document.createElement("style");
-  styleElement.setAttribute("data-wm-scope", scopeAttribute);
+  styleElement.setAttribute("data-wm-scope", `${scopeAttribute}-${uniqueId}`);
   styleElement.textContent = scopedCss;
   const existing = document.querySelector(`style[data-wm-scope="${scopeAttribute}"]`);
   if (existing) {

package/runtime-dynamic/services/variable-factory.js

@@ -23,6 +23,7 @@ import {
   EMPTY_RESULT,
   createLazyPartial
 } from "./variable-registry";
+import { getPartialNames } from "../app-initializer";
 const EVENT_HANDLER_REGEX = /^(\w+)\(([^)]*)\)$/;
 const RETURN_VALUE_HANDLERS = /* @__PURE__ */ new Set([
   "onBeforeUpdate",
@@ -126,7 +127,7 @@ const enhanceNotification = (config, variable, scopeProxy) => {
   const dataBindings = variable.dataBinding;
   const pageBinding = dataBindings == null ? void 0 : dataBindings.find((b) => b.target === "page");
   if (pageBinding == null ? void 0 : pageBinding.value) {
-    const partialName = pageBinding.value.charAt(0).toUpperCase() + pageBinding.value.slice(1);
+    const partialName = getPartialNames().find((p) => p.toLowerCase() === pageBinding.value.toLowerCase()) || pageBinding.value;
     config.partialContent = { component: createLazyPartial(partialName) };
   }
 };

package/runtime-dynamic/services/variable-transpiler.js

@@ -23,6 +23,7 @@ import {
   EMPTY_RESULT,
   createLazyPartial
 } from "./variable-registry";
+import { getPartialNames } from "../app-initializer";
 function buildEntityProviderShims(rawVariables) {
   const entityMap = /* @__PURE__ */ new Map();
   for (const config of Object.values(rawVariables || {})) {
@@ -99,8 +100,10 @@ function transpileAndBuildGetVariables(variablesCodeString, rawVariables) {
     getEntityPropertyMap,
     getEntityRelatedTables
   });
+  const knownPartials = getPartialNames();
   for (const name of extractPartialImports(variablesCodeString)) {
-    scopeWithShims[name] = createLazyPartial(name);
+    const partialName = knownPartials.find((p) => p.toLowerCase() === name.toLowerCase()) || name;
+    scopeWithShims[name] = createLazyPartial(partialName);
   }
   const scopeNames = Object.keys(scopeWithShims);
   const scopeValues = Object.values(scopeWithShims);

package/runtime-dynamic/wmx-shared.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Packages the app's WMX bundle must borrow from this one instead of bundling
+ * its own copy.
+ *
+ * A WMX component is built separately and loaded as its own <script>, so any
+ * package used on both sides ends up loaded twice. For most packages that is
+ * harmless -- two copies of lodash or embla-carousel just cost bundle size,
+ * because everything they hold lives on the values they hand back.
+ *
+ * The ones below are different. Each keeps something private inside the package
+ * itself that both sides have to agree on:
+ *
+ *   react / react-dom   a second copy makes every hook throw "Invalid hook call"
+ *   @emotion/*          two copies write conflicting stylesheets
+ *   @mui/*              the app's <ThemeProvider> cannot be seen by a second copy
+ *   react-redux,
+ *   @reduxjs/toolkit    the store cannot be seen by a second copy
+ *   react-hook-form     the form provider cannot be seen by a second copy
+ *   react-router-dom    the router cannot be seen by a second copy
+ *   @dnd-kit/core,
+ *   @base-ui-components same problem, their own providers
+ *
+ * Everything except React fails QUIETLY -- the component reads an empty default
+ * instead of the app's real value, with no error anywhere. That is why the list
+ * is written out by hand rather than guessed.
+ *
+ * It only needs to cover packages THIS runtime ships. A package a WMX component
+ * adds that the runtime does not have exists only once on the page, so there is
+ * nothing to share and nothing to break -- which is what stops this list from
+ * growing every time someone writes a new component.
+ *
+ * Handed over as a plain module export, not on `window`. The app's WMX bundle
+ * imports it straight out of wm-react-loader.js, so the browser reuses the file
+ * it already loaded for the page and there is only ever one copy.
+ *
+ * Adding a package here is half the job -- the name must also go into
+ * SHARED_MODULES in the app's config/esbuild.wmx.config.mjs. If it is only
+ * listed there, the bundle throws a clear message when it loads.
+ */
+export declare const __wmxShared: Record<string, unknown>;

package/runtime-dynamic/wmx-shared.js

@@ -0,0 +1,33 @@
+import * as React from "react";
+import * as ReactJsxRuntime from "react/jsx-runtime";
+import * as ReactDOM from "react-dom";
+import * as ReactDOMClient from "react-dom/client";
+import * as EmotionReact from "@emotion/react";
+import * as EmotionStyled from "@emotion/styled";
+import * as MuiMaterial from "@mui/material";
+import * as MuiXDatePickers from "@mui/x-date-pickers";
+import * as ReactRedux from "react-redux";
+import * as ReduxToolkit from "@reduxjs/toolkit";
+import * as ReactHookForm from "react-hook-form";
+import * as ReactRouterDom from "react-router-dom";
+import * as DndKitCore from "@dnd-kit/core";
+import * as BaseUiComponents from "@base-ui-components/react";
+const __wmxShared = {
+  react: React,
+  "react/jsx-runtime": ReactJsxRuntime,
+  "react-dom": ReactDOM,
+  "react-dom/client": ReactDOMClient,
+  "@emotion/react": EmotionReact,
+  "@emotion/styled": EmotionStyled,
+  "@mui/material": MuiMaterial,
+  "@mui/x-date-pickers": MuiXDatePickers,
+  "react-redux": ReactRedux,
+  "@reduxjs/toolkit": ReduxToolkit,
+  "react-hook-form": ReactHookForm,
+  "react-router-dom": ReactRouterDom,
+  "@dnd-kit/core": DndKitCore,
+  "@base-ui-components/react": BaseUiComponents
+};
+export {
+  __wmxShared
+};

package/utils/style-utils.js

@@ -1,6 +1,6 @@
 import { getCurrentPath } from "../core/util/utils";
 const sanitizeStyleObject = (styleObj) => {
-  if (!styleObj || typeof styleObj !== "object") {
+  if (!styleObj || typeof styleObj !== "object" || Array.isArray(styleObj)) {
     return {};
   }
   const validStyles = {};

package/utils/wmx.utils.d.ts

@@ -3,4 +3,3 @@ export type WmxComponentModule = Record<string, ComponentType<any>>;
 export declare const registerWmxComponents: (module: WmxComponentModule) => void;
 export declare const getWmxModule: () => WmxComponentModule | null;
 export declare const getWmxComponentName: (widgetName: string) => string | null;
-export declare const loadWmxComponent: (componentName: string) => Promise<ComponentType<any> | null>;

package/utils/wmx.utils.js

@@ -9,33 +9,8 @@ const getWmxComponentName = (widgetName) => {
   const componentName = (_a = widgetName.split("-")) == null ? void 0 : _a[1];
   return componentName || null;
 };
-const resolveWmxComponent = (module, componentName) => {
-  const prefixedComponentName = `Wmx${componentName}`;
-  const namedExport = module[prefixedComponentName];
-  return namedExport;
-};
-const loadWmxComponent = async (componentName) => {
-  try {
-    const module = _registeredModule;
-    if (!module) {
-      console.warn("wmx modules not found");
-      const fallbackModule = await import("../components/input/text");
-      return fallbackModule.default;
-    }
-    const component = resolveWmxComponent(module, componentName);
-    if (!component) {
-      throw new Error(`WMX component "${componentName}" has no default export.`);
-    }
-    return component;
-  } catch (error) {
-    console.warn(`WMX component "${componentName}" failed to load, falling back to WmText.`, error);
-    const fallbackModule = await import("../components/input/text");
-    return fallbackModule.default;
-  }
-};
 export {
   getWmxComponentName,
   getWmxModule,
-  loadWmxComponent,
   registerWmxComponents
 };

package/variables/crud-variable.d.ts

@@ -22,8 +22,18 @@ declare class CrudVariable extends CrudVariable_base {
     config: CrudVariableConfig;
     params: any;
     filters: any;
+    /**
+     * The by-name params a generated invokeHttp receives. Same field name ServiceVariable uses, so
+     * useHttp's call site needs no per-kind chain. NOT `lastInvokedParams`: that name is
+     * ServiceVariable's RAW provider snapshot (compared against by invokeOnParamChange), and it is
+     * private there — reading it cross-object would also be reading a different thing.
+     */
+    resolvedParams: any;
     constructor(config: CrudVariableConfig);
     setFilterExpValue(filter: any): void;
+    lastInvokedOperation: string | undefined;
+    private captureLastInvokedParams;
+    private resolveParams;
     invokeOnParamChange(): Promise<this>;
     listRecords(options?: any, onSuccess?: Function, onError?: Function): any;
     updateRecord(options?: any, success?: any, error?: any): any;

package/variables/crud-variable.js

@@ -9,7 +9,9 @@ import {
   internalBoundNodeMap
 } from "@wavemaker-ai/variables";
 import { VariableEvents, isStaticParamVariable } from "./base-variable";
-import { isEqual, isUndefined, isFunction, forEach, isEmpty, isArray, set } from "lodash-es";
+import { isEqual, isUndefined, isFunction, forEach, isEmpty, isArray, set, merge } from "lodash-es";
+import { metadataService } from "./metadata.service";
+import { resolveOperationParams } from "./operation-params";
 import httpService from "../hooks/useHttp";
 import { deepCopy } from "../core/util";
 import Formatters from "../core/formatters";
@@ -63,12 +65,26 @@ class CrudVariable extends _CrudVariable {
           EventNotifier.ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
         }
         return config.onError && config.onError(args.variable, args.data, args.options);
-      }
+      },
+      // Outside preview mode useHttp's send() calls variable.invokeHttp — without this the
+      // generated glue is dropped here and every CRUD call throws "invokeHttp is not a function".
+      invokeHttp: (config == null ? void 0 : config.invokeHttp) || void 0
     };
     super(variableConfig);
     this.config = config;
     __publicField(this, "params", {});
     __publicField(this, "filters", {});
+    /**
+     * The by-name params a generated invokeHttp receives. Same field name ServiceVariable uses, so
+     * useHttp's call site needs no per-kind chain. NOT `lastInvokedParams`: that name is
+     * ServiceVariable's RAW provider snapshot (compared against by invokeOnParamChange), and it is
+     * private there — reading it cross-object would also be reading a different thing.
+     */
+    __publicField(this, "resolvedParams");
+    // Which CRUD operation this call is for. A CrudVariable maps to a SET of operations
+    // (list/create/update/delete) resolved per call, so a generated invokeHttp has to be told which
+    // one to dispatch to — unlike a ServiceVariable, which is always one fixed operation.
+    __publicField(this, "lastInvokedOperation");
     this.dateFormatter = Formatters.get("toDate");
     this.init();
   }
@@ -79,6 +95,36 @@ class CrudVariable extends _CrudVariable {
       r.value = filter[r.target];
     });
   }
+  captureLastInvokedParams(options, operation) {
+    var _a, _b;
+    this.lastInvokedOperation = (_a = operation != null ? operation : options == null ? void 0 : options.operation) != null ? _a : "list";
+    let inputFields = merge({}, this.config.paramProvider(), this.dataBinding, this.params);
+    if (options) {
+      const overrides = (_b = options.inputFields) != null ? _b : options;
+      inputFields = merge({}, inputFields, overrides);
+    }
+    this.resolvedParams = this.resolveParams(inputFields, options);
+  }
+  // CrudVariableManager calls httpCall(requestParams, variable) with NO third argument (unlike
+  // Live/ServiceVariable), so a generated invokeHttp never receives this call's values by name.
+  // The manager does resolve them — onto operationInfo.parameters[].sampleValue in
+  // getMethodInfoForCrud — but keeps that local. Rebuild the same flat map from the same
+  // servicedefs entry, using the resolver shared with ServiceVariable.
+  resolveParams(inputFields, options) {
+    var _a, _b, _c, _d;
+    const defs = (_c = (_a = metadataService) == null ? void 0 : _a.getByCrudId) == null ? void 0 : _c.call(
+      _a,
+      this.config.crudOperationId,
+      (_b = this.getPrefabName) == null ? void 0 : _b.call(this)
+    );
+    const def = (defs || []).find((d) => (d == null ? void 0 : d.operationType) === this.lastInvokedOperation);
+    return resolveOperationParams({
+      parameters: (_d = def == null ? void 0 : def.wmServiceOperationInfo) == null ? void 0 : _d.parameters,
+      inputFields,
+      options,
+      config: this.config
+    });
+  }
   invokeOnParamChange() {
     const isStatic = isStaticParamVariable(this.config, this);
     if (isStatic) return isStatic;
@@ -125,21 +171,25 @@ class CrudVariable extends _CrudVariable {
     options = options || {};
     options.filterFields = this.filters;
     this.setFilterExpValue(this.filters);
+    this.captureLastInvokedParams(options, "list");
     return super.listRecords(options, onSuccess, onError);
   }
   updateRecord(options, success, error) {
     this.processBinding(this);
     this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    this.captureLastInvokedParams(options, "update");
     return super.updateRecord(options, success, error);
   }
   insertRecord(options, success, error) {
     this.processBinding(this);
     this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    this.captureLastInvokedParams(options, "create");
     return super.insertRecord(options, success, error);
   }
   deleteRecord(options, success, error) {
     this.processBinding(this);
     this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    this.captureLastInvokedParams(options, "delete");
     return super.deleteRecord(options, success, error);
   }
   processBindExp(d, variable) {
@@ -187,6 +237,7 @@ class CrudVariable extends _CrudVariable {
   }
   invoke(options, onSuccess, onError) {
     this.processBinding(this);
+    this.captureLastInvokedParams(options);
     return super.invoke(options, onSuccess, onError);
   }
 }

package/variables/live-variable.d.ts

@@ -34,6 +34,7 @@ export interface LiveVariableConfig extends VariableConfig {
     insertRecord: (options?: any, success?: any, error?: any) => Promise<any>;
     deleteRecord: (options?: any, success?: any, error?: any) => Promise<any>;
     notify: (event: VariableEvents, args: any) => void;
+    invokeHttp?: Function;
 }
 declare enum _LiveVariableEvents {
     BEFORE_INVOKE = "beforeInvoke"

package/variables/live-variable.js

@@ -66,7 +66,8 @@ class LiveVariable extends _LiveVariable {
           EventNotifier.ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
         }
         return config.onError && config.onError(args.variable, args.data, args.options);
-      }
+      },
+      invokeHttp: (config == null ? void 0 : config.invokeHttp) || void 0
     };
     super(variableConfig);
     this.config = config;

package/variables/operation-params.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Port of getEvaluatedOrderBy (not exported from the package root): the options order wins, and a
+ * field ordered by both is kept only once.
+ */
+export declare function evaluatedOrderBy(varOrder: any, optionsOrder: any): any;
+export interface ResolveParamsInput {
+    /** The operation's declared parameters — `wmServiceOperationInfo.parameters`. */
+    parameters?: any[];
+    /** The values the variable already holds, keyed by param name. */
+    inputFields?: any;
+    /** The per-call options (`options.page`, `options.size`, `options.orderBy`). */
+    options?: any;
+    /** The variable's own config, for its defaults. */
+    config?: any;
+    /**
+     * ServiceVariableUtils' `isBodyTypeQueryOrProcedure` — `controller` in
+     * {QueryExecution, ProcedureExecution} and `operationType` in {put, post}. Its BODY branch
+     * assembles the body from the body param's declared children instead of reading the param's
+     * own value.
+     */
+    isBodyTypeQueryOrProcedure?: boolean;
+    /** `wmServiceOperationInfo.definitions` — keyed by a param's `type`, listing its children. */
+    definitions?: Record<string, any>;
+}
+/**
+ * Returns `inputFields` unchanged when the operation has no declared parameters — there is nothing
+ * to resolve against, so passing the raw fields through is strictly better than emptying them.
+ */
+export declare function resolveOperationParams({ parameters, inputFields, options, config, isBodyTypeQueryOrProcedure, definitions, }: ResolveParamsInput): any;

package/variables/operation-params.js

@@ -0,0 +1,69 @@
+import { includes, isEmpty, join, map, remove, split, trim } from "lodash-es";
+const PAGINATION_PARAMS = ["page", "size", "sort"];
+function evaluatedOrderBy(varOrder, optionsOrder) {
+  if (!optionsOrder || isEmpty(optionsOrder)) {
+    return varOrder;
+  }
+  if (!varOrder) {
+    return optionsOrder;
+  }
+  const varFields = split(varOrder, ",");
+  const optionFields = map(split(optionsOrder, ","), (order) => split(trim(order), " ")[0]);
+  remove(varFields, (orderBy) => includes(optionFields, split(trim(orderBy), " ")[0]));
+  return join(split(optionsOrder, ","), ",") + (varFields.length ? "," + join(varFields, ",") : "");
+}
+function buildQueryProcedureBody(param, inputFields, definitions) {
+  const children = definitions == null ? void 0 : definitions[param == null ? void 0 : param.type];
+  const wrapped = inputFields == null ? void 0 : inputFields[param == null ? void 0 : param.name];
+  const values = wrapped && typeof wrapped === "object" && !Array.isArray(wrapped) ? wrapped : inputFields;
+  const declared = (children == null ? void 0 : children.length) ? children.filter((child) => !(child == null ? void 0 : child.readOnly)) : Object.keys(values != null ? values : {}).map((name) => ({ name }));
+  const body = {};
+  for (const child of declared) {
+    const value = values == null ? void 0 : values[child.name];
+    if (value !== void 0 && value !== "" && value !== null) {
+      body[child.name] = value;
+    }
+  }
+  return body;
+}
+function resolveOperationParams({
+  parameters,
+  inputFields,
+  options,
+  config,
+  isBodyTypeQueryOrProcedure,
+  definitions
+}) {
+  var _a, _b;
+  if (!(parameters == null ? void 0 : parameters.length)) {
+    return inputFields;
+  }
+  if (isBodyTypeQueryOrProcedure) {
+    const bodyParam = parameters.find((p) => (p == null ? void 0 : p.parameterType) === "body");
+    if (bodyParam) {
+      return buildQueryProcedureBody(bodyParam, inputFields, definitions);
+    }
+  }
+  const resolved = {};
+  for (const param of parameters) {
+    if (param.readOnly) {
+      continue;
+    }
+    let value = inputFields == null ? void 0 : inputFields[param.name];
+    if (includes(PAGINATION_PARAMS, param.name)) {
+      if (param.name === "size") {
+        value = (options == null ? void 0 : options.size) || value || ((_b = (_a = config == null ? void 0 : config._paginationConfig) == null ? void 0 : _a.input) == null ? void 0 : _b.size) || parseInt(config == null ? void 0 : config.maxResults, 10);
+      } else if (param.name === "page") {
+        value = (options == null ? void 0 : options.page) || value || 1;
+      } else if (param.name === "sort") {
+        value = evaluatedOrderBy(config == null ? void 0 : config.orderBy, options == null ? void 0 : options.orderBy) || value || "";
+      }
+    }
+    resolved[param.name] = value;
+  }
+  return resolved;
+}
+export {
+  evaluatedOrderBy,
+  resolveOperationParams
+};

package/variables/service-variable.d.ts

@@ -11,6 +11,7 @@ export interface ServiceVariableConfig extends VariableConfig {
     inFlightBehavior: string;
     controller: string;
     getServiceInfo: Function;
+    invokeHttp?: Function;
 }
 declare enum _ServiceVariableEvents {
     BEFORE_INVOKE = "beforeInvoke"
@@ -24,6 +25,14 @@ export declare class ServiceVariable extends ServiceVariable_base {
     private initialized;
     params: any;
     private lastInvokedParams;
+    /**
+     * The by-name params a generated invokeHttp receives — resolved from the operation's declared
+     * parameters, so the pagination defaults the manager applies internally are present. Kept
+     * separate from lastInvokedParams, which invokeOnParamChange() compares against the RAW provider
+     * values: adding `page`/`size` to that snapshot would make every comparison unequal and
+     * re-invoke in a loop.
+     */
+    resolvedParams: any;
     private dateFormatter;
     private lastParams;
     private lastParamProviderValues;