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

package/components/input/epoch/time/utils.js

@@ -0,0 +1,229 @@
+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 moment from "moment-timezone";
+function parseTimeFormat(timepattern = "hh:mm a") {
+  const hasSeconds = timepattern.toLowerCase().includes("s");
+  const is12Hour = timepattern.includes("h");
+  return {
+    format: timepattern,
+    hasSeconds,
+    is12Hour
+  };
+}
+function getSupportedTimeFormats() {
+  return [
+    "HH:mm:ss",
+    "HH:mm",
+    "H:mm:ss",
+    "H:mm",
+    "hh:mm:ss a",
+    "hh:mm a",
+    "h:mm:ss a",
+    "h:mm a",
+    "HH:mm:ss.SSS"
+  ];
+}
+function parseTimeValue(value, timepattern) {
+  if (!value) return null;
+  try {
+    if (value === "CURRENT_TIME") {
+      return moment();
+    }
+    if (typeof value === "number") {
+      return moment(value);
+    }
+    if (value instanceof Date) {
+      return moment(value);
+    }
+    if (typeof value === "string") {
+      let parsed = moment(value, timepattern, true);
+      if (parsed.isValid()) return parsed;
+      const formats = getSupportedTimeFormats();
+      for (const format of formats) {
+        parsed = moment(value, format, true);
+        if (parsed.isValid()) return parsed;
+      }
+      parsed = moment(value);
+      if (parsed.isValid()) return parsed;
+    }
+    return null;
+  } catch (error) {
+    console.warn("Error parsing time value:", error);
+    return null;
+  }
+}
+function formatDisplayTimeValue(value, pattern) {
+  if (!value) return "";
+  try {
+    const momentObj = moment.isMoment(value) ? value : moment(value);
+    if (pattern === "timestamp") {
+      return momentObj.valueOf().toString();
+    }
+    return momentObj.isValid() ? momentObj.format(pattern) : "";
+  } catch (error) {
+    console.warn("Error formatting display value:", error);
+    return "";
+  }
+}
+function getValidatorErrorMessage(validators, validatorType) {
+  if (!validators || validators.length === 0) return void 0;
+  const validator = validators.find(
+    (v) => typeof v === "object" && v !== null && "type" in v && v.type === validatorType
+  );
+  if (validator && typeof validator === "object" && "errorMessage" in validator) {
+    const errorMessage = validator.errorMessage;
+    if (typeof errorMessage === "string") {
+      return errorMessage;
+    }
+  }
+  return void 0;
+}
+function validateTimeRange(timeValue, minTime, maxTime, validators = [], validationmessage) {
+  if (!timeValue) return { isValid: true };
+  try {
+    const timeToCheck = moment.isMoment(timeValue) ? timeValue : moment(timeValue);
+    if (!timeToCheck.isValid()) {
+      return {
+        isValid: false,
+        errorType: "format",
+        message: validationmessage || "Invalid time format"
+      };
+    }
+    const timeToCheckMinutes = timeToCheck.hours() * 60 + timeToCheck.minutes();
+    if (minTime) {
+      const minMoment = typeof minTime === "string" ? moment(minTime, getSupportedTimeFormats(), true) : moment(minTime);
+      if (minMoment.isValid()) {
+        const minMinutes = minMoment.hours() * 60 + minMoment.minutes();
+        if (timeToCheckMinutes < minMinutes) {
+          const errorMessage = getValidatorErrorMessage(validators, "mintime") || validationmessage || `Time must be later than ${minMoment.format("HH:mm")}`;
+          return {
+            isValid: false,
+            errorType: "mintime",
+            message: errorMessage
+          };
+        }
+      }
+    }
+    if (maxTime) {
+      const maxMoment = typeof maxTime === "string" ? moment(maxTime, getSupportedTimeFormats(), true) : moment(maxTime);
+      if (maxMoment.isValid()) {
+        const maxMinutes = maxMoment.hours() * 60 + maxMoment.minutes();
+        if (timeToCheckMinutes > maxMinutes) {
+          const errorMessage = getValidatorErrorMessage(validators, "maxtime") || validationmessage || `Time must be earlier than ${maxMoment.format("HH:mm")}`;
+          return {
+            isValid: false,
+            errorType: "maxtime",
+            message: errorMessage
+          };
+        }
+      }
+    }
+    return { isValid: true };
+  } catch (error) {
+    console.warn("Error validating time range:", error);
+    return {
+      isValid: false,
+      errorType: "format",
+      message: validationmessage || "Validation error"
+    };
+  }
+}
+function validateTimeFormat(inputValue, pattern, required, validationmessage) {
+  if (!inputValue.trim()) return { isValid: true };
+  try {
+    const parsed = moment(inputValue, pattern, true);
+    if (!parsed.isValid()) {
+      const error = {
+        isValid: false,
+        errorType: "format"
+      };
+      if (required) {
+        error.message = validationmessage || `Invalid time format. Expected: ${pattern}`;
+      }
+      return error;
+    }
+    return { isValid: true };
+  } catch (error) {
+    return {
+      isValid: false,
+      errorType: "format",
+      message: validationmessage || "Invalid time format"
+    };
+  }
+}
+function parseTimeObj(timeValue) {
+  if (!timeValue) return null;
+  try {
+    return typeof timeValue === "string" ? moment(timeValue, getSupportedTimeFormats(), true).toDate() : timeValue instanceof Date ? timeValue : null;
+  } catch (error) {
+    console.warn("Error parsing time object:", error);
+    return null;
+  }
+}
+const DEFAULT_CLASS = "input-group app-timeinput";
+const DEFAULT_TIMEPATTERN = "h:mm:ss A";
+const DEFAULT_OUTPUT_FORMAT = "HH:mm:ss";
+const READONLY_STYLES = {
+  cursor: "not-allowed"
+};
+function updateListener(name, listener, props, displayValue, timestamp, datavalue) {
+  if (listener == null ? void 0 : listener.onChange) {
+    listener.onChange(props.fieldName || name, __spreadProps(__spreadValues({}, props), {
+      displayValue,
+      timestamp,
+      datavalue
+    }));
+  }
+}
+function createWidgetEvent(args) {
+  const { type, name, value, anchor, originalEvent } = args;
+  const base = originalEvent && typeof originalEvent === "object" ? __spreadValues({}, originalEvent) : {};
+  const evt = base;
+  if (!evt.type) {
+    evt.type = type;
+  }
+  if (!evt.target && anchor) {
+    evt.target = anchor;
+  }
+  if (!evt.currentTarget && anchor) {
+    evt.currentTarget = anchor;
+  }
+  if (name !== void 0) evt.name = name;
+  if (value !== void 0) evt.value = value;
+  if (originalEvent) {
+    evt.originalEvent = originalEvent;
+  }
+  return evt;
+}
+export {
+  DEFAULT_CLASS,
+  DEFAULT_OUTPUT_FORMAT,
+  DEFAULT_TIMEPATTERN,
+  READONLY_STYLES,
+  createWidgetEvent,
+  formatDisplayTimeValue,
+  getSupportedTimeFormats,
+  parseTimeFormat,
+  parseTimeObj,
+  parseTimeValue,
+  updateListener,
+  validateTimeFormat,
+  validateTimeRange
+};

package/components/input/fileupload/Utils.d.ts

@@ -0,0 +1,14 @@
+import { FileUploadState } from "./props";
+export declare const dialogService: {
+    showAppConfirmDialog: ({ title, message, onOk, onCancel }: any) => void;
+    closeAppConfirmDialog: () => void;
+};
+export declare const getDefaultChooseFilter: (allowedExtensions: string[]) => string;
+export declare const isValidFile: (filename: string, contenttype: string, extensionName: string) => boolean;
+export declare const getValidFiles: ($files: FileList | File[], contenttype: string, extensions: string, filetype: string, chooseFilter: string, maxfilesize: string | number, onError?: any, listener?: any) => {
+    validFiles: File[];
+    errorFiles: File[];
+};
+export declare const handleErrorFiles: (key: string, msg: string, file: File, errorFiles: File[], onError?: any, listener?: any) => void;
+export declare const clearFile: (files: (File & FileUploadState)[], file: FileUploadState | File) => (File & FileUploadState)[];
+export declare const generateFileId: () => string;

package/components/input/fileupload/Utils.js

@@ -0,0 +1,112 @@
+import { forEach } from "lodash-es";
+import {
+  fileUploadConstants,
+  isImageFile,
+  isAudioFile,
+  isVideoFile,
+  isDocumentFile,
+  getFileExtension
+} from "../../constants";
+const app = (listener) => ({
+  notifyApp: (message, type) => {
+    if (listener && listener.App && listener.App.notifyApp) {
+      listener.App.notifyApp(message, type);
+    }
+  }
+});
+const dialogService = {
+  showAppConfirmDialog: ({ title, message, onOk, onCancel }) => {
+    if (confirm(`${title}: ${message}`)) {
+      onOk();
+    } else {
+      onCancel();
+    }
+  },
+  closeAppConfirmDialog: () => {
+  }
+};
+const getDefaultChooseFilter = (allowedExtensions) => {
+  return allowedExtensions.includes("*/*") ? "" : allowedExtensions.join(" ");
+};
+const isValidFile = (filename, contenttype, extensionName) => {
+  if (!contenttype) {
+    return true;
+  }
+  const ext = extensionName.toLowerCase();
+  const contentTypes = contenttype.toLowerCase().split(/[\s,]+/).map((type) => type.trim()).filter(Boolean);
+  if (contentTypes.some((type) => type === `.${ext}` || type === ext)) {
+    return true;
+  }
+  for (const type of contentTypes) {
+    const normalizedType = type.startsWith(".") ? type.slice(1) : type;
+    if (type === "image/*" || normalizedType === "image") {
+      if (isImageFile(filename)) return true;
+    }
+    if (type === "audio/*" || normalizedType === "audio") {
+      if (isAudioFile(filename)) return true;
+    }
+    if (type === "video/*" || normalizedType === "video") {
+      if (isVideoFile(filename)) return true;
+    }
+    if (normalizedType === "document" || normalizedType === "pdf" || normalizedType === "doc") {
+      if (isDocumentFile(filename)) return true;
+    }
+  }
+  return false;
+};
+const getValidFiles = ($files, contenttype, extensions, filetype, chooseFilter, maxfilesize, onError, listener) => {
+  const validFiles = [];
+  const errorFiles = [];
+  const MAXFILEUPLOAD_SIZE = (typeof maxfilesize === "number" ? maxfilesize : parseFloat(maxfilesize || "10")) * fileUploadConstants.DEFAULT_VALUES.FILESIZE_MB;
+  const MAX_FILE_UPLOAD_FORMATTED_SIZE = (maxfilesize || "1") + "MB";
+  const currentChooseFilter = chooseFilter === fileUploadConstants.DEFAULT_CLASSES.DEVICE_CONTENTTYPES.FILES ? "" : contenttype || extensions || filetype || chooseFilter;
+  forEach($files, (file) => {
+    if (!isValidFile(file.name, currentChooseFilter, getFileExtension(file.name))) {
+      const msg = `Invalid file extension ${currentChooseFilter}`;
+      handleErrorFiles("INVALID_FILE_EXTENSION", msg, file, errorFiles, onError, listener);
+      return;
+    }
+    if (file.size > MAXFILEUPLOAD_SIZE) {
+      const msg = `File size exceeded limit. Max upload size is ${MAX_FILE_UPLOAD_FORMATTED_SIZE}`;
+      handleErrorFiles("INVALID_FILE_SIZE", msg, file, errorFiles, onError, listener);
+      return;
+    }
+    validFiles.push(file);
+  });
+  return { validFiles, errorFiles };
+};
+const handleErrorFiles = (key, msg, file, errorFiles, onError, listener) => {
+  if (!onError) {
+    app(listener).notifyApp(msg, "Error");
+  }
+  const error = {
+    key,
+    message: msg
+  };
+  onError == null ? void 0 : onError(event, listener, file);
+  file.error = error;
+  errorFiles.push(file);
+};
+const clearFile = (files, file) => {
+  return files.filter((fileObj) => {
+    var _a, _b;
+    const fileObjResponse = (_a = fileObj._response) == null ? void 0 : _a.fileName;
+    const fileResponse = (_b = file._response) == null ? void 0 : _b.fileName;
+    return fileObjResponse !== fileResponse || fileObj.name !== file.name || file !== fileObj;
+  });
+};
+const generateFileId = () => {
+  if (typeof window !== "undefined" && typeof crypto !== "undefined" && crypto.randomUUID) {
+    return "file-" + crypto.randomUUID();
+  }
+  return "file-" + Date.now().toString(36) + Math.random().toString(36).substr(2);
+};
+export {
+  clearFile,
+  dialogService,
+  generateFileId,
+  getDefaultChooseFilter,
+  getValidFiles,
+  handleErrorFiles,
+  isValidFile
+};

package/components/input/fileupload/components/ListItems.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { CommonFileProps, FileUploadState } from "../props";
+declare const CommonFile: React.FC<CommonFileProps>;
+export default CommonFile;
+export declare const ListItem: ({ file, index, clearSelectedFile, onBeforedelete, onFileDelete, cleariconclass, cleariconurl, cleariconhint, prefabName, }: {
+    file: FileUploadState & File;
+    index: number;
+    clearSelectedFile: (file: FileUploadState & File) => void;
+    onBeforedelete?: (e: React.MouseEvent, file: FileUploadState & File) => void;
+    onFileDelete: (e: React.MouseEvent, file: FileUploadState & File) => void;
+    cleariconclass?: string;
+    cleariconurl?: string;
+    cleariconhint?: string;
+    prefabName?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/components/input/fileupload/components/ListItems.js

@@ -0,0 +1,159 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import Box from "@mui/material/Box";
+import IconButton from "@mui/material/IconButton";
+import ListItemIcon from "@mui/material/ListItemIcon";
+import ListItemText from "@mui/material/ListItemText";
+import List from "@mui/material/List";
+import FolderIcon from "@mui/icons-material/Folder";
+import ClearIcon from "@mui/icons-material/Clear";
+import { getFileIconClass } from "../../../constants";
+import { WmAppIcon } from "../../../common/WmAppIcon";
+const CommonFile = ({
+  uploadedFiles,
+  selectedFolders,
+  filelistheight,
+  readonly,
+  clearSelectedFile,
+  onBeforedelete,
+  onFileDelete,
+  setSelectedFolders,
+  cleariconclass,
+  cleariconurl,
+  cleariconhint,
+  prefabName
+}) => {
+  const fileUploadComponents = [];
+  if (uploadedFiles.length > 0) {
+    fileUploadComponents.push(
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "file-list-container wm-fileupload-file-list-container",
+          style: {
+            "--fileupload-list-max-height": `${filelistheight || 400}px`
+          },
+          children: /* @__PURE__ */ jsx(List, { className: "list-group file-upload", dense: true, children: uploadedFiles.map((file, index) => /* @__PURE__ */ jsx(
+            ListItem,
+            {
+              file,
+              index,
+              clearSelectedFile,
+              onBeforedelete,
+              onFileDelete,
+              cleariconclass,
+              cleariconurl,
+              cleariconhint,
+              prefabName
+            },
+            file.uniqueId || `file-${index}`
+          )) })
+        },
+        "file-list"
+      )
+    );
+  }
+  if (selectedFolders.length > 0) {
+    fileUploadComponents.push(
+      /* @__PURE__ */ jsx(List, { dense: true, children: selectedFolders.map((folder, index) => /* @__PURE__ */ jsxs("li", { className: "file-upload-status error", children: [
+        /* @__PURE__ */ jsx(ListItemIcon, { children: /* @__PURE__ */ jsx(FolderIcon, {}) }),
+        /* @__PURE__ */ jsx(ListItemText, { primary: folder.name, secondary: "Folders cannot be uploaded" }),
+        /* @__PURE__ */ jsx(
+          IconButton,
+          {
+            onClick: () => setSelectedFolders((prev) => prev.filter((_, i) => i !== index)),
+            edge: "end",
+            "aria-label": "clear",
+            size: "small",
+            disabled: readonly,
+            children: /* @__PURE__ */ jsx(ClearIcon, { fontSize: "small" })
+          }
+        )
+      ] }, index)) }, "folder-list")
+    );
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: fileUploadComponents });
+};
+var ListItems_default = CommonFile;
+const ListItem = ({
+  file,
+  index,
+  clearSelectedFile,
+  onBeforedelete,
+  onFileDelete,
+  cleariconclass,
+  cleariconurl,
+  cleariconhint,
+  prefabName
+}) => {
+  return /* @__PURE__ */ jsx(
+    "li",
+    {
+      className: `file-upload-status list-group-item ${file.status || ""}`,
+      children: /* @__PURE__ */ jsxs(Box, { component: "div", className: "media upload-file-list wm-fileupload-media-full-width", children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `${getFileIconClass(file.storageName || file.name)} file-icon media-left media-middle`
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "media-body media-middle file-details", children: [
+          /* @__PURE__ */ jsxs("p", { className: "uploaddetails col-md-3", children: [
+            /* @__PURE__ */ jsx("span", { className: "upload-title", children: file.storageName || file.name }),
+            file.status === "success" && /* @__PURE__ */ jsx("span", { className: `status-icon text-success wi wi-check-circle` }),
+            /* @__PURE__ */ jsx("br", {}),
+            /* @__PURE__ */ jsxs("span", { className: "filesize", children: [
+              Math.round(
+                (file._response && file._response[0].length || file.size || 0) / 1024
+              ),
+              " ",
+              "KB"
+            ] }),
+            file.status === "error" && /* @__PURE__ */ jsx("span", { className: "status-icon status-icon text-danger wi wi-error" }),
+            file.status === "error" && /* @__PURE__ */ jsx("span", { className: "error-message", children: "Upload Failed" })
+          ] }),
+          file.status === "onProgress" && file.progress !== void 0 && file.progress >= 0 && /* @__PURE__ */ jsxs("div", { className: "col-md-1 upload-progress-percentage", children: [
+            file.progress || 0,
+            "%"
+          ] })
+        ] }),
+        (cleariconclass || cleariconurl) && file.status !== "onProgress" && /* @__PURE__ */ jsx("div", { className: "media-right media-middle", children: /* @__PURE__ */ jsx(
+          "a",
+          {
+            type: "button",
+            className: "btn btn-transparent btn-default status-icon",
+            title: cleariconhint,
+            onClick: () => {
+              clearSelectedFile(file);
+            },
+            children: /* @__PURE__ */ jsx(
+              WmAppIcon,
+              {
+                iconclass: cleariconclass,
+                iconurl: cleariconurl,
+                prefabName,
+                alt: "Clear"
+              }
+            )
+          }
+        ) }),
+        file.status == "success" && /* @__PURE__ */ jsx("div", { className: "media-right media-middle", children: /* @__PURE__ */ jsx(
+          "a",
+          {
+            type: "button",
+            className: "btn btn-transparent btn-default status-icon",
+            onClick: (e) => {
+              onBeforedelete == null ? void 0 : onBeforedelete(e, file);
+              onFileDelete(e, file);
+            },
+            children: /* @__PURE__ */ jsx("i", { className: "wi wi-delete" })
+          }
+        ) })
+      ] })
+    },
+    `file-${file.uniqueId || index}`
+  );
+};
+export {
+  ListItem,
+  ListItems_default as default
+};

package/components/input/fileupload/components/MultiUpload.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { MultipleFileUploadProps } from "../props";
+declare const MultipleFileUpload: React.FC<MultipleFileUploadProps>;
+export default MultipleFileUpload;

package/components/input/fileupload/components/MultiUpload.js

@@ -0,0 +1,92 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import Box from "@mui/material/Box";
+import { WmAppIcon } from "../../../common/WmAppIcon";
+const MultipleFileUpload = ({
+  fileInputRef,
+  multiple,
+  contenttype,
+  extensions,
+  filetype,
+  caption = "Upload",
+  chooseFilter,
+  disabled,
+  readonly,
+  required,
+  arialabel,
+  displayname,
+  tabindex,
+  iconclass,
+  iconurl,
+  prefabName,
+  fileuploadmessage,
+  highlightDropArea,
+  triggerFileSelect,
+  onFileSelect,
+  dragOverHandler,
+  onFileDrop,
+  setHighlightDropArea,
+  onBeforeselect,
+  styles
+}) => {
+  return /* @__PURE__ */ jsx("div", { className: "app-multi-file-upload", children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `drop-box ${highlightDropArea ? "highlight-drop-box" : ""}`,
+      id: "dropzone",
+      onClick: disabled || readonly ? void 0 : triggerFileSelect,
+      onDragOver: dragOverHandler,
+      onDrop: onFileDrop,
+      onDragLeave: () => setHighlightDropArea(false),
+      style: styles,
+      children: [
+        /* @__PURE__ */ jsx(
+          WmAppIcon,
+          {
+            iconclass,
+            iconurl,
+            prefabName,
+            alt: "Upload"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "message", children: [
+          /* @__PURE__ */ jsx("label", { className: "upload-label", htmlFor: "Upload", children: caption }),
+          /* @__PURE__ */ jsxs(Box, { component: "form", className: "form-horizontal", children: [
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                ref: fileInputRef,
+                type: "file",
+                name: "files",
+                multiple,
+                accept: chooseFilter,
+                disabled,
+                required,
+                "aria-label": arialabel || displayname || "File selection field",
+                onChange: onFileSelect,
+                className: "file-input wm-fileupload-file-input",
+                tabIndex: tabindex
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "a",
+              {
+                className: "app-anchor upload-label",
+                onClick: disabled || readonly ? void 0 : triggerFileSelect,
+                children: fileuploadmessage || "Drop your files here or click here to browse"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("label", { className: "upload-extensions", htmlFor: "extensions", children: [
+            chooseFilter || "All files",
+            " only",
+            " "
+          ] })
+        ] })
+      ]
+    }
+  ) });
+};
+var MultiUpload_default = MultipleFileUpload;
+export {
+  MultiUpload_default as default
+};

package/components/input/fileupload/components/SingleUpload.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { SingleFileUploadProps } from "../props";
+declare const SingleFileUpload: React.FC<SingleFileUploadProps>;
+export default SingleFileUpload;