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

package/components/page/props.d.ts

@@ -0,0 +1,33 @@
+import { BaseProps, Prettify } from "@wavemaker-ai/react-runtime/higherOrder/props";
+/** Event payload for page lifecycle and resize events. */
+type PageEventPayload = {
+    type: string;
+    target: Window;
+};
+/**
+ * Props specific to the WmPage component.
+ */
+export interface PageProps {
+    /** The title of the page. */
+    pagetitle?: string;
+    /** Callback when navigation height changes (used internally for layout). */
+    onNavHeightChange?: (isFull: boolean) => void;
+    /** Fired when the page is attached to the DOM. */
+    OnAttach?: (event: PageEventPayload, props: WmPageProps) => void;
+    /** Fired when the page is detached from the DOM. */
+    OnDetach?: (event: PageEventPayload, props: WmPageProps) => void;
+    /** Fired when the page is destroyed. */
+    OnDestroy?: (event: PageEventPayload, props: WmPageProps) => void;
+    /** Fired when device orientation changes. */
+    OnOrientationChange?: (event: Event, props: WmPageProps) => void;
+    /** Fired when the window is resized. */
+    OnResize?: (event: PageEventPayload, props: WmPageProps, size: {
+        width: number;
+        height: number;
+    }) => void;
+}
+/**
+ * Combined props for the WmPage component, including base WaveMaker props.
+ */
+export type WmPageProps = Prettify<PageProps & BaseProps>;
+export {};

package/components/page/toast-container/index.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { WmPageToastProps } from "./props";
+/**
+ * The WmPageToast component is a container wrapper for toast notification components.
+ *
+ * - [Playground](https://react-components.wavemaker.ai/?path=/story/page-toast--showcase)
+ *
+ * - [Docs](https://react-components.wavemaker.ai/?path=/story/page-toast--docs#tab-overview)
+ *
+ * @param props - {@link WmPageToastProps}
+ */
+declare const _default: React.MemoExoticComponent<({ component: Component }: WmPageToastProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/components/page/toast-container/index.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { memo } from "react";
+import Container from "@mui/material/Container";
+import Box from "@mui/material/Box";
+const WmPageToast = ({ component: Component }) => {
+  return /* @__PURE__ */ jsx(
+    Container,
+    {
+      style: {
+        position: "relative",
+        scrollbarWidth: "none"
+      },
+      id: "toast-container",
+      className: " toast-container",
+      children: /* @__PURE__ */ jsx(Box, { component: "div", className: "toast", sx: { opacity: "1 !important" }, children: /* @__PURE__ */ jsx(Container, { className: "parent-custom-toast", children: /* @__PURE__ */ jsx(Component, {}) }) })
+    }
+  );
+};
+var toast_container_default = memo(WmPageToast);
+export {
+  toast_container_default as default
+};

package/components/page/toast-container/props.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+/**
+ * Props for the WmPageToast component.
+ */
+export interface WmPageToastProps {
+    /** The toast component to render inside the container. */
+    component: React.ComponentType<any>;
+}

package/components/prefab/container/index.d.ts

@@ -0,0 +1,12 @@
+import { WmPrefabContainerProps } from "./props";
+declare const WmPrefabContainer: (props: WmPrefabContainerProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The WmPrefabContainer component is a wrapper for prefab content with load/destroy lifecycle callbacks.
+ *
+ * - [Playground](https://react-components.wavemaker.ai/?path=/story/prefab-container--showcase)
+ *
+ * - [Docs](https://react-components.wavemaker.ai/?path=/story/prefab-container--docs#tab-overview)
+ *
+ * @param props - {@link WmPrefabContainerProps}
+ */
+export default WmPrefabContainer;

package/components/prefab/container/index.js

@@ -0,0 +1,71 @@
+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));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { removeInvalidAttributes } from "../../../utils/attr";
+let timeoutId = null;
+const WmPrefabContainer = (props) => {
+  const DEFAULT_CLASS = "app-prefab-container full-height";
+  const _a = props, { styles, onLoad, onDestroy, children, className } = _a, rest = __objRest(_a, ["styles", "onLoad", "onDestroy", "children", "className"]);
+  const loadedRef = useRef(false);
+  const ref = useRef(null);
+  useEffect(() => {
+    if (onLoad && !loadedRef.current) {
+      timeoutId = setTimeout(() => {
+        onLoad(new Event("load"), { ref: ref.current });
+      }, 1e3);
+      loadedRef.current = true;
+    }
+    return () => {
+      if (onDestroy) {
+        onDestroy(new Event("destroy"), { ref: ref.current });
+      }
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [onLoad, onDestroy]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    __spreadProps(__spreadValues({
+      style: styles
+    }, removeInvalidAttributes(rest)), {
+      ref,
+      className: className || DEFAULT_CLASS,
+      children
+    })
+  );
+};
+var container_default = WmPrefabContainer;
+export {
+  container_default as default
+};

package/components/prefab/container/props.d.ts

@@ -0,0 +1,23 @@
+import { BaseProps, Prettify } from "@wavemaker-ai/react-runtime/higherOrder/props";
+/** Callback when the prefab container is loaded. */
+type OnLoadCallback = (event: Event, context: {
+    ref: HTMLDivElement | null;
+}) => void;
+/** Callback when the prefab container is destroyed. */
+type OnDestroyCallback = (event: Event, context: {
+    ref: HTMLDivElement | null;
+}) => void;
+/**
+ * Props specific to the WmPrefabContainer component.
+ */
+export interface PrefabContainerProps {
+    /** Callback when the container is loaded. */
+    onLoad?: OnLoadCallback;
+    /** Callback when the container is destroyed. */
+    onDestroy?: OnDestroyCallback;
+}
+/**
+ * Combined props for the WmPrefabContainer component, including base WaveMaker props.
+ */
+export type WmPrefabContainerProps = Prettify<PrefabContainerProps & BaseProps>;
+export {};

package/components/prefab/index.d.ts

@@ -0,0 +1,12 @@
+import { WmPrefabProps } from "./props";
+declare const WmPrefab: (props: WmPrefabProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The WmPrefab component is a reusable widget container that loads prefab content.
+ *
+ * - [Playground](https://react-components.wavemaker.ai/?path=/story/prefab--showcase)
+ *
+ * - [Docs](https://react-components.wavemaker.ai/?path=/story/prefab--docs#tab-overview)
+ *
+ * @param props - {@link WmPrefabProps}
+ */
+export default WmPrefab;

package/components/prefab/index.js

@@ -0,0 +1,85 @@
+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));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import clsx from "clsx";
+import { removeInvalidAttributes } from "../../utils/attr";
+const WmPrefab = (props) => {
+  const _a = props, {
+    styles,
+    onLoad,
+    onDestroy,
+    onRender,
+    children,
+    show = true,
+    listener,
+    width,
+    height
+  } = _a, rest = __objRest(_a, [
+    "styles",
+    "onLoad",
+    "onDestroy",
+    "onRender",
+    "children",
+    "show",
+    "listener",
+    "width",
+    "height"
+  ]);
+  const loadedRef = useRef(false);
+  const ref = useRef(null);
+  useEffect(() => {
+    if (onLoad && !loadedRef.current) {
+      setTimeout(() => {
+        onLoad(new Event("load"), { ref: ref.current });
+      }, 1e3);
+      loadedRef.current = true;
+    }
+    return () => {
+      if (onDestroy) {
+        onDestroy(new Event("destroy"), { ref: ref.current });
+      }
+    };
+  }, [onLoad, onDestroy]);
+  return /* @__PURE__ */ jsx("div", { className: clsx(props.prefabname && `app-prefab-${props.prefabname.toLowerCase()}`), children: /* @__PURE__ */ jsx(
+    "div",
+    __spreadProps(__spreadValues({}, removeInvalidAttributes(rest, ["hidden"])), {
+      style: __spreadValues(__spreadValues(__spreadValues({}, styles), width !== void 0 && { width: parseFloat(width) }), height !== void 0 && { height: parseFloat(height) }),
+      ref,
+      children
+    })
+  ) });
+};
+var prefab_default = WmPrefab;
+export {
+  prefab_default as default
+};

package/components/prefab/props.d.ts

@@ -0,0 +1,19 @@
+import { BaseProps, Prettify } from "@wavemaker-ai/react-runtime/higherOrder/props";
+/**
+ * WmPrefab has no additional props beyond BaseProps.
+ * Combined props for the WmPrefab component.
+ */
+interface PrefabProps {
+    onLoad?: (event: React.SyntheticEvent, data: any) => void;
+    onDestroy?: (event: React.SyntheticEvent, data: any) => void;
+    onRender?: (event: React.SyntheticEvent, data: any) => void;
+    children?: React.ReactNode;
+    show?: boolean;
+    listener?: any;
+    width?: number | string;
+    height?: string;
+    styles?: React.CSSProperties;
+    prefabname?: string;
+}
+export type WmPrefabProps = Prettify<PrefabProps & BaseProps>;
+export {};

package/context/AppContext.d.ts

@@ -0,0 +1,11 @@
+import BaseAppProps from "@wavemaker-ai/react-runtime/higherOrder/BaseAppProps";
+interface AppProviderProps {
+    state: BaseAppProps;
+    proxy: any;
+}
+declare const AppContext: import("react").Context<AppProviderProps>;
+export declare const useAppContext: () => BaseAppProps;
+export declare const useAppProxy: () => any;
+export declare const useAppNotificationAction: () => any;
+export declare const useNotifyApp: () => any;
+export default AppContext;

package/context/AppContext.js

@@ -0,0 +1,43 @@
+import { createContext, useContext } from "react";
+import get from "lodash-es/get";
+const AppContext = createContext(void 0);
+const useAppContext = () => {
+  var _a;
+  const context = (_a = useContext(AppContext)) == null ? void 0 : _a.state;
+  if (context === void 0) {
+    throw new Error("useAppContext must be used within an AppProvider");
+  }
+  return context;
+};
+const useAppProxy = () => {
+  var _a;
+  const context = (_a = useContext(AppContext)) == null ? void 0 : _a.proxy;
+  if (context === void 0) {
+    throw new Error("useAppProxy must be used within an AppProvider");
+  }
+  return context;
+};
+const useAppNotificationAction = () => {
+  var _a;
+  const context = (_a = useContext(AppContext)) == null ? void 0 : _a.proxy;
+  if (context === void 0) {
+    throw new Error("useNotificationAction must be used within an AppProvider");
+  }
+  return get(context, "Actions.appNotification", null);
+};
+const useNotifyApp = () => {
+  var _a;
+  const context = (_a = useContext(AppContext)) == null ? void 0 : _a.proxy;
+  if (context === void 0) {
+    throw new Error("useNotifyApp must be used within an AppProvider");
+  }
+  return context.notifyApp;
+};
+var AppContext_default = AppContext;
+export {
+  AppContext_default as default,
+  useAppContext,
+  useAppNotificationAction,
+  useAppProxy,
+  useNotifyApp
+};

package/context/AppSpinnerProvider.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+export interface DisplayOptions {
+    content?: React.ReactNode;
+    message?: string;
+    spinner?: any;
+}
+export interface SpinnerService {
+    show: (message: string) => any;
+    hide: () => any;
+}
+declare const AppSpinnerProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AppSpinnerProvider;
+export declare const useAppSpinner: () => SpinnerService;

package/context/AppSpinnerProvider.js

@@ -0,0 +1,28 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { useContext, useState } from "react";
+import AppSpinner from "../components/common/app-spinner";
+const AppSpinnerContext = React.createContext(null);
+const AppSpinnerProvider = ({ children }) => {
+  const [spinnerShow, setSpinnerShow] = useState(false);
+  const [spinnerMessage, setSpinnerMessage] = useState("");
+  function show(message) {
+    setSpinnerShow(true);
+    setSpinnerMessage(message);
+  }
+  function hide() {
+    setSpinnerShow(false);
+    setSpinnerMessage("");
+  }
+  return /* @__PURE__ */ jsxs(AppSpinnerContext.Provider, { value: { show, hide }, children: [
+    /* @__PURE__ */ jsx(AppSpinner, { show: spinnerShow, message: spinnerMessage }),
+    children
+  ] });
+};
+var AppSpinnerProvider_default = AppSpinnerProvider;
+const useAppSpinner = () => {
+  return useContext(AppSpinnerContext);
+};
+export {
+  AppSpinnerProvider_default as default,
+  useAppSpinner
+};

package/context/LayoutProvider.d.ts

@@ -0,0 +1,7 @@
+export type LayoutProxyMap = Record<string, Record<string, unknown>>;
+export declare const LayoutContext: import("react").Context<any>;
+export declare const LayoutProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useLayout: () => any;
+export default LayoutProvider;

package/context/LayoutProvider.js

@@ -0,0 +1,63 @@
+"use client";
+var __defProp = Object.defineProperty;
+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;
+};
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useEffect, useCallback, useContext, useRef } from "react";
+import { useDebounceCallback } from "../hooks/useDebounce";
+import { EVENTEMITTER_METHODS } from "../core/constants/events";
+const LayoutContext = createContext(null);
+const LayoutProvider = ({ children }) => {
+  const [layout, setLayout] = useState({});
+  const layoutProxyRef = useRef({});
+  const batchRef = useRef({});
+  const flushBatch = useCallback(() => {
+    setLayout((prevLayout) => __spreadValues(__spreadValues({}, prevLayout), batchRef.current));
+    batchRef.current = {};
+  }, []);
+  const debounceBatchUpdate = useDebounceCallback(flushBatch, 100);
+  const batchUpdateLayout = useCallback(
+    (layoutName, layoutData) => {
+      batchRef.current[layoutName] = layoutData;
+      debounceBatchUpdate();
+    },
+    [debounceBatchUpdate]
+  );
+  useEffect(() => () => debounceBatchUpdate.cancel(), [debounceBatchUpdate]);
+  useEffect(() => {
+    const handleLayoutRefresh = (data) => {
+      var _a;
+      layoutProxyRef.current[data.layoutName] = (_a = data.proxy) != null ? _a : {};
+      batchUpdateLayout(data.layoutName, data.layout);
+    };
+    EVENTEMITTER_METHODS.LAYOUT_STATE_REFRESH_ON(handleLayoutRefresh);
+    return () => {
+      EVENTEMITTER_METHODS.LAYOUT_STATE_REFRESH_OFF(handleLayoutRefresh);
+    };
+  }, [batchUpdateLayout]);
+  return /* @__PURE__ */ jsx(LayoutContext.Provider, { value: { layout, proxy: layoutProxyRef.current }, children });
+};
+const useLayout = () => {
+  const context = useContext(LayoutContext);
+  return context != null ? context : {};
+};
+var LayoutProvider_default = LayoutProvider;
+export {
+  LayoutContext,
+  LayoutProvider,
+  LayoutProvider_default as default,
+  useLayout
+};

package/context/LocalizationProvider.d.ts

@@ -0,0 +1,4 @@
+declare const CustomLocalizationProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default CustomLocalizationProvider;

package/context/LocalizationProvider.js

@@ -0,0 +1,65 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { useAppSelector } from "../store";
+import moment from "moment-timezone";
+import { LocalizationProvider } from "@mui/x-date-pickers";
+import { AdapterMoment } from "@mui/x-date-pickers/AdapterMoment";
+const loadedLocales = /* @__PURE__ */ new Set(["en"]);
+const loadMomentLocale = (locale) => {
+  if (!locale || locale === "en") {
+    return true;
+  }
+  const normalizedLocale = locale.toLowerCase();
+  if (loadedLocales.has(normalizedLocale)) {
+    return true;
+  }
+  try {
+    require(`moment/locale/${normalizedLocale}.js`);
+    loadedLocales.add(normalizedLocale);
+    return true;
+  } catch (error) {
+    const baseLocale = normalizedLocale.split("-")[0];
+    if (baseLocale !== normalizedLocale && baseLocale !== "en" && !loadedLocales.has(baseLocale)) {
+      try {
+        require(`moment/locale/${baseLocale}.js`);
+        loadedLocales.add(baseLocale);
+        return true;
+      } catch (baseError) {
+        return false;
+      }
+    }
+    return false;
+  }
+};
+const CustomLocalizationProvider = ({ children }) => {
+  const selectedLocale = useAppSelector((state) => state.i18n.selectedLocale);
+  useEffect(() => {
+    if (!selectedLocale) {
+      return;
+    }
+    const localeLoadSuccess = loadMomentLocale(selectedLocale);
+    moment.locale(selectedLocale);
+    if (localeLoadSuccess) {
+      moment.updateLocale(selectedLocale, {
+        monthsShort: Array.from({ length: 12 }, (_, i) => moment().month(i).format("MMM")),
+        months: Array.from({ length: 12 }, (_, i) => moment().month(i).format("MMMM"))
+      });
+    }
+  }, [selectedLocale]);
+  return /* @__PURE__ */ jsx(
+    LocalizationProvider,
+    {
+      dateAdapter: AdapterMoment,
+      adapterLocale: selectedLocale,
+      localeText: {
+        calendarViewSwitchingButtonAriaLabel: (view) => view === "year" ? "year view is open, switch to calendar view" : "calendar view is open, switch to year view"
+      },
+      children
+    }
+  );
+};
+var LocalizationProvider_default = CustomLocalizationProvider;
+export {
+  LocalizationProvider_default as default
+};

package/context/PrefabContext.d.ts

@@ -0,0 +1,15 @@
+interface PrefabContextProps {
+    inbound: Record<string, any>;
+    outbound: Record<string, any>;
+    prefabName: string;
+    parentForm?: string;
+    isParentList: boolean;
+    formArrayIndex: number;
+    parentListName?: string;
+}
+export declare const PrefabContext: import("react").Context<PrefabContextProps>;
+declare const PrefabProvider: ({ value: Context, children, }: {
+    value: PrefabContextProps;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default PrefabProvider;