component-shipinlv 2.0.18 → 2.1.1

package/dist/lib/file-type.js

@@ -0,0 +1,156 @@
+var MineTypes = {
+  'image/bmp': 'bmp',
+  'audio/vnd.dolby.dd-raw': 'ac3',
+  'application/x-apple-diskimage': 'dmg',
+  'application/x-msdownload': 'exe',
+  'application/eps': 'eps',
+  'application/postscript': 'ps',
+  'application/x-compress': 'Z',
+  'image/jpeg': 'jpg',
+  'image/vnd.ms-photo': 'jxr',
+  'application/gzip': 'gz',
+  'application/x-bzip2': 'bz2',
+  'audio/mpeg': 'mp3',
+  'audio/x-musepack': 'mpc',
+  'application/x-shockwave-flash': 'swf',
+  'image/gif': 'gif',
+  'image/flif': 'flif',
+  'image/webp': 'webp',
+  'audio/aiff': 'aif',
+  'image/icns': 'icns',
+  'application/x-xpinstall': 'xpi',
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+  'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'pptx',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+  'model/3mf': '3mf',
+  'application/epub+zip': 'epub',
+  'application/vnd.oasis.opendocument.text': 'odt',
+  'application/vnd.oasis.opendocument.spreadsheet': 'ods',
+  'application/vnd.oasis.opendocument.presentation': 'odp',
+  'application/zip': 'zip',
+  'audio/opus': 'opus',
+  'audio/ogg': 'ogg',
+  'application/ogg': 'ogx',
+  'image/avif': 'avif',
+  'image/heif': 'heic',
+  'image/heif-sequence': 'heic',
+  'image/heic': 'heic',
+  'image/heic-sequence': 'heic',
+  'video/quicktime': 'mov',
+  'video/x-m4v': 'm4v',
+  'audio/mp4': 'm4b',
+  'audio/x-m4a': 'm4a',
+  'image/x-canon-cr3': 'cr3',
+  'video/3gpp2': '3g2',
+  'video/3gpp': '3gp',
+  'video/mp4': 'mp4',
+  'audio/midi': 'mid',
+  'font/woff': 'woff',
+  'font/woff2': 'woff2',
+  'application/vnd.tcpdump.pcap': 'pcap',
+  'audio/x-dsf': 'dsf',
+  'application/x-lzip': 'lz',
+  'audio/x-flac': 'flac',
+  'image/bpg': 'bpg',
+  'audio/wavpack': 'wv',
+  'application/pdf': 'pdf',
+  'application/wasm': 'wasm',
+  'audio/ape': 'ape',
+  'video/webm': 'webm',
+  'video/x-matroska': 'mkv',
+  'video/vnd.avi': 'avi',
+  'audio/vnd.wave': 'wav',
+  'audio/qcelp': 'qcp',
+  'application/x-sqlite3': 'sqlite',
+  'application/x-nintendo-nes-rom': 'nes',
+  'application/x-google-chrome-extension': 'crx',
+  'application/vnd.ms-cab-compressed': 'cab',
+  'application/x-rpm': 'rpm',
+  'application/zstd': 'zst',
+  'font/otf': 'otf',
+  'audio/amr': 'amr',
+  'application/rtf': 'rtf',
+  'video/x-flv': 'flv',
+  'audio/x-it': 'it',
+  'application/x-lzh-compressed': 'lzh',
+  'video/MP1S': 'mpg',
+  'video/MP2P': 'mpg',
+  'application/vnd.ms-htmlhelp': 'chm',
+  'application/x-xz': 'xz',
+  'application/xml': 'xml',
+  'application/x-7z-compressed': '7z',
+  'application/x-rar-compressed': 'rar',
+  'model/stl': 'stl',
+  'application/x-blender': 'blend',
+  'application/x-deb': 'deb',
+  'application/x-unix-archive': 'ar',
+  'image/png': 'png',
+  'image/apng': 'apng',
+  'application/x-apache-arrow': 'arrow',
+  'model/gltf-binary': 'glb',
+  'image/x-olympus-orf': 'orf',
+  'image/x-xcf': 'xcf',
+  'image/x-panasonic-rw2': 'rw2',
+  'audio/x-ms-asf': 'asf',
+  'video/x-ms-asf': 'asf',
+  'application/vnd.ms-asf': 'ktx',
+  'image/ktx': 'mie',
+  'application/x-mie': 'shp',
+  'application/x-esri-shape': 'jp2',
+  'image/jp2': 'jpx',
+  'image/jpx': 'jpm',
+  'image/jpm': 'mj2',
+  'image/mj2': 'jxl',
+  'image/jxl': 'xml',
+  'video/mpeg': 'ttf',
+  'font/ttf': 'ico',
+  'image/x-icon': 'cur',
+  'application/x-cfb': 'vcf',
+  'text/vcard': 'ics',
+  'text/calendar': 'raf',
+  'image/x-fujifilm-raf': 'xm',
+  'audio/x-xm': 'voc',
+  'audio/x-voc': 'asar',
+  'application/x-asar': 'mxf',
+  'application/mxf': 's3m',
+  'audio/x-s3m': 'mts',
+  'video/mp2t': 'mts',
+  'application/x-mobipocket-ebook': 'dcm',
+  'application/dicom': 'lnk',
+  'application/x.ms.shortcut': 'alias',
+  'application/x.apple.alias': 'eot',
+  'application/vnd.ms-fontobject': 'indd',
+  'application/x-indesign': 'tar',
+  'application/x-tar': 'skp',
+  'application/vnd.sketchup.skp': 'pgp',
+  'application/pgp-encrypted': 'aac',
+  'audio/aac': 'mp3',
+  'image/x-sony-arw': 'dng',
+  'image/x-adobe-dng': 'cr2',
+  'image/x-canon-cr2': 'nef',
+  'image/x-nikon-nef': 'tif',
+  'image/tiff': 'tiff'
+};
+var FileType = function FileType() {
+  var fileUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var mineType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  // 先从网址获取；
+  var url = fileUrl.replace(/#.+/g, '');
+  var laseIndex = url.lastIndexOf('.');
+  var extName = url.slice(laseIndex + 1).toLocaleLowerCase();
+  var matchExtName = '';
+  for (var _mineType in MineTypes) {
+    var ext = MineTypes[_mineType];
+    if (ext === extName) {
+      matchExtName = ext;
+      break;
+    }
+  }
+
+  // 没找到的话 在判断 mineType
+  if (!matchExtName) {
+    matchExtName = MineTypes[mineType] || extName;
+  }
+  return matchExtName;
+};
+export default FileType;

package/dist/lib/fs.d.ts

@@ -0,0 +1,14 @@
+export declare const fs: () => any;
+export declare function fsDirVideoList(dir: string): string[];
+export declare function getDirSize(dirPath: string): number;
+export declare function isFileExist(filePath: string): Promise<boolean>;
+export declare function isDirExist(dirPath: string): Promise<boolean>;
+export declare function writeFileText(filePath: string, content: any): Promise<true>;
+export declare function getFileText(filePath: string): Promise<string>;
+export declare function fileRename(oldFilePath: string, newFilePath: string): Promise<true>;
+export declare function fileIno(filePath: string): Promise<number>;
+export declare function getFileSize(filePath: string): Promise<number>;
+export declare function delFile(filePath: string): Promise<unknown>;
+export declare function delDirFiles(dirPath: string, oldTime?: number): Promise<unknown>;
+export declare function mkdir(directory: string): Promise<unknown>;
+export declare function isDirExistCreate(directory: string): Promise<boolean>;

package/dist/lib/fs.js

@@ -0,0 +1,479 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { VideoMineType } from "./allow-mine-type";
+import getFileExt from "./getFileExt";
+export var fs = function fs() {
+  return window.getBridge().fs;
+};
+var path = function path() {
+  return window.getBridge().path;
+};
+function fsDirWalk(dir) {
+  var _fs, _fs$readdirSync;
+  var size = 0;
+  (_fs = fs()) === null || _fs === void 0 || (_fs$readdirSync = _fs.readdirSync) === null || _fs$readdirSync === void 0 || _fs$readdirSync.call(_fs, dir).forEach(function (file) {
+    var filePath = path().join(dir, file);
+    var stat = fs().statSync(filePath);
+    if (stat.isDirectory()) {
+      size += fsDirWalk(filePath);
+    } else {
+      size += stat.size;
+    }
+  });
+  return size;
+}
+export function fsDirVideoList(dir) {
+  var _fs2, _fs2$readdirSync;
+  var list = [];
+  console.log('fsDirVideoList:', dir);
+  (_fs2 = fs()) === null || _fs2 === void 0 || (_fs2$readdirSync = _fs2.readdirSync) === null || _fs2$readdirSync === void 0 || _fs2$readdirSync.call(_fs2, dir).forEach(function (file) {
+    var filePath = path().join(dir, file);
+    var extName = getFileExt(file);
+    if ((VideoMineType === null || VideoMineType === void 0 ? void 0 : VideoMineType.indexOf(extName)) === -1) {
+      console.log('fsDirVideoList not video :', file, extName);
+      return;
+    }
+    list.push(filePath);
+    //
+    // console.log('fsDirVideoList:', file, extName );
+    //
+    //
+    // const stat = fs().statSync(filePath);
+    //
+    // console.log('fsDirVideoList stat.isDirectory():', stat.isDirectory() ,  stat.isFile()  );
+    //
+    // if ( ! stat.isDirectory()) {
+    //   list.push( filePath );
+    // }
+  });
+
+  return list;
+}
+export function getDirSize(dirPath) {
+  console.log('getDirSize:', dirPath);
+  return fsDirWalk(dirPath);
+}
+export function isFileExist(_x) {
+  return _isFileExist.apply(this, arguments);
+}
+function _isFileExist() {
+  _isFileExist = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(filePath) {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", new Promise(function (resolve, reject) {
+            try {
+              fs().stat(filePath, function (err) {
+                if (err) {
+                  console.log('isFileExist fs:', err);
+                  reject(err);
+                  return;
+                }
+                resolve(true);
+              });
+            } catch (e) {
+              reject(e);
+            }
+          }));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _isFileExist.apply(this, arguments);
+}
+export function isDirExist(_x2) {
+  return _isDirExist.apply(this, arguments);
+}
+function _isDirExist() {
+  _isDirExist = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(dirPath) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          return _context2.abrupt("return", new Promise(function (resolve, reject) {
+            try {
+              fs().stat(dirPath, function (err, stats) {
+                if (err) {
+                  console.log('isFileExist fs:', err);
+                  reject(err);
+                  return;
+                }
+                if (stats.isDirectory()) {
+                  return resolve(true);
+                }
+                var error = new Error('文件夹不存在，但存在同名文件');
+                error.name = 'not-dir-but-file';
+                reject(error);
+              });
+            } catch (e) {
+              reject(e);
+            }
+          }));
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _isDirExist.apply(this, arguments);
+}
+export function writeFileText(_x3, _x4) {
+  return _writeFileText.apply(this, arguments);
+}
+
+// 获取文本内容
+function _writeFileText() {
+  _writeFileText = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(filePath, content) {
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          return _context3.abrupt("return", new Promise(function (resolve, reject) {
+            var text = typeof content === 'string' ? content : JSON.stringify(content !== null && content !== void 0 ? content : '');
+            fs().writeFile(filePath, text, function (err) {
+              if (err) {
+                console.warn(err);
+                reject(err);
+                return;
+              }
+              console.log('内容已成功写入文件');
+              resolve(true);
+            });
+          }));
+        case 1:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _writeFileText.apply(this, arguments);
+}
+export function getFileText(_x5) {
+  return _getFileText.apply(this, arguments);
+}
+function _getFileText() {
+  _getFileText = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(filePath) {
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          return _context4.abrupt("return", new Promise(function (resolve, reject) {
+            fs().readFile(filePath, 'utf8', function (err, data) {
+              if (err) {
+                console.error('getFileText:', err);
+                reject(err);
+                return;
+              }
+              console.log(data);
+              resolve(data);
+            });
+          }));
+        case 1:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _getFileText.apply(this, arguments);
+}
+export function fileRename(_x6, _x7) {
+  return _fileRename.apply(this, arguments);
+}
+function _fileRename() {
+  _fileRename = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(oldFilePath, newFilePath) {
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          return _context5.abrupt("return", new Promise(function (resolve, reject) {
+            fs().rename(oldFilePath, newFilePath, function (err) {
+              if (err) {
+                console.log('fileRename err:', err);
+                reject(err);
+                console.log('re name fail:', err);
+                return;
+              }
+              resolve(true);
+            });
+          }));
+        case 1:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _fileRename.apply(this, arguments);
+}
+export function fileIno(_x8) {
+  return _fileIno.apply(this, arguments);
+}
+function _fileIno() {
+  _fileIno = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(filePath) {
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          return _context6.abrupt("return", new Promise(function (resolve, reject) {
+            fs().stat(filePath, function (err, stats) {
+              if (err) {
+                console.log('fileIno 2:', err);
+                reject(err);
+                return;
+              }
+              resolve(stats.size);
+            });
+          }));
+        case 1:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return _fileIno.apply(this, arguments);
+}
+export function getFileSize(_x9) {
+  return _getFileSize.apply(this, arguments);
+}
+function _getFileSize() {
+  _getFileSize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(filePath) {
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          return _context7.abrupt("return", fileIno(filePath));
+        case 1:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  }));
+  return _getFileSize.apply(this, arguments);
+}
+export function delFile(_x10) {
+  return _delFile.apply(this, arguments);
+}
+function _delFile() {
+  _delFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(filePath) {
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          return _context8.abrupt("return", new Promise(function (resolve, reject) {
+            fs().unlink(filePath, function (err) {
+              if (err) {
+                console.error('delFile:', filePath, err);
+                reject(err);
+                return;
+              }
+              resolve(true);
+            });
+          }));
+        case 1:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  }));
+  return _delFile.apply(this, arguments);
+}
+export function delDirFiles(_x11) {
+  return _delDirFiles.apply(this, arguments);
+}
+function _delDirFiles() {
+  _delDirFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(dirPath) {
+    var oldTime,
+      _args11 = arguments;
+    return _regeneratorRuntime().wrap(function _callee10$(_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          oldTime = _args11.length > 1 && _args11[1] !== undefined ? _args11[1] : 6 * 3600 * 1000;
+          console.log('delDirFiles:', dirPath, oldTime);
+          return _context11.abrupt("return", new Promise( /*#__PURE__*/function () {
+            var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(resolve, reject) {
+              var _fs3, _fs3$readdirSync;
+              var fileList, _iterator, _step, _loop;
+              return _regeneratorRuntime().wrap(function _callee9$(_context10) {
+                while (1) switch (_context10.prev = _context10.next) {
+                  case 0:
+                    fileList = ((_fs3 = fs()) === null || _fs3 === void 0 || (_fs3$readdirSync = _fs3.readdirSync) === null || _fs3$readdirSync === void 0 ? void 0 : _fs3$readdirSync.call(_fs3, dirPath)) || [];
+                    console.log('delDirFiles 1:', fileList);
+                    _iterator = _createForOfIteratorHelper(fileList);
+                    _context10.prev = 3;
+                    _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+                      var filePath, fileFullPath;
+                      return _regeneratorRuntime().wrap(function _loop$(_context9) {
+                        while (1) switch (_context9.prev = _context9.next) {
+                          case 0:
+                            filePath = _step.value;
+                            fileFullPath = path().join(dirPath, filePath);
+                            if (!(oldTime <= 0)) {
+                              _context9.next = 6;
+                              break;
+                            }
+                            _context9.next = 5;
+                            return new Promise(function (resolve, reject) {
+                              fs().rm(fileFullPath, {
+                                force: true
+                              }, function (err) {
+                                resolve(true);
+                              });
+                            });
+                          case 5:
+                            return _context9.abrupt("return", 1);
+                          case 6:
+                            _context9.next = 8;
+                            return new Promise(function (resolve, reject) {
+                              fs().stat(fileFullPath, function (err, stats) {
+                                if (err) {
+                                  console.log('delDirFiles 2:', err);
+                                  reject(err);
+                                  return;
+                                }
+                                // console.log('fileList stats:', stats );
+                                if (stats.birthtimeMs + oldTime < Date.now()) {
+                                  fs().rm(fileFullPath, {
+                                    force: true
+                                  }, function (err) {
+                                    if (err) {
+                                      console.log('delDirFiles 3:', err);
+                                      return reject(err);
+                                    }
+                                    resolve(true);
+                                  });
+                                } else {
+                                  resolve(true);
+                                }
+                              });
+                            }).catch(function (err) {
+                              console.log("del err:", err);
+                            });
+                          case 8:
+                          case "end":
+                            return _context9.stop();
+                        }
+                      }, _loop);
+                    });
+                    _iterator.s();
+                  case 6:
+                    if ((_step = _iterator.n()).done) {
+                      _context10.next = 12;
+                      break;
+                    }
+                    return _context10.delegateYield(_loop(), "t0", 8);
+                  case 8:
+                    if (!_context10.t0) {
+                      _context10.next = 10;
+                      break;
+                    }
+                    return _context10.abrupt("continue", 10);
+                  case 10:
+                    _context10.next = 6;
+                    break;
+                  case 12:
+                    _context10.next = 17;
+                    break;
+                  case 14:
+                    _context10.prev = 14;
+                    _context10.t1 = _context10["catch"](3);
+                    _iterator.e(_context10.t1);
+                  case 17:
+                    _context10.prev = 17;
+                    _iterator.f();
+                    return _context10.finish(17);
+                  case 20:
+                    resolve(true);
+                  case 21:
+                  case "end":
+                    return _context10.stop();
+                }
+              }, _callee9, null, [[3, 14, 17, 20]]);
+            }));
+            return function (_x14, _x15) {
+              return _ref.apply(this, arguments);
+            };
+          }()));
+        case 3:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee10);
+  }));
+  return _delDirFiles.apply(this, arguments);
+}
+export function mkdir(_x12) {
+  return _mkdir.apply(this, arguments);
+}
+
+// 检查存在，并创建
+function _mkdir() {
+  _mkdir = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(directory) {
+    return _regeneratorRuntime().wrap(function _callee11$(_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          return _context12.abrupt("return", new Promise(function (resolve, reject) {
+            fs().mkdir(directory, {
+              recursive: true
+            }, function (err) {
+              if (err) {
+                console.error(err);
+                return reject(err);
+              }
+              console.log('Directory created successfully');
+              resolve(true);
+            });
+          }));
+        case 1:
+        case "end":
+          return _context12.stop();
+      }
+    }, _callee11);
+  }));
+  return _mkdir.apply(this, arguments);
+}
+export function isDirExistCreate(_x13) {
+  return _isDirExistCreate.apply(this, arguments);
+}
+function _isDirExistCreate() {
+  _isDirExistCreate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(directory) {
+    return _regeneratorRuntime().wrap(function _callee13$(_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          return _context14.abrupt("return", new Promise( /*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(resolve, reject) {
+              var isExist, createDir;
+              return _regeneratorRuntime().wrap(function _callee12$(_context13) {
+                while (1) switch (_context13.prev = _context13.next) {
+                  case 0:
+                    _context13.next = 2;
+                    return isDirExist(directory).catch(function (err) {});
+                  case 2:
+                    isExist = _context13.sent;
+                    if (!isExist) {
+                      _context13.next = 5;
+                      break;
+                    }
+                    return _context13.abrupt("return", resolve(true));
+                  case 5:
+                    _context13.next = 7;
+                    return mkdir(directory).catch(function (err) {
+                      reject(err);
+                    });
+                  case 7:
+                    createDir = _context13.sent;
+                    if (createDir) {
+                      resolve(true);
+                    }
+                  case 9:
+                  case "end":
+                    return _context13.stop();
+                }
+              }, _callee12);
+            }));
+            return function (_x16, _x17) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 1:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee13);
+  }));
+  return _isDirExistCreate.apply(this, arguments);
+}

package/dist/lib/getFileExt.d.ts

@@ -0,0 +1,2 @@
+declare const getFileExt: (fileUrl: string) => string;
+export default getFileExt;

package/dist/lib/getFileExt.js

@@ -0,0 +1,6 @@
+var getFileExt = function getFileExt(fileUrl) {
+  var _split, _ref;
+  var url = ((_split = (fileUrl || '').split(/[#?/]/g)) === null || _split === void 0 ? void 0 : _split[0].match(/\.([a-z0-9]+)$/i)) || [];
+  return ((_ref = url[1] || '') === null || _ref === void 0 ? void 0 : _ref.toLocaleLowerCase()) || '';
+};
+export default getFileExt;

package/dist/lib/save-path.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import './save-path.less';
+import type { SizeType } from "antd/es/config-provider/SizeContext";
+interface Props {
+    isDefaultEmpty?: boolean;
+    size?: SizeType;
+    label?: React.ReactNode;
+    disabled?: boolean;
+    path?: string;
+    placeholder?: string;
+    hiddenOpenDir?: boolean;
+    onChange?: (path: string) => void;
+    onBeforeSelect?: () => boolean | Promise<boolean>;
+}
+export declare const getSavePath: (productType: string) => void;
+declare const SavePath: React.FC<Props>;
+export default SavePath;