@pisell/materials 2.2.48 → 2.2.49

package/lib/components/dataSourceComponents/fields/Upload/type.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/fields/Upload/type.ts
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);

package/lib/components/dataSourceComponents/fields/Upload/types.d.ts

@@ -0,0 +1,48 @@
+import type { UploadFile } from 'antd/es/upload/interface';
+import { SUPPORTED_LANGUAGES } from './constants';
+export declare type Language = typeof SUPPORTED_LANGUAGES[number];
+export interface MediaMetadata {
+    width?: number;
+    height?: number;
+    duration?: number;
+    bitrate?: number;
+    cover?: File;
+}
+export interface FileCountValidation {
+    multiple: boolean;
+    minCount: number;
+    maxCount: number;
+    valueLength: number;
+}
+export interface ValidationResult {
+    success: boolean;
+    message?: string;
+}
+export interface MultilingualFile extends UploadFile {
+    multilingual?: SingleMultilingualValue;
+    multilingualFileList?: Record<Language, UploadFile[]>;
+    response?: {
+        status: boolean;
+        data: {
+            url: string;
+        };
+    };
+}
+export interface FileListOptions {
+    enableMultilingual: boolean;
+    multiple: boolean;
+}
+export declare type SingleUploadValue = string;
+export declare type MultipleUploadValue = string[];
+export declare type SingleMultilingualValue = Record<Language, string>;
+export declare type MultipleMultilingualValue = SingleMultilingualValue[];
+export declare type UploadValue = SingleUploadValue | MultipleUploadValue | SingleMultilingualValue | MultipleMultilingualValue;
+export interface MultilingualUploadResponse {
+    status: boolean;
+    data: {
+        url: string;
+    };
+}
+export declare type UploadChangeHandler = (value: UploadValue) => void;
+export declare type NonNullMultilingualValue = NonNullable<SingleMultilingualValue>;
+export declare type NonNullMultilingualArray = NonNullMultilingualValue[];

package/lib/components/dataSourceComponents/fields/Upload/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/fields/Upload/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/components/dataSourceComponents/fields/Upload/utils.d.ts

@@ -0,0 +1,18 @@
+import { RcFile, UploadFile } from 'antd/es/upload/interface';
+import type { MediaMetadata, FileCountValidation, ValidationResult, MultilingualFile, FileListOptions, UploadValue, SingleMultilingualValue } from './types';
+export declare const generateUid: () => string;
+export declare const getSuffix: (name: string) => string;
+export declare const getPointSuffix: (name: string) => string;
+export declare const getFileType: (name: string) => string;
+export declare const getFileName: (url: string) => string;
+export declare const checkFileCount: ({ multiple, minCount, maxCount, valueLength, }: FileCountValidation) => ValidationResult;
+export declare const getMediaMetadata: (file: RcFile) => Promise<MediaMetadata | null>;
+export declare const genFileListByString: (value: string) => UploadFile[];
+export declare const createMultilingualData: (value: string) => SingleMultilingualValue;
+export declare const createMultilingualFileList: (value: string) => Record<string, UploadFile<any>[]>;
+export declare const getDefaultFileList: (value: UploadValue | undefined, options: FileListOptions) => MultilingualFile[];
+export declare const getFileMetadataParams: (file: RcFile & {
+    metadata?: MediaMetadata;
+}) => Record<string, any>;
+export declare const isValueEqual: (value: any, fileListValue: any) => boolean;
+export declare const getBaseTime: (size: number) => 2000 | 1000 | 4000 | 8000;

package/lib/components/dataSourceComponents/fields/Upload/utils.js

@@ -0,0 +1,292 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/fields/Upload/utils.tsx
+var utils_exports = {};
+__export(utils_exports, {
+  checkFileCount: () => checkFileCount,
+  createMultilingualData: () => createMultilingualData,
+  createMultilingualFileList: () => createMultilingualFileList,
+  genFileListByString: () => genFileListByString,
+  generateUid: () => generateUid,
+  getBaseTime: () => getBaseTime,
+  getDefaultFileList: () => getDefaultFileList,
+  getFileMetadataParams: () => getFileMetadataParams,
+  getFileName: () => getFileName,
+  getFileType: () => getFileType,
+  getMediaMetadata: () => getMediaMetadata,
+  getPointSuffix: () => getPointSuffix,
+  getSuffix: () => getSuffix,
+  isValueEqual: () => isValueEqual
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("@pisell/utils");
+var import_locales = require("../../../../locales");
+var import_constants = require("./constants");
+var generateUid = () => {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+};
+var getSuffix = (name) => name.split(".").pop() || "";
+var getPointSuffix = (name) => `.${getSuffix(name)}`;
+var getFileType = (name) => getPointSuffix(getSuffix(name));
+var getFileName = (url) => {
+  const parts = url.split("/");
+  return parts[parts.length - 1] || "";
+};
+var checkFileCount = ({
+  multiple,
+  minCount,
+  maxCount,
+  valueLength
+}) => {
+  if (!multiple)
+    return { success: true };
+  if (minCount === maxCount && valueLength !== minCount) {
+    return {
+      success: false,
+      message: (0, import_locales.getText)("pisell-upload-count-error")(minCount)
+    };
+  }
+  if (minCount !== maxCount && (valueLength < minCount || valueLength > maxCount)) {
+    return {
+      success: false,
+      message: (0, import_locales.getText)("pisell-upload-count-error")(`${minCount}-${maxCount}`)
+    };
+  }
+  return { success: true };
+};
+var createVideoMetadata = async (file) => {
+  return new Promise((resolve, reject) => {
+    const video = document.createElement("video");
+    const canvas = document.createElement("canvas");
+    video.preload = "metadata";
+    let hasMetadata = false;
+    let hasSeeked = false;
+    const tryResolve = () => {
+      if (!hasMetadata || !hasSeeked) {
+        reject();
+        console.log("没有元数据或没有seeked");
+        return;
+      }
+      ;
+      canvas.width = video.videoWidth;
+      canvas.height = video.videoHeight;
+      const ctx = canvas.getContext("2d");
+      ctx == null ? void 0 : ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob(
+        (blob) => {
+          const metadata = {
+            width: video.videoWidth,
+            height: video.videoHeight,
+            duration: video.duration,
+            bitrate: file.size / video.duration
+          };
+          if (blob) {
+            metadata.cover = new File([blob], `${file.name}-cover.jpg`, {
+              type: import_constants.IMAGE_TYPE
+            });
+          }
+          URL.revokeObjectURL(video.src);
+          resolve(metadata);
+        },
+        import_constants.IMAGE_TYPE,
+        import_constants.IMAGE_QUALITY
+      );
+    };
+    video.onloadedmetadata = () => {
+      hasMetadata = true;
+      tryResolve();
+    };
+    video.onseeked = () => {
+      hasSeeked = true;
+      tryResolve();
+    };
+    video.src = URL.createObjectURL(file);
+  });
+};
+var createAudioMetadata = async (file) => {
+  return new Promise((resolve) => {
+    const audio = document.createElement("audio");
+    audio.preload = "metadata";
+    audio.src = URL.createObjectURL(file);
+    audio.onloadedmetadata = () => {
+      URL.revokeObjectURL(audio.src);
+      resolve({
+        duration: audio.duration,
+        bitrate: file.size / audio.duration
+      });
+    };
+  });
+};
+var getMediaMetadata = async (file) => {
+  if (file.type.startsWith(import_constants.MEDIA_TYPES.VIDEO)) {
+    return createVideoMetadata(file);
+  }
+  if (file.type.startsWith(import_constants.MEDIA_TYPES.AUDIO)) {
+    return createAudioMetadata(file);
+  }
+  return null;
+};
+var genFileListByString = (value) => {
+  if (!value)
+    return [];
+  return [{
+    uid: generateUid(),
+    name: getFileName(value),
+    status: "done",
+    url: value
+  }];
+};
+var createMultilingualData = (value) => {
+  return import_constants.SUPPORTED_LANGUAGES.reduce((acc, lang) => {
+    acc[lang] = value;
+    return acc;
+  }, {});
+};
+var createMultilingualFileList = (value) => {
+  return import_constants.SUPPORTED_LANGUAGES.reduce((acc, lang) => {
+    acc[lang] = genFileListByString(value);
+    return acc;
+  }, {});
+};
+var handleMultilingualSingleFile = (value, index = 1) => ({
+  uid: `-${index}`,
+  name: getFileName(value),
+  status: "done",
+  url: value,
+  multilingualFileList: createMultilingualFileList(value),
+  multilingual: createMultilingualData(value)
+});
+var handleMultilingualObject = (value, index = 1) => {
+  const defaultUrl = value.original || value.en || value["zh-CN"] || value["zh-HK"];
+  return {
+    uid: `-${index}`,
+    name: getFileName(defaultUrl),
+    status: "done",
+    url: defaultUrl,
+    multilingual: value,
+    multilingualFileList: import_constants.SUPPORTED_LANGUAGES.reduce((acc, lang) => {
+      acc[lang] = genFileListByString(value[lang]);
+      return acc;
+    }, {})
+  };
+};
+var getDefaultFileList = (value, options) => {
+  if (!value)
+    return [];
+  if (Object.values(value).filter((item) => !!item).length === 0)
+    return [];
+  const { enableMultilingual, multiple } = options;
+  if (enableMultilingual) {
+    if ((0, import_utils.isString)(value)) {
+      return [handleMultilingualSingleFile(value)];
+    }
+    if (Array.isArray(value)) {
+      return value.map((item, index) => {
+        if ((0, import_utils.isString)(item)) {
+          return handleMultilingualSingleFile(item, index);
+        }
+        if ((0, import_utils.isPlainObject)(item)) {
+          return handleMultilingualObject(item, index);
+        }
+        return [];
+      }).flat();
+    }
+    if ((0, import_utils.isPlainObject)(value)) {
+      return [handleMultilingualObject(value)];
+    }
+  }
+  if (multiple && Array.isArray(value)) {
+    return value.map((url, index) => ({
+      uid: `-${index}`,
+      name: getFileName(url),
+      status: "done",
+      url
+    }));
+  }
+  if ((0, import_utils.isString)(value)) {
+    return [{
+      uid: import_constants.DEFAULT_UID,
+      name: getFileName(value),
+      status: "done",
+      url: value
+    }];
+  }
+  return [];
+};
+var getFileMetadataParams = (file) => {
+  if (!file.metadata)
+    return {};
+  const metadataParams = {};
+  const metadataKeys = ["width", "height", "duration", "bitrate"];
+  metadataKeys.forEach((key) => {
+    var _a;
+    if (((_a = file.metadata) == null ? void 0 : _a[key]) !== void 0) {
+      metadataParams[`metadata[${key}]`] = file.metadata[key];
+    }
+  });
+  return metadataParams;
+};
+var isValueEqual = (value, fileListValue) => {
+  if (!value && !fileListValue)
+    return true;
+  if (!value || !fileListValue)
+    return false;
+  if (Array.isArray(value) && Array.isArray(fileListValue)) {
+    if (value.length !== fileListValue.length)
+      return false;
+    return value.every((v, i) => {
+      if (typeof v === "object") {
+        return JSON.stringify(v) === JSON.stringify(fileListValue[i]);
+      }
+      return v === fileListValue[i];
+    });
+  }
+  if (typeof value === "object" && typeof fileListValue === "object") {
+    return JSON.stringify(value) === JSON.stringify(fileListValue);
+  }
+  return value === fileListValue;
+};
+var getBaseTime = (size) => {
+  const KB = 1024;
+  const MB = KB * 1024;
+  if (size < MB)
+    return 1e3;
+  if (size < 5 * MB)
+    return 2e3;
+  if (size < 20 * MB)
+    return 4e3;
+  return 8e3;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkFileCount,
+  createMultilingualData,
+  createMultilingualFileList,
+  genFileListByString,
+  generateUid,
+  getBaseTime,
+  getDefaultFileList,
+  getFileMetadataParams,
+  getFileName,
+  getFileType,
+  getMediaMetadata,
+  getPointSuffix,
+  getSuffix,
+  isValueEqual
+});

package/lib/components/dataSourceComponents/fields/index.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="react" />
+declare const formFieldMap: {
+    FormItemCheckbox: import("react").FC<{}> & {
+        Group: import("react").FC<import("./Checkbox/type").CheckboxGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+    } & {
+        Group: import("react").FC<import("./Checkbox/type").CheckboxGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+    };
+    FormItemColorPicker: import("react").FC<import("./ColorPicker/type").ColorPickerProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    FormItemDatePicker: import("react").FC<(import("antd").DatePickerProps & import("../dataSourceForm/utils").WithModeProps) & import("../dataSourceForm/utils").WithFormItemProps>;
+    FormItemInput: import("react").FC<import("./Input/type").InputProps> & {
+        JSON: import("react").FC<any>;
+        Password: import("react").FC<import("antd/es/input").PasswordProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+        TextArea: import("react").FC<import("antd/es/input").TextAreaProps & import("react").RefAttributes<import("antd/es/input/TextArea").TextAreaRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+        URL: import("react").FC<import("antd").InputProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+        Email: import("react").FC<import("antd").InputProps & {
+            onChange: (value: string) => void;
+        } & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+        Phone: import("react").FC<import("./Input.Phone/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+        Mobile: import("react").FC<import("./Input.Mobile/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+        Subdomain: import("react").FC<import("antd").InputProps & {
+            onChange: (value: string) => void;
+            onBlur?: ((e: import("react").FocusEvent<HTMLInputElement, Element>) => void) | undefined;
+            rootDomain: "custom" | "saas" | "xzero";
+            customDomain?: string | undefined;
+            value?: string | undefined;
+            tenantId: string;
+            name?: string | undefined;
+            fieldKey?: string | undefined;
+        } & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    };
+    FormItemRadio: import("react").FC<{}> & {
+        Group: import("react").FC<import("./Radio/type").RadioGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+    } & {
+        Group: import("react").FC<import("./Radio/type").RadioGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+    };
+    FormItemSelect: (props: import("antd").SelectProps<any, import("antd/es/select").DefaultOptionType> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps & {
+        options?: any;
+        optionSourceType?: "default" | "custom" | "api" | undefined;
+        labelField: string;
+        valueField: string;
+        extraParams?: Record<string, any> | undefined;
+    } & {
+        dataSource?: any;
+    }) => JSX.Element;
+    FormItemInputNumber: import("react").FC<any>;
+    FormItemPercent: import("react").FC<any>;
+    FormItemTimePicker: import("react").FC<import("./TimePicker/type").TimePickerProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    'FormItemInput.JSON': import("react").FC<any>;
+    'FormItemInput.Phone': import("react").FC<import("./Input.Phone/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    'FormItemInput.Mobile': import("react").FC<import("./Input.Mobile/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    'FormItemInput.Email': import("react").FC<import("antd").InputProps & {
+        onChange: (value: string) => void;
+    } & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    'FormItemInput.URL': import("react").FC<import("antd").InputProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    'FormItemInput.Password': import("react").FC<import("antd/es/input").PasswordProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    'FormItemRadio.Group': import("react").FC<import("./Radio/type").RadioGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+    'FormItemCheckbox.Group': import("react").FC<import("./Checkbox/type").CheckboxGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+    FormItemDateRangePicker: import("react").FC<import("./DateRangePicker/type").DateRangePickerProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    FormItemUpload: import("react").FC<import("./Upload/type").UploadProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    FormItemTranslation: import("react").FC<import("./Translation/type").TranslationProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    FormItemIconSelect: import("react").FC<import("./IconSelect/type").IconSelectProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+};
+declare const getFieldComponent: (fieldComponent: string) => import("react").FC<any> | import("react").FC<import("./Checkbox/type").CheckboxGroupProps & import("../dataSourceForm/utils").WithModeProps> | (import("react").FC<{}> & {
+    Group: import("react").FC<import("./Checkbox/type").CheckboxGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+} & {
+    Group: import("react").FC<import("./Checkbox/type").CheckboxGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+}) | import("react").FC<import("./ColorPicker/type").ColorPickerProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<(import("antd").DatePickerProps & import("../dataSourceForm/utils").WithModeProps) & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("antd/es/input").PasswordProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("antd").InputProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("antd").InputProps & {
+    onChange: (value: string) => void;
+} & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("./Input.Phone/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("./Input.Mobile/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | (import("react").FC<import("./Input/type").InputProps> & {
+    JSON: import("react").FC<any>;
+    Password: import("react").FC<import("antd/es/input").PasswordProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    TextArea: import("react").FC<import("antd/es/input").TextAreaProps & import("react").RefAttributes<import("antd/es/input/TextArea").TextAreaRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    URL: import("react").FC<import("antd").InputProps & import("react").RefAttributes<import("antd").InputRef> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    Email: import("react").FC<import("antd").InputProps & {
+        onChange: (value: string) => void;
+    } & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    Phone: import("react").FC<import("./Input.Phone/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    Mobile: import("react").FC<import("./Input.Mobile/WithMode").PhoneInputProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+    Subdomain: import("react").FC<import("antd").InputProps & {
+        onChange: (value: string) => void;
+        onBlur?: ((e: import("react").FocusEvent<HTMLInputElement, Element>) => void) | undefined;
+        rootDomain: "custom" | "saas" | "xzero";
+        customDomain?: string | undefined;
+        value?: string | undefined;
+        tenantId: string;
+        name?: string | undefined;
+        fieldKey?: string | undefined;
+    } & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+}) | import("react").FC<import("./Radio/type").RadioGroupProps & import("../dataSourceForm/utils").WithModeProps> | (import("react").FC<{}> & {
+    Group: import("react").FC<import("./Radio/type").RadioGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+} & {
+    Group: import("react").FC<import("./Radio/type").RadioGroupProps & import("../dataSourceForm/utils").WithModeProps>;
+}) | ((props: import("antd").SelectProps<any, import("antd/es/select").DefaultOptionType> & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps & {
+    options?: any;
+    optionSourceType?: "default" | "custom" | "api" | undefined;
+    labelField: string;
+    valueField: string;
+    extraParams?: Record<string, any> | undefined;
+} & {
+    dataSource?: any;
+}) => JSX.Element) | import("react").FC<import("./TimePicker/type").TimePickerProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("./DateRangePicker/type").DateRangePickerProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("./Upload/type").UploadProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("./Translation/type").TranslationProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps> | import("react").FC<import("./IconSelect/type").IconSelectProps & import("../dataSourceForm/utils").WithModeProps & import("../dataSourceForm/utils").WithFormItemProps>;
+export { getFieldComponent, formFieldMap };

package/lib/components/dataSourceComponents/fields/index.js

@@ -0,0 +1,78 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/fields/index.ts
+var fields_exports = {};
+__export(fields_exports, {
+  formFieldMap: () => formFieldMap,
+  getFieldComponent: () => getFieldComponent
+});
+module.exports = __toCommonJS(fields_exports);
+var import_Checkbox = __toESM(require("./Checkbox"));
+var import_ColorPicker = __toESM(require("./ColorPicker"));
+var import_DatePicker = __toESM(require("./DatePicker"));
+var import_Input = __toESM(require("./Input"));
+var import_Radio = __toESM(require("./Radio"));
+var import_Select = __toESM(require("./Select"));
+var import_InputNumber = __toESM(require("./InputNumber"));
+var import_TimePicker = __toESM(require("./TimePicker"));
+var import_DateRangePicker = __toESM(require("./DateRangePicker"));
+var import_Upload = __toESM(require("./Upload"));
+var import_Translation = __toESM(require("./Translation"));
+var import_IconSelect = __toESM(require("./IconSelect"));
+var formFieldMap = {
+  FormItemCheckbox: import_Checkbox.default,
+  FormItemColorPicker: import_ColorPicker.default,
+  FormItemDatePicker: import_DatePicker.default,
+  FormItemInput: import_Input.default,
+  FormItemRadio: import_Radio.default,
+  FormItemSelect: import_Select.default,
+  FormItemInputNumber: import_InputNumber.default,
+  FormItemPercent: import_InputNumber.default,
+  FormItemTimePicker: import_TimePicker.default,
+  "FormItemInput.JSON": import_Input.default.JSON,
+  "FormItemInput.Phone": import_Input.default.Phone,
+  "FormItemInput.Mobile": import_Input.default.Mobile,
+  "FormItemInput.Email": import_Input.default.Email,
+  "FormItemInput.URL": import_Input.default.URL,
+  "FormItemInput.Password": import_Input.default.Password,
+  "FormItemRadio.Group": import_Radio.default.Group,
+  "FormItemCheckbox.Group": import_Checkbox.default.Group,
+  FormItemDateRangePicker: import_DateRangePicker.default,
+  FormItemUpload: import_Upload.default,
+  FormItemTranslation: import_Translation.default,
+  FormItemIconSelect: import_IconSelect.default
+};
+var getFieldComponent = (fieldComponent) => {
+  return formFieldMap[fieldComponent];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formFieldMap,
+  getFieldComponent
+});

package/lib/components/dataSourceComponents/fields/type.d.ts

@@ -0,0 +1,19 @@
+import { Field } from '../provider/dataSource/DataSourceContext';
+import { formFieldMap } from './index';
+export declare type FormFieldComponentType = keyof typeof formFieldMap;
+export declare type FilterFunctionReturnType = {
+    $eq?: any;
+    $includes?: string;
+    $in?: (string | number)[];
+    $anyOf?: (string | number)[];
+    $isTruly?: boolean;
+    $isFalsy?: boolean;
+    $dateAfter?: string;
+    $dateBefore?: string;
+    $and?: Array<{
+        $dateAfter?: string;
+        $dateBefore?: string;
+    }>;
+};
+export declare type FilterFunction = (value: any, field: Field) => FilterFunctionReturnType | null;
+export declare type FormFieldFilterFuncMapType = Record<FormFieldComponentType, FilterFunction>;

package/lib/components/dataSourceComponents/fields/type.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/fields/type.ts
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);

package/lib/components/dataSourceComponents/fields/utils.d.ts

@@ -0,0 +1,3 @@
+import { FormFieldFilterFuncMapType } from './type';
+declare const formFieldFilterFuncMap: FormFieldFilterFuncMapType;
+export { formFieldFilterFuncMap };