@pisell/materials 3.0.62 → 6.0.2

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

@@ -0,0 +1,9 @@
+export declare const SUPPORTED_LANGUAGES: readonly ["original", "en", "zh-CN", "zh-HK"];
+export declare const DEFAULT_MAX_COUNT = 9;
+export declare const DEFAULT_UID = "-1";
+export declare const MEDIA_TYPES: {
+    readonly VIDEO: "video/";
+    readonly AUDIO: "audio/";
+};
+export declare const IMAGE_QUALITY = 0.8;
+export declare const IMAGE_TYPE = "image/jpeg";

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

@@ -0,0 +1,47 @@
+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/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_MAX_COUNT: () => DEFAULT_MAX_COUNT,
+  DEFAULT_UID: () => DEFAULT_UID,
+  IMAGE_QUALITY: () => IMAGE_QUALITY,
+  IMAGE_TYPE: () => IMAGE_TYPE,
+  MEDIA_TYPES: () => MEDIA_TYPES,
+  SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES
+});
+module.exports = __toCommonJS(constants_exports);
+var SUPPORTED_LANGUAGES = ["original", "en", "zh-CN", "zh-HK"];
+var DEFAULT_MAX_COUNT = 9;
+var DEFAULT_UID = "-1";
+var MEDIA_TYPES = {
+  VIDEO: "video/",
+  AUDIO: "audio/"
+};
+var IMAGE_QUALITY = 0.8;
+var IMAGE_TYPE = "image/jpeg";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MAX_COUNT,
+  DEFAULT_UID,
+  IMAGE_QUALITY,
+  IMAGE_TYPE,
+  MEDIA_TYPES,
+  SUPPORTED_LANGUAGES
+});

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

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const Upload: React.FC<import("./type").UploadProps & import("../../dataSourceForm/utils").WithModeProps & import("../../dataSourceForm/utils").WithFormItemProps>;
+export default Upload;

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

@@ -0,0 +1,38 @@
+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/Upload/index.tsx
+var Upload_exports = {};
+__export(Upload_exports, {
+  default: () => Upload_default
+});
+module.exports = __toCommonJS(Upload_exports);
+var import_utils = require("../../dataSourceForm/utils");
+var import_WithMode = __toESM(require("./WithMode"));
+var Upload = (0, import_utils.withFormItem)(import_WithMode.default);
+var Upload_default = Upload;

package/lib/components/dataSourceComponents/fields/Upload/index.less

@@ -0,0 +1,82 @@
+.pisell-lowcode-upload {
+  position: relative;
+}
+.pisell-upload-button {
+  border: 0;
+  background: none;
+  cursor: inherit;
+  color: #000;
+
+  .pisell-upload-text {
+    margin-top: 8px;
+  }
+
+  .pisell-upload-globe-icon {
+    position: absolute;
+    right: 6px;
+    bottom: 6px;
+    cursor: pointer;
+    color: #98A2B3;
+    font-size: 20px;
+    &:hover {
+      transition: color 0.3s;
+      color: var(--theme-color);
+    }
+  }
+  // &[disabled] {
+  //   opacity: 0.4;
+  // }
+}
+.pisell-data-source-upload {
+  .pisell-lowcode-upload-list-item-container {
+    .pisell-lowcode-upload-list-item-action {
+      &:hover {
+        background: none;
+      }
+    }
+  }
+}
+
+.pisell-upload-multilingual-container {
+  padding: 24px 0;
+
+  .pisell-upload-multilingual-item {
+    margin-bottom: 24px;
+    &-title {
+      font-size: 14px;
+      font-weight: 500;
+      color: #344054;
+      margin-bottom: 8px;
+    }
+
+    &-content {
+      .ant-upload-wrapper {
+        .ant-upload-list {
+          .ant-upload-list-item-container {
+            width: 100px;
+            height: 100px;
+          }
+        }
+        .ant-upload.ant-upload-select {
+          width: 100px;
+          height: 100px;
+        }
+      }
+    }
+  }
+}
+
+.pisell-upload-multilingual-icon {
+  color: #fff;
+  font-size: 16px;
+}
+
+.pisell-lowcode-image-preview-wrap {
+  z-index: 1201 !important;
+}
+.pisell-lowcode-image-preview-mask {
+  z-index: 1201 !important;
+}
+.pisell-lowcode-image-preview-operations-wrapper {
+  z-index: 1202!important;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * 获取nocobase媒体数据列表
+ */
+export declare const getMediaTypeList: () => Promise<any>;
+export interface MediaType {
+    id: number;
+    name: string;
+    maxsize: number;
+}
+export declare const useMediaConfig: () => {
+    data: any;
+};
+export declare const useMediaTypes: () => {
+    data: MediaType[];
+    getExtensionsByIds: (ids: number[]) => string[];
+    getMaxSizeByIds: (ids: number[]) => Record<number, number>;
+};

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

@@ -0,0 +1,96 @@
+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/serve.ts
+var serve_exports = {};
+__export(serve_exports, {
+  getMediaTypeList: () => getMediaTypeList,
+  useMediaConfig: () => useMediaConfig,
+  useMediaTypes: () => useMediaTypes
+});
+module.exports = __toCommonJS(serve_exports);
+var import_ahooks = require("ahooks");
+var import_utils = require("./utils");
+var import_utils2 = require("../../../table/utils");
+var getMediaTypeList = async () => {
+  const { data } = await import_utils2.request.getRequest().get(
+    `/media_type:list`,
+    {},
+    {
+      isNocobase: true,
+      fullResult: true,
+      headers: {
+        "x-data-source": "pisell2"
+      }
+    }
+  );
+  return data;
+};
+var getMediaConfig = async () => {
+  const data = await import_utils2.request.getRequest().get(`/core/module/media/config`, {});
+  return data;
+};
+var useMediaConfig = () => {
+  const { data } = (0, import_ahooks.useRequest)(getMediaConfig, {
+    cacheKey: "media-config",
+    staleTime: 1e3 * 60 * 5,
+    // 5分钟后数据过期
+    cacheTime: 1e3 * 60 * 60
+    // 1小时后清除缓存
+  });
+  return { data };
+};
+var useMediaTypes = () => {
+  const { data } = (0, import_ahooks.useRequest)(getMediaTypeList, {
+    cacheKey: "media-type",
+    staleTime: 1e3 * 60 * 5,
+    // 5分钟后数据过期
+    cacheTime: 1e3 * 60 * 60
+    // 1小时后清除缓存
+  });
+  const getExtensionsByIds = (ids) => {
+    const extensions = [];
+    (data || []).forEach((item) => {
+      if (ids == null ? void 0 : ids.includes(item.id)) {
+        extensions.push(
+          ...(item.extensions || []).map((item2) => (0, import_utils.getPointSuffix)(item2))
+        );
+      }
+    });
+    return extensions;
+  };
+  const getMaxSizeByIds = (ids) => {
+    const maxSizeMap = {};
+    (data || []).forEach((item) => {
+      if (ids == null ? void 0 : ids.includes(item.id)) {
+        item.extensions.forEach((extension) => {
+          const key = (0, import_utils.getPointSuffix)(extension);
+          maxSizeMap[key] = item.maxsize;
+        });
+      }
+    });
+    return maxSizeMap;
+  };
+  return { data, getExtensionsByIds, getMaxSizeByIds };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMediaTypeList,
+  useMediaConfig,
+  useMediaTypes
+});

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

@@ -0,0 +1,27 @@
+import { UploadFile as AntdUploadFile } from 'antd/es/upload/interface';
+import type { UploadValue, UploadChangeHandler } from './types';
+export interface UploadFile extends AntdUploadFile {
+    metadata?: {
+        width?: number;
+        height?: number;
+        duration?: number;
+        bitrate?: number;
+    };
+}
+export interface UploadProps {
+    renderMode?: string;
+    maxSize?: number;
+    minCount?: number;
+    maxCount?: number;
+    multiple?: boolean;
+    presetType?: string[];
+    customType?: string[];
+    enablePresetType?: boolean;
+    enableCustomType?: boolean;
+    allowPreview?: boolean;
+    value?: UploadValue;
+    typeMaxSizeMap?: Record<string, number>;
+    enableMultilingual?: boolean;
+    onChange?: UploadChangeHandler;
+    disabled?: boolean;
+}

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/{productCard → dataSourceComponents/fields/Upload}/types.js

@@ -12,6 +12,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/components/productCard/types.ts
+// 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,16 @@
+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>;

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

@@ -0,0 +1,253 @@
+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,
+  getDefaultFileList: () => getDefaultFileList,
+  getFileMetadataParams: () => getFileMetadataParams,
+  getFileName: () => getFileName,
+  getFileType: () => getFileType,
+  getMediaMetadata: () => getMediaMetadata,
+  getPointSuffix: () => getPointSuffix,
+  getSuffix: () => getSuffix
+});
+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) => {
+    const video = document.createElement("video");
+    const canvas = document.createElement("canvas");
+    video.preload = "metadata";
+    let hasMetadata = false;
+    let hasSeeked = false;
+    const tryResolve = () => {
+      if (!hasMetadata || !hasSeeked)
+        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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkFileCount,
+  createMultilingualData,
+  createMultilingualFileList,
+  genFileListByString,
+  generateUid,
+  getDefaultFileList,
+  getFileMetadataParams,
+  getFileName,
+  getFileType,
+  getMediaMetadata,
+  getPointSuffix,
+  getSuffix
+});