@wavemaker-ai/react-runtime 1.0.0-next.27766

package/components/data/card/index.js

@@ -0,0 +1,253 @@
+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 { jsx, jsxs } from "react/jsx-runtime";
+import React, { useCallback, useMemo, useRef, useEffect } from "react";
+import withBaseWrapper from "../../../higherOrder/withBaseWrapper";
+import { Card, CardHeader, CardMedia, Avatar, Typography, Box } from "@mui/material";
+import Image from "next/image";
+import { WmMenu } from "../../navigation/menu";
+import { WmAppIcon } from "../../common/WmAppIcon";
+import clsx from "clsx";
+import WmCardContentWithWrapper, { WmCardContent } from "./card-content";
+import WmCardActionsWithWrapper, { WmCardActions } from "./card-actions";
+import WmCardFooterWithWrapper, { WmCardFooter } from "./card-footer";
+const WmCard = (props) => {
+  const {
+    name,
+    title,
+    subheading,
+    iconclass,
+    iconurl,
+    actions,
+    picturesource,
+    picturetitle,
+    imageheight = "200px",
+    itemaction,
+    itemchildren,
+    itemicon,
+    itemlabel,
+    itemlink,
+    userrole,
+    isactive,
+    autoclose = "always",
+    children,
+    className = "",
+    onClick,
+    onDblclick,
+    onMouseover,
+    onMouseout,
+    onMouseenter,
+    onMouseleave,
+    animation,
+    height,
+    width,
+    cardItem,
+    listener
+  } = props;
+  const cardRef = useRef(null);
+  const showHeader = useMemo(() => {
+    return !!(title || subheading || iconclass || iconurl || actions);
+  }, [title, subheading, iconclass, iconurl, actions]);
+  const handleKeyDown = useCallback((event) => {
+    var _a;
+    if (event.key === "Enter") {
+      event.preventDefault();
+      (_a = cardRef.current) == null ? void 0 : _a.click();
+    }
+  }, []);
+  const handleClick = useCallback(
+    (event) => {
+      var _a;
+      onClick == null ? void 0 : onClick(event, (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name], cardItem, listener);
+    },
+    [onClick, listener, name]
+  );
+  const handleDoubleClick = useCallback(
+    (event) => {
+      var _a;
+      onDblclick == null ? void 0 : onDblclick(event, (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name], cardItem, listener);
+    },
+    [onDblclick, props]
+  );
+  const handleMouseOver = useCallback(
+    (event) => {
+      var _a;
+      onMouseover == null ? void 0 : onMouseover(event, (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name], cardItem, listener);
+    },
+    [onMouseover, props]
+  );
+  const handleMouseOut = useCallback(
+    (event) => {
+      var _a;
+      onMouseout == null ? void 0 : onMouseout(event, (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name], cardItem, listener);
+    },
+    [onMouseout, props]
+  );
+  const handleMouseEnter = useCallback(
+    (event) => {
+      var _a;
+      onMouseenter == null ? void 0 : onMouseenter(event, (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name], cardItem, listener);
+    },
+    [onMouseenter, props]
+  );
+  const handleMouseLeave = useCallback(
+    (event) => {
+      var _a;
+      onMouseleave == null ? void 0 : onMouseleave(event, (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name], cardItem, listener);
+    },
+    [onMouseleave, props]
+  );
+  useEffect(() => {
+    if (cardRef.current) {
+      cardRef.current.setAttribute("tabindex", "0");
+    }
+  }, []);
+  const menuItems = useMemo(() => {
+    if (!actions) return [];
+    try {
+      if (actions.startsWith("[") || actions.startsWith("{")) {
+        return JSON.parse(actions);
+      }
+      return actions.split(",").map((action, index) => ({
+        id: index,
+        label: action.trim(),
+        action: itemaction,
+        icon: itemicon,
+        link: itemlink,
+        children: itemchildren
+      }));
+    } catch (error) {
+      console.warn("Failed to parse actions data:", error);
+      return [];
+    }
+  }, [actions, itemaction, itemicon, itemlink, itemchildren]);
+  const isComponentType = (child, ComponentType) => {
+    return React.isValidElement(child) && child.type === ComponentType;
+  };
+  const cardProps = {
+    ref: cardRef,
+    className: clsx("app-card card app-panel", className, animation ? `animated ${animation}` : ""),
+    onKeyDown: handleKeyDown,
+    onClick: handleClick,
+    onDoubleClick: handleDoubleClick,
+    onMouseOver: handleMouseOver,
+    onMouseOut: handleMouseOut,
+    onMouseEnter: handleMouseEnter,
+    onMouseLeave: handleMouseLeave,
+    style: {
+      width,
+      height
+    }
+  };
+  const renderAvatar = () => {
+    if (!iconclass && !iconurl) {
+      return null;
+    }
+    return /* @__PURE__ */ jsx(Avatar, { className: "app-card-avatar", children: /* @__PURE__ */ jsx(
+      WmAppIcon,
+      {
+        iconclass,
+        iconurl,
+        prefabName: props.prefabName,
+        defaultClasses: iconurl ? "wm-card-avatar-img img-circle" : "",
+        alt: ""
+      }
+    ) });
+  };
+  const renderActionMenu = () => {
+    if (!actions) return null;
+    return /* @__PURE__ */ jsx(
+      WmMenu,
+      {
+        listener: {},
+        type: "anchor",
+        iconclass: "wm-sl-l sl-more-menu-vertical",
+        menuposition: "down,left",
+        hint: "Actions",
+        caption: "",
+        dataset: menuItems,
+        autoclose,
+        itemlabel,
+        itemicon,
+        itemlink,
+        itemaction,
+        itemchildren,
+        userrole,
+        isactive,
+        className: "panel-action"
+      }
+    );
+  };
+  const cardHeaderProps = __spreadValues(__spreadValues({
+    className: "app-card-header panel-heading",
+    avatar: renderAvatar(),
+    action: renderActionMenu()
+  }, title && {
+    title: /* @__PURE__ */ jsx(Typography, { variant: "h4", className: "card-heading", children: title })
+  }), subheading && {
+    subheader: /* @__PURE__ */ jsx(Typography, { variant: "h5", className: "card-subheading text-muted", children: subheading })
+  });
+  return /* @__PURE__ */ jsxs(Card, __spreadProps(__spreadValues({}, cardProps), { children: [
+    showHeader && /* @__PURE__ */ jsx(CardHeader, __spreadValues({}, cardHeaderProps)),
+    picturesource && /* @__PURE__ */ jsx(
+      CardMedia,
+      {
+        component: "div",
+        className: clsx("app-card-image", "wm-card-media-root"),
+        style: { maxHeight: imageheight },
+        children: /* @__PURE__ */ jsx(
+          Image,
+          {
+            src: picturesource,
+            alt: picturetitle || "",
+            width: 0,
+            height: 0,
+            sizes: "100vw",
+            className: clsx("card-image", "wm-card-media-img")
+          }
+        )
+      }
+    ),
+    React.Children.map(children, (child) => {
+      if (isComponentType(child, WmCardContent) || isComponentType(child, WmCardContentWithWrapper)) {
+        return child;
+      }
+      return null;
+    }),
+    React.Children.map(children, (child) => {
+      if (isComponentType(child, WmCardActions) || isComponentType(child, WmCardActionsWithWrapper)) {
+        return child;
+      }
+      return null;
+    }),
+    /* @__PURE__ */ jsx(Box, { children: React.Children.map(children, (child) => {
+      if (isComponentType(child, WmCardFooter) || isComponentType(child, WmCardFooterWithWrapper)) {
+        return child;
+      }
+      return null;
+    }) })
+  ] }));
+};
+WmCard.displayName = "WmCard";
+var card_default = withBaseWrapper(React.memo(WmCard));
+export {
+  WmCard,
+  card_default as default
+};

package/components/data/card/props.d.ts

@@ -0,0 +1,131 @@
+import { BaseProps, Prettify } from "@wavemaker-ai/react-runtime/higherOrder/props";
+export interface CardProps {
+    /**
+     * Title of the card.
+     */
+    title?: string;
+    /**
+     * Subheading of the card.
+     */
+    subheading?: string;
+    /**
+     * CSS class for the icon in the card header.
+     */
+    iconclass?: string;
+    /**
+     * URL for the icon image in the card header.
+     */
+    iconurl?: string;
+    /**
+     * Actions available for the card, typically shown in a menu.
+     */
+    actions?: string;
+    /**
+     * Source URL for the card's main image.
+     */
+    picturesource?: string;
+    /**
+     * Title for the card's main image.
+     */
+    picturetitle?: string;
+    /**
+     * Height of the card's main image.
+     * @default "200px"
+     */
+    imageheight?: string;
+    /**
+     * Action to perform when a menu item is clicked.
+     */
+    itemaction?: string;
+    /**
+     * Property to use for submenu items.
+     */
+    itemchildren?: string;
+    /**
+     * Property to use for menu item icons.
+     */
+    itemicon?: string;
+    /**
+     * Property to use for menu item labels.
+     */
+    itemlabel?: string;
+    /**
+     * Property to use for menu item links.
+     */
+    itemlink?: string;
+    /**
+     * Property to determine if a menu item is active.
+     */
+    isactive?: string;
+    /**
+     * The data item associated with the card.
+     */
+    cardItem?: any;
+    /**
+     * User role for access control.
+     */
+    userrole?: string;
+    /**
+     * When to close the action menu.
+     * @default "always"
+     */
+    autoclose?: string;
+    /**
+     * Whether the card is the first item in a list.
+     */
+    isFirst?: boolean;
+    /**
+     * Whether the card is the last item in a list.
+     */
+    isLast?: boolean;
+    /**
+     * Widgets for the current item in a list.
+     */
+    currentItemWidgets?: any;
+    /**
+     * Callback for click event on the card.
+     */
+    onClick?: (event: React.MouseEvent, widget: any, item: any, currentItemWidgets: any) => void;
+    /**
+     * Callback for double click event on the card.
+     */
+    onDblclick?: (event: React.MouseEvent, widget: any, item: any, currentItemWidgets: any) => void;
+    /**
+     * Callback for mouse over event on the card.
+     */
+    onMouseover?: (event: React.MouseEvent, widget: any, item: any, currentItemWidgets: any) => void;
+    /**
+     * Callback for mouse out event on the card.
+     */
+    onMouseout?: (event: React.MouseEvent, widget: any, item: any, currentItemWidgets: any) => void;
+    /**
+     * Callback for mouse enter event on the card.
+     */
+    onMouseenter?: (event: React.MouseEvent, widget: any, item: any, currentItemWidgets: any) => void;
+    /**
+     * Callback for mouse leave event on the card.
+     */
+    onMouseleave?: (event: React.MouseEvent, widget: any, item: any, currentItemWidgets: any) => void;
+}
+export interface CardCommonProps {
+    /**
+     * HTML content for the card component.
+     */
+    content?: string;
+    /**
+     * Function to render partial content.
+     */
+    renderPartial?: (props: any, onLoad?: any) => React.ReactNode;
+    /**
+     * Callback for when the partial is loaded.
+     */
+    onLoad?: any;
+}
+/**
+ * Combined props for the WmCard component, including base WaveMaker props.
+ */
+export type WmCardProps = Prettify<CardProps & BaseProps>;
+/**
+ * Combined props for the WmCard sub-components, including base WaveMaker props.
+ */
+export type WmCardCommonProps = Prettify<CardCommonProps & BaseProps>;

package/components/data/form/base-form/constant.d.ts

@@ -0,0 +1,33 @@
+export declare const REGEX: {
+    SNAKE_CASE: RegExp;
+    ANDROID: RegExp;
+    IPHONE: RegExp;
+    IPOD: RegExp;
+    IPAD: RegExp;
+    MAC: RegExp;
+    ANDROID_TABLET: RegExp;
+    MOBILE: RegExp;
+    WINDOWS: RegExp;
+    SUPPORTED_IMAGE_FORMAT: RegExp;
+    SUPPORTED_FILE_FORMAT: RegExp;
+    SUPPORTED_AUDIO_FORMAT: RegExp;
+    SUPPORTED_VIDEO_FORMAT: RegExp;
+    PAGE_RESOURCE_PATH: RegExp;
+    MIN_PAGE_RESOURCE_PATH: RegExp;
+    VALID_EMAIL: RegExp;
+    VALID_WEB_URL: RegExp;
+    VALID_WEBSOCKET_URL: RegExp;
+    VALID_RELATIVE_URL: RegExp;
+    REPLACE_PATTERN: RegExp;
+    ZIP_FILE: RegExp;
+    EXE_FILE: RegExp;
+    NO_QUOTES_ALLOWED: RegExp;
+    NO_DOUBLE_QUOTES_ALLOWED: RegExp;
+    VALID_HTML: RegExp;
+    VALID_PASSWORD: RegExp;
+    SPECIAL_CHARACTERS: RegExp;
+    APP_SERVER_URL_FORMAT: RegExp;
+    JSON_DATE_FORMAT: RegExp;
+    DATA_URL: RegExp;
+    ISO_DATE_FORMAT: RegExp;
+};

package/components/data/form/base-form/constant.js

@@ -0,0 +1,36 @@
+const REGEX = {
+  SNAKE_CASE: /[A-Z]/g,
+  ANDROID: /Android/i,
+  IPHONE: /iPhone/i,
+  IPOD: /iPod/i,
+  IPAD: /iPad/i,
+  MAC: /Mac/i,
+  ANDROID_TABLET: /android|android 3.0|xoom|sch-i800|playbook|tablet|kindle/i,
+  MOBILE: /Mobile/i,
+  WINDOWS: /Windows Phone/i,
+  SUPPORTED_IMAGE_FORMAT: /\.(bmp|gif|jpe|jpg|jpeg|tif|tiff|pbm|png|ico)$/i,
+  SUPPORTED_FILE_FORMAT: /\.(txt|js|css|html|script|properties|json|java|xml|smd|xmi|sql|log|wsdl|vm|ftl|jrxml|yml|yaml|md|less|jsp)$/i,
+  SUPPORTED_AUDIO_FORMAT: /\.(mp3|ogg|webm|wma|3gp|wav|m4a)$/i,
+  SUPPORTED_VIDEO_FORMAT: /\.(mp4|ogg|webm|wmv|mpeg|mpg|avi|mov)$/i,
+  PAGE_RESOURCE_PATH: /^\/pages\/.*\.(js|css|html|json)$/,
+  MIN_PAGE_RESOURCE_PATH: /.*(page.min.html)$/,
+  VALID_EMAIL: /^[a-zA-Z][\w.+]+@[a-zA-Z_]+?\.[a-zA-Z.]{1,4}[a-zA-Z]$/,
+  VALID_WEB_URL: /^(http[s]?:\/\/)(www\.){0,1}[a-zA-Z0-9=:?\/\.\-]+(\.[a-zA-Z]{2,5}[\.]{0,1})?/,
+  VALID_WEBSOCKET_URL: /^(ws[s]?:\/\/)(www\.){0,1}[a-zA-Z0-9=:?\/\.\-]+(\.[a-zA-Z]{2,5}[\.]{0,1})?/,
+  VALID_RELATIVE_URL: /^(?!www\.|(?:http|ftp)s?:\/\/|[A-Za-z]:\\|\/\/).*/,
+  REPLACE_PATTERN: /\$\{([^\}]+)\}/g,
+  ZIP_FILE: /\.zip$/i,
+  EXE_FILE: /\.exe$/i,
+  NO_QUOTES_ALLOWED: /^[^'|"]*$/,
+  NO_DOUBLE_QUOTES_ALLOWED: /^[^"]*$/,
+  VALID_HTML: /<[a-z][\s\S]*>/i,
+  VALID_PASSWORD: /^[0-9a-zA-Z-_.@&*!#$%]+$/,
+  SPECIAL_CHARACTERS: /[^A-Z0-9a-z_]+/i,
+  APP_SERVER_URL_FORMAT: /^(http[s]?:\/\/)(www\.){0,1}[a-zA-Z0-9\.\-]+([:]?[0-9]{2,5}|\.[a-zA-Z]{2,5}[\.]{0,1})\/+[^?#&=]+$/,
+  JSON_DATE_FORMAT: /\d{4}-[0-1]\d-[0-3]\d(T[0-2]\d:[0-5]\d:[0-5]\d.\d{1,3}Z$)?/,
+  DATA_URL: /^\s*data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s]*)\s*$/i,
+  ISO_DATE_FORMAT: /(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})(\.\d+)?([+-]\d{2}:?\d{2}|Z)$/
+};
+export {
+  REGEX
+};

package/components/data/form/base-form/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export { useFormDataSync } from "./useFormDataSync";
+export { useParentFormRelationship } from "./useParentFormRelationship";
+export { useFormValidation } from "./useFormValidation";
+export { useFormOperations } from "./useFormOperations";
+export { useFormSubmission } from "./useFormSubmission";
+export { FormType, FORM_TYPE_CONFIGS, getFormTypeConfig, detectFormType, isChildFormType, usesPrefixedFields, } from "../props";
+export type { FormTypeConfig } from "../props";

package/components/data/form/base-form/hooks/index.js

@@ -0,0 +1,26 @@
+import { useFormDataSync } from "./useFormDataSync";
+import { useParentFormRelationship } from "./useParentFormRelationship";
+import { useFormValidation } from "./useFormValidation";
+import { useFormOperations } from "./useFormOperations";
+import { useFormSubmission } from "./useFormSubmission";
+import {
+  FormType,
+  FORM_TYPE_CONFIGS,
+  getFormTypeConfig,
+  detectFormType,
+  isChildFormType,
+  usesPrefixedFields
+} from "../props";
+export {
+  FORM_TYPE_CONFIGS,
+  FormType,
+  detectFormType,
+  getFormTypeConfig,
+  isChildFormType,
+  useFormDataSync,
+  useFormOperations,
+  useFormSubmission,
+  useFormValidation,
+  useParentFormRelationship,
+  usesPrefixedFields
+};

package/components/data/form/base-form/hooks/useFormDataSync.d.ts

@@ -0,0 +1,16 @@
+import { UseFormDataSyncOptions, UseFormDataSyncReturn } from "../props";
+/**
+ * Form Data Sync Manager
+ *
+ * Coordinates bidirectional data flow in nested forms:
+ * - DOWN: Props/widget data initializes forms
+ * - UP: User edits propagate to parent forms via events
+ * - DOWN: Context updates flow to child forms
+ *
+ * Key behaviors:
+ * 1. First sync always accepted (initialization)
+ * 2. Identical data ignored (no-op)
+ * 3. User clears block stale external data until genuinely new data arrives
+ * 4. Child forms have additional staleness checks for parent sync delays
+ */
+export declare function useFormDataSync({ reset, formType, formName, }: UseFormDataSyncOptions): UseFormDataSyncReturn;

package/components/data/form/base-form/hooks/useFormDataSync.js

@@ -0,0 +1,132 @@
+import { useRef, useCallback, useState, useMemo } from "react";
+import isEqual from "lodash-es/isEqual";
+import {
+  getFormTypeConfig,
+  isChildFormType
+} from "../props";
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "";
+}
+function useFormDataSync({
+  reset,
+  formType,
+  formName
+}) {
+  const config = useMemo(() => getFormTypeConfig(formType), [formType]);
+  const isChildForm = isChildFormType(formType);
+  const shouldWrapData = config.dataResetStrategy === "wrapped";
+  const [currentFormData, setCurrentFormData] = useState(null);
+  const stateRef = useRef({
+    state: "UNINITIALIZED",
+    currentData: null,
+    isUpdating: false
+  });
+  const lastSyncedExternalDataRef = useRef(null);
+  const applyResetStrategy = useCallback(
+    (data) => {
+      return shouldWrapData && formName ? { [formName]: data } : data;
+    },
+    [shouldWrapData, formName]
+  );
+  const updateState = useCallback((data, newState) => {
+    stateRef.current.currentData = data;
+    stateRef.current.state = newState;
+    setCurrentFormData(data);
+  }, []);
+  const withUpdateLock = useCallback((operation) => {
+    stateRef.current.isUpdating = true;
+    operation();
+    setTimeout(() => {
+      stateRef.current.isUpdating = false;
+    }, 0);
+  }, []);
+  const shouldSync = useCallback(
+    (incomingData) => {
+      if (!incomingData || incomingData._wmListItemId) return false;
+      if (stateRef.current.isUpdating) return false;
+      const { state, currentData } = stateRef.current;
+      if (state === "UNINITIALIZED" || !currentData) {
+        return true;
+      }
+      if (isEqual(incomingData, currentData)) {
+        return false;
+      }
+      const incomingKeys = Object.keys(incomingData);
+      const currentKeys = Object.keys(currentData);
+      if (!isChildForm) {
+        const hasNewFields = incomingKeys.some((key) => !(key in currentData));
+        if (hasNewFields && lastSyncedExternalDataRef.current !== null) {
+          const isSameAsLastSynced = isEqual(incomingData, lastSyncedExternalDataRef.current);
+          if (isSameAsLastSynced) {
+            return false;
+          }
+        }
+        return hasNewFields;
+      }
+      const incomingIsStale = currentKeys.some((key) => {
+        const cur = currentData[key];
+        const inc = incomingData[key];
+        const curHasValue = !isEmpty(cur);
+        const incHasValue = !isEmpty(inc);
+        if (curHasValue && !incHasValue) return true;
+        if (curHasValue && incHasValue && !isEqual(cur, inc)) return true;
+        if (!curHasValue && incHasValue) return true;
+        return false;
+      });
+      return !incomingIsStale;
+    },
+    [isChildForm]
+  );
+  const syncFormData = useCallback(
+    (data) => {
+      if (!shouldSync(data)) return;
+      lastSyncedExternalDataRef.current = data;
+      withUpdateLock(() => {
+        reset(applyResetStrategy(data));
+        updateState(data, "SYNCED");
+      });
+    },
+    [shouldSync, withUpdateLock, reset, applyResetStrategy, updateState, formName, isChildForm]
+  );
+  const resetFormData = useCallback(
+    (data) => {
+      if (!data || typeof data !== "object" || Array.isArray(data)) return;
+      lastSyncedExternalDataRef.current = data;
+      withUpdateLock(() => {
+        reset(applyResetStrategy(data));
+        updateState(data, "SYNCED");
+      });
+    },
+    [withUpdateLock, reset, applyResetStrategy, updateState]
+  );
+  const clearFormData = useCallback(
+    (cleanedData) => {
+      const dataToReset = cleanedData || {};
+      withUpdateLock(() => {
+        reset(applyResetStrategy(dataToReset));
+        updateState(dataToReset, "SYNCED");
+      });
+    },
+    [withUpdateLock, reset, applyResetStrategy, updateState]
+  );
+  const markCurrentData = useCallback((data) => {
+    stateRef.current.currentData = data;
+    if (stateRef.current.state === "UNINITIALIZED" && data && Object.keys(data).length > 0) {
+      stateRef.current.state = "SYNCED";
+    }
+  }, []);
+  const isUpdating = useCallback(() => {
+    return stateRef.current.isUpdating;
+  }, []);
+  return {
+    currentFormData,
+    syncFormData,
+    resetFormData,
+    clearFormData,
+    markCurrentData,
+    isUpdating
+  };
+}
+export {
+  useFormDataSync
+};

package/components/data/form/base-form/hooks/useFormOperations.d.ts

@@ -0,0 +1,13 @@
+import { UseFormOperationsOptions, UseFormOperationsReturn } from "../props";
+/**
+ * Hook for managing form CRUD operations
+ *
+ * Handles:
+ * - Form reset (clearing all fields)
+ * - Create new entry
+ * - Edit existing entry
+ * - Set form data programmatically
+ * - Save and new / Save and view actions
+ * - View mode state management
+ */
+export declare function useFormOperations({ formName, formfields, formRef, formReff, formType, fullDataPath, parentFormDataContext, clearFormData, resetFormData, trigger, submit, formProxy, widgetFormType, debouncedFilter, }: UseFormOperationsOptions): UseFormOperationsReturn;