@elice/material-exercise 1.220803.0

package/cjs/components/shared/file-tree/context/FileTreeContext.js

@@ -0,0 +1,202 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+require('filesize');
+var fileTreeGenerator = require('../utils/fileTreeGenerator.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const StateContext = React__default["default"].createContext(undefined);
+const DispatchContext = React__default["default"].createContext(undefined);
+StateContext.displayName = 'FileTreeStateContext';
+DispatchContext.displayName = 'FileTreeDispatchContext';
+
+function reducer(state, action) {
+  switch (action.type) {
+    case 'UPDATE_THEME':
+      return Object.assign(Object.assign({}, state), {
+        theme: action.theme
+      });
+
+    case 'TOGGLE_OPENED_DIRECTORY_LIST':
+      return Object.assign(Object.assign({}, state), {
+        openedDirectoryList: state.openedDirectoryList.includes(action.path) ? state.openedDirectoryList.filter(path => path !== action.path) : [...state.openedDirectoryList, action.path]
+      });
+
+    case 'ADD_OPENED_DIRECTORY_LIST':
+      return Object.assign(Object.assign({}, state), {
+        openedDirectoryList: [...new Set([...state.openedDirectoryList, action.path])]
+      });
+
+    case 'NEW_INPUT_OPEN':
+      return Object.assign(Object.assign({}, state), {
+        newInput: {
+          type: action.newInput.type,
+          path: action.newInput.path
+        },
+        openedDirectoryList: [...state.openedDirectoryList, action.newInput.path]
+      });
+
+    case 'NEW_INPUT_CLOSE':
+      return Object.assign(Object.assign({}, state), {
+        newInput: undefined
+      });
+
+    case 'UPDATE_FILE_TREE':
+      return Object.assign(Object.assign({}, state), {
+        fileTree: action.fileTree
+      });
+
+    case 'UPDATE_RENAME_INPUT_PATH':
+      return Object.assign(Object.assign({}, state), {
+        renameInputPath: action.path
+      });
+
+    case 'UPDATE_DRAGGED_PATH':
+      return Object.assign(Object.assign({}, state), {
+        draggedPath: action.path
+      });
+
+    case 'UPDATE_DROPZONE_PATH':
+      return Object.assign(Object.assign({}, state), {
+        dropzonePath: action.path
+      });
+
+    case 'UPDATE_MODE':
+      return Object.assign(Object.assign({}, state), {
+        mode: action.mode
+      });
+
+    case 'INITIAL_OPEN_FILELIST_UPDATE':
+      return Object.assign(Object.assign({}, state), {
+        initialOpenFileListTemp: [...action.initialOpenFilelist]
+      });
+
+    case 'INITIAL_OPEN_FILELIST_ADD':
+      return Object.assign(Object.assign({}, state), {
+        initialOpenFileListTemp: [...state.initialOpenFileListTemp, action.path]
+      });
+
+    case 'INITIAL_OPEN_FILELIST_REMOVE':
+      return Object.assign(Object.assign({}, state), {
+        initialOpenFileListTemp: state.initialOpenFileListTemp.filter(path => path !== action.path)
+      });
+
+    default:
+      return state;
+  }
+}
+
+const init = state => Object.assign({}, state);
+
+function FileTreeProvider({
+  theme = 'dark',
+  collapsed = false,
+  activePath,
+  allowToggleReadonly = false,
+  allowToggleHidden = false,
+  onCollapse,
+  onActivePathChange,
+  maxFileUploadSize = 50,
+  onFilesUpload,
+  onFileAdd,
+  onDirectoryAdd,
+  onHiddenSet,
+  onReadOnlySet,
+  onFileDelete,
+  onDirectoryDelete,
+  onFileMove,
+  onDirectoryMove,
+  exerciseRoomFilelist,
+  imageFilelist,
+  readOnlyFilelist,
+  hiddenFilelist,
+  isHiddenFilelistVisible = false,
+  children
+}) {
+  const [state, dispatch] = React__default["default"].useReducer(reducer, {
+    mode: 'default',
+    maxFileUploadSize,
+    draggedPath: null,
+    dropzonePath: null,
+    openedDirectoryList: [],
+    initialOpenFileListTemp: [],
+    theme,
+    fileTree: fileTreeGenerator.create({
+      exerciseRoomFilelist,
+      imageFilelist,
+      hiddenFilelist,
+      readOnlyFilelist,
+      openedDirectoryList: []
+    })
+  }, init);
+  React__default["default"].useEffect(() => {
+    dispatch({
+      type: 'UPDATE_FILE_TREE',
+      fileTree: fileTreeGenerator.create({
+        exerciseRoomFilelist,
+        imageFilelist,
+        hiddenFilelist,
+        readOnlyFilelist,
+        initialOpenFilelist: state.initialOpenFileListTemp,
+        openedDirectoryList: state.openedDirectoryList,
+        newInput: state.newInput,
+        renameInputPath: state.renameInputPath
+      })
+    });
+  }, [exerciseRoomFilelist, imageFilelist, hiddenFilelist, readOnlyFilelist, state.initialOpenFileListTemp, state.openedDirectoryList, state.newInput, state.renameInputPath]);
+  return (// StateContext and DispatchContext are seperated on purpose in order to optimize rendering performance.
+    React__default["default"].createElement(StateContext.Provider, {
+      value: Object.assign(Object.assign({}, state), {
+        collapsed,
+        activePath,
+        allowToggleReadonly,
+        allowToggleHidden,
+        isHiddenFilelistVisible
+      })
+    }, React__default["default"].createElement(DispatchContext.Provider, {
+      value: {
+        dispatch,
+        onCollapse,
+        onActivePathChange,
+        onFileAdd,
+        onDirectoryAdd,
+        onHiddenSet,
+        onReadOnlySet,
+        onFileDelete,
+        onDirectoryDelete,
+        onFileMove,
+        onDirectoryMove,
+        onFilesUpload
+      }
+    }, children))
+  );
+}
+
+function useFileTreeState() {
+  const context = React__default["default"].useContext(StateContext);
+
+  if (context === undefined) {
+    throw new Error('useFileTreeState must be used within a FileTreeProvider');
+  }
+
+  return context;
+}
+
+function useFileTreeDispatch() {
+  const context = React__default["default"].useContext(DispatchContext);
+
+  if (context === undefined) {
+    throw new Error('useFileTreeDispatch must be used within a FileTreeProvider');
+  }
+
+  return context;
+}
+
+exports.FileTreeProvider = FileTreeProvider;
+exports.useFileTreeDispatch = useFileTreeDispatch;
+exports.useFileTreeState = useFileTreeState;

package/cjs/components/shared/file-tree/context/index.d.ts

@@ -0,0 +1 @@
+export * from './FileTreeContext';

package/cjs/components/shared/file-tree/index.d.ts

@@ -0,0 +1,15 @@
+export { default as FileTree } from './FileTree';
+export type { FileTreeProps } from './FileTree';
+export type { FileTreeToolbarProps } from './FileTreeToolbar';
+export type { FileTreeListProps } from './FileTreeList';
+export type { FileTreeConfigProps } from './FileTreeConfig';
+export type { OnDirectoryAdd, OnDirectoryAddParams } from './interface';
+export type { OnFileAdd, OnFileAddParams } from './interface';
+export type { OnDirectoryDelete } from './interface';
+export type { OnFileDelete } from './interface';
+export type { OnFilesUpload, OnFilesUploadParams } from './interface';
+export type { OnDirectoryMove, OnDirectoryMoveParams } from './interface';
+export type { OnFileMove, OnFileMoveParams } from './interface';
+export type { OnHiddenSet, OnHiddenSetParams } from './interface';
+export type { OnInitialOpenFileSet, OnInitialOpenFileSetParams, } from './interface';
+export type { OnReadOnlySet, OnReadOnlySetParams } from './interface';

package/cjs/components/shared/file-tree/interface/index.d.ts

@@ -0,0 +1,47 @@
+export declare type OnFileAddParams = {
+    path: string;
+    userFile?: File;
+    emptyFileWithName?: string;
+    overwrite?: boolean;
+};
+export declare type OnFileAdd = (params: OnFileAddParams) => Promise<any>;
+export declare type OnDirectoryAddParams = {
+    path: string;
+    name: string;
+    overwrite?: boolean;
+};
+export declare type OnDirectoryAdd = (params: OnDirectoryAddParams) => Promise<any>;
+export declare type OnHiddenSetParams = {
+    path: string;
+    isHidden: boolean;
+};
+export declare type OnHiddenSet = (params: OnHiddenSetParams) => void;
+export declare type OnReadOnlySetParams = {
+    path: string;
+    isReadOnly: boolean;
+};
+export declare type OnReadOnlySet = (params: OnReadOnlySetParams) => void;
+export declare type OnFileDelete = (path: string) => Promise<any>;
+export declare type OnDirectoryDelete = (path: string) => Promise<any>;
+export declare type OnFileMoveParams = {
+    currentFilename: string;
+    newPath: string;
+    newName: string;
+};
+export declare type OnFileMove = (params: OnFileMoveParams) => Promise<any>;
+export declare type OnDirectoryMoveParams = {
+    currentFilename: string;
+    newPath: string;
+    newName: string;
+};
+export declare type OnDirectoryMove = (params: OnDirectoryMoveParams) => Promise<any>;
+export declare type OnInitialOpenFileSetParams = {
+    path: string;
+    isInitialOpen: boolean;
+};
+export declare type OnInitialOpenFileSet = (params: OnInitialOpenFileSetParams) => void;
+export declare type OnFilesUploadParams = {
+    files: FileList;
+    path: string;
+};
+export declare type OnFilesUpload = (params: OnFilesUploadParams) => void;

package/cjs/components/shared/file-tree/locales/en.json.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var phrasesEn = {"fileTree.list.item.content.input.validation.error.filename.dot":"The filename can't be \".\" or \"..\".","fileTree.list.item.content.input.validation.error.filename.dotElice":"The filename can't be \".elice\".","fileTree.list.item.content.input.validation.error.filename.duplicated":"The file name is already used.","fileTree.list.item.content.input.validation.error.filename.slash":"The filename can't include slash or backslash.","fileTree.list.item.content.input.validation.error.maxLength":"The filename can't be more than {maxLength} characters long.","fileTree.list.item.content.input.validation.error.required":"Please enter a filename.","fileTree.list.item.content.menu.deleteConfirmDialog.body":"Are you sure you want to delete \"{title}\"?","fileTree.list.item.content.menu.deleteConfirmDialog.cancel":"Cancel","fileTree.list.item.content.menu.deleteConfirmDialog.confirm":"Delete","fileTree.list.item.content.menu.deleteConfirmDialog.title":"Confirm Delete","fileTree.list.item.content.menu.item.delete":"Delete","fileTree.list.item.content.menu.item.hiddenSet":"Set Hidden","fileTree.list.item.content.menu.item.hiddenUnset":"Unset Hidden","fileTree.list.item.content.menu.item.newDirectory":"New Directory","fileTree.list.item.content.menu.item.newFile":"New File","fileTree.list.item.content.menu.item.readOnlySet":"Set Read-only","fileTree.list.item.content.menu.item.readOnlyUnset":"Unset Read-only","fileTree.list.item.content.menu.item.rename":"Rename","fileTree.toolbar.newDirectory":"New Directory","fileTree.toolbar.newFile":"New File","fileTree.toolbar.upload":"Upload File"};
+
+module.exports = phrasesEn;

package/cjs/components/shared/file-tree/locales/ko.json.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var phrasesKo = {"fileTree.list.item.content.input.validation.error.filename.dot":"파일 이름은 \".\" 혹은 \"..\"을 사용할 수 없습니다.","fileTree.list.item.content.input.validation.error.filename.dotElice":"파일 이름은 \".elice\"를 사용할 수 없습니다.","fileTree.list.item.content.input.validation.error.filename.duplicated":"이미 존재하는 파일 이름입니다.","fileTree.list.item.content.input.validation.error.filename.slash":"파일 이름은 슬래시나 역슬래시를 포함할 수 없습니다.","fileTree.list.item.content.input.validation.error.maxLength":"파일 이름은 {maxLength}자를 초과할 수 없습니다..","fileTree.list.item.content.input.validation.error.required":"파일 이름을 입력해주세요.","fileTree.list.item.content.menu.deleteConfirmDialog.body":"\"{title}\" 파일을 삭제하시겠습니까?","fileTree.list.item.content.menu.deleteConfirmDialog.cancel":"취소","fileTree.list.item.content.menu.deleteConfirmDialog.confirm":"확인","fileTree.list.item.content.menu.deleteConfirmDialog.title":"파일 삭제","fileTree.list.item.content.menu.item.delete":"삭제","fileTree.list.item.content.menu.item.hiddenSet":"파일 숨기기","fileTree.list.item.content.menu.item.hiddenUnset":"파일 보이기","fileTree.list.item.content.menu.item.newDirectory":"새 폴더","fileTree.list.item.content.menu.item.newFile":"새 파일","fileTree.list.item.content.menu.item.readOnlySet":"읽기 전용","fileTree.list.item.content.menu.item.readOnlyUnset":"읽기 전용 해제","fileTree.list.item.content.menu.item.rename":"이름 바꾸기","fileTree.toolbar.newDirectory":"새 폴더 추가","fileTree.toolbar.newFile":"새 파일 추가","fileTree.toolbar.upload":"파일 업로드"};
+
+module.exports = phrasesKo;

package/cjs/components/shared/file-tree/utils/fileTreeFiles.d.ts

@@ -0,0 +1,2 @@
+export declare const validateFileSize: (file: File, maxFileUploadSize: number) => boolean;
+export declare const validateFilesSize: (files: FileList, maxFileUploadSize: number) => boolean;

package/cjs/components/shared/file-tree/utils/fileTreeFiles.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var filesize = require('filesize');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var filesize__default = /*#__PURE__*/_interopDefaultLegacy(filesize);
+
+const validateFileSize = (file, maxFileUploadSize) => {
+  const {
+    value: currentSize,
+    unit: currentUnit
+  } = filesize__default["default"](file.size, {
+    output: 'object',
+    base: 10,
+    exponent: 2
+  });
+  const {
+    value: maxSize,
+    unit: maxUnit
+  } = filesize__default["default"](maxFileUploadSize * 1024 * 1024, {
+    output: 'object',
+    base: 10,
+    exponent: 2
+  });
+
+  if (currentSize > maxSize) {
+    alert(`The file size can be up to ${maxSize}${maxUnit}, but your file(${file.name}) size is ${currentSize}${currentUnit}.`);
+    return false;
+  }
+
+  return true;
+};
+const validateFilesSize = (files, maxFileUploadSize) => {
+  return Array.from(files).every(file => validateFileSize(file, maxFileUploadSize));
+};
+
+exports.validateFileSize = validateFileSize;
+exports.validateFilesSize = validateFilesSize;

package/cjs/components/shared/file-tree/utils/fileTreeGenerator.d.ts

@@ -0,0 +1,68 @@
+import type { NewInput } from '../context';
+export declare class FileTreeRoot {
+    readonly root: FileTreeNode;
+    readonly directoryNodes: {
+        [key: string]: FileTreeNode;
+    };
+    imageFilelist: string[];
+    readOnlyFilelist: string[];
+    hiddenFilelist: string[];
+    openedDirectoryList: string[];
+    renameInputPath?: string;
+    initialOpenFilelist: string[];
+    constructor({ imageFilelist, readOnlyFilelist, hiddenFilelist, openedDirectoryList, renameInputPath, initialOpenFilelist, }: {
+        imageFilelist: string[];
+        readOnlyFilelist: string[];
+        hiddenFilelist: string[];
+        openedDirectoryList: string[];
+        newInputDirectoryPath?: string;
+        newInputFilePath?: string;
+        renameInputPath?: string;
+        initialOpenFilelist?: string[];
+    });
+    createDirectoryNode(path: string, parentPath: string): FileTreeNode;
+    createFileNode(path: string, parentPath: string): FileTreeNode;
+    getParentNode(path: string): FileTreeNode;
+    insert(path: string): void;
+    insertInputNode(path: string, inputType: 'directory' | 'file'): void;
+    _setDirectoriesRemovable(node: FileTreeNode): boolean;
+}
+export declare class FileTreeNode {
+    readonly path: string;
+    readonly title: string;
+    readonly isDirectory: boolean;
+    readonly isEdit: boolean;
+    isReadonly: boolean;
+    isRemovable: boolean;
+    isHidden: boolean;
+    expanded: boolean;
+    isRenaming: boolean;
+    children: FileTreeNode[];
+    parentPath: string;
+    isInitialOpen: boolean;
+    constructor({ path, parentPath, title, isDirectory, isReadonly, isRemovable, isHidden, expanded, isEdit, isRenaming, isInitialOpen, }: {
+        path: string;
+        parentPath: string;
+        title?: string;
+        isDirectory?: boolean;
+        isReadonly?: boolean;
+        isRemovable?: boolean;
+        isHidden?: boolean;
+        expanded?: boolean;
+        isEdit?: boolean;
+        isRenaming?: boolean;
+        isInitialOpen?: boolean;
+    });
+    findTreeNode(path: string, depth?: number): FileTreeNode | undefined;
+}
+export declare function create({ imageFilelist, exerciseRoomFilelist, openedDirectoryList, hiddenFilelist, readOnlyFilelist, newInput, renameInputPath, initialOpenFilelist, }: {
+    imageFilelist: string[];
+    exerciseRoomFilelist: string[];
+    openedDirectoryList: string[];
+    hiddenFilelist?: string[];
+    readOnlyFilelist?: string[];
+    newInput?: NewInput;
+    renameInputPath?: string;
+    initialOpenFilelist?: string[];
+}): FileTreeNode;
+export declare function getParentPath(path: string): string;

package/cjs/components/shared/file-tree/utils/fileTreeGenerator.js

@@ -0,0 +1,250 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fileTreeItem = require('./fileTreeItem.js');
+
+class FileTreeRoot {
+  constructor({
+    imageFilelist = [],
+    readOnlyFilelist = [],
+    hiddenFilelist = [],
+    openedDirectoryList = [],
+    renameInputPath,
+    initialOpenFilelist = []
+  }) {
+    this.root = new FileTreeNode({
+      path: '',
+      expanded: true,
+      parentPath: ''
+    });
+    this.directoryNodes = {};
+    this.imageFilelist = imageFilelist;
+    this.readOnlyFilelist = readOnlyFilelist;
+    this.hiddenFilelist = hiddenFilelist;
+    this.openedDirectoryList = openedDirectoryList;
+    this.renameInputPath = renameInputPath;
+    this.initialOpenFilelist = initialOpenFilelist;
+  }
+
+  createDirectoryNode(path, parentPath) {
+    return new FileTreeNode({
+      path,
+      expanded: this.openedDirectoryList.includes(path),
+      isDirectory: true,
+      isRenaming: path === this.renameInputPath,
+      parentPath
+    });
+  }
+
+  createFileNode(path, parentPath) {
+    return new FileTreeNode({
+      path,
+      isRenaming: path === this.renameInputPath,
+      parentPath,
+      isInitialOpen: this.initialOpenFilelist.includes(path)
+    });
+  }
+
+  getParentNode(path) {
+    const parentPath = getParentPath(path); // root scope
+
+    if (!parentPath) {
+      return this.root;
+    } else if (this.directoryNodes[parentPath]) {
+      return this.directoryNodes[parentPath];
+    } else {
+      const grandParentNode = this.getParentNode(parentPath);
+      const parentNode = this.createDirectoryNode(parentPath, grandParentNode.path);
+      grandParentNode.children.push(parentNode);
+      grandParentNode.children = arrangeFileAndDirectoryNameByPath(grandParentNode.children);
+      this.directoryNodes[parentPath] = parentNode;
+      return parentNode;
+    }
+  }
+
+  insert(path) {
+    let parentNode = null;
+    let node = null; // folder
+
+    if (path.endsWith('/')) {
+      const cleanPath = path.slice(0, path.length - 1);
+      parentNode = this.getParentNode(cleanPath);
+      node = this.createDirectoryNode(cleanPath, parentNode.path); // if directory does not exist, add a new node
+
+      if (!this.directoryNodes[cleanPath]) {
+        this.directoryNodes[cleanPath] = node;
+        parentNode.children.push(node);
+        parentNode.children = arrangeFileAndDirectoryNameByPath(parentNode.children);
+      }
+    } else {
+      // file
+      parentNode = this.getParentNode(path);
+      node = this.createFileNode(path, parentNode.path);
+
+      if (this.imageFilelist.includes(path)) {
+        node.isRemovable = false;
+        node.isReadonly = this.readOnlyFilelist.includes(path);
+        node.isHidden = this.hiddenFilelist.includes(path);
+      }
+
+      parentNode.children.push(node);
+      parentNode.children = arrangeFileAndDirectoryNameByPath(parentNode.children);
+    }
+  }
+
+  insertInputNode(path, inputType) {
+    const isRoot = path === '';
+    const tree = new FileTreeNode({
+      path: isRoot ? '' : path + '/',
+      expanded: this.openedDirectoryList.includes(path),
+      isDirectory: inputType === 'directory',
+      isEdit: true,
+      title: '*',
+      parentPath: path
+    });
+
+    if (isRoot) {
+      this.root.children = [tree, ...this.root.children];
+      this.root.children = arrangeFileAndDirectoryNameByPath(this.root.children);
+    } else {
+      this.directoryNodes[path].expanded = true;
+      this.directoryNodes[path].children = [tree, ...this.directoryNodes[path].children];
+      this.directoryNodes[path].children = arrangeFileAndDirectoryNameByPath(this.directoryNodes[path].children);
+    }
+  }
+
+  _setDirectoriesRemovable(node) {
+    for (const child of node.children) {
+      if (child.isDirectory) {
+        if (!this._setDirectoriesRemovable(child)) {
+          node.isRemovable = false;
+        }
+      } else if (!child.isRemovable) {
+        node.isRemovable = false;
+      }
+    }
+
+    if (this.imageFilelist.includes(node.path + '/')) {
+      node.isRemovable = false;
+    }
+
+    return node.isRemovable;
+  }
+
+}
+class FileTreeNode {
+  constructor({
+    path,
+    parentPath,
+    title,
+    isDirectory = false,
+    isReadonly = false,
+    isRemovable = true,
+    isHidden = false,
+    expanded = false,
+    isEdit = false,
+    isRenaming = false,
+    isInitialOpen = false
+  }) {
+    const _title = title === undefined ? fileTreeItem.getTitle(path) : title;
+
+    this.path = path;
+    this.parentPath = parentPath;
+    this.title = _title;
+    this.isDirectory = isDirectory;
+    this.isReadonly = isReadonly;
+    this.isRemovable = isRemovable;
+    this.isHidden = isHidden;
+    this.expanded = expanded;
+    this.isEdit = isEdit;
+    this.isRenaming = isRenaming;
+    this.isInitialOpen = isInitialOpen;
+    this.children = [];
+  }
+
+  findTreeNode(path, depth = 0) {
+    if (this.path === path) {
+      return this;
+    }
+
+    for (let i = 0; i < this.children.length; i++) {
+      if (path.split('/')[depth] === this.children[i].path.split('/')[depth]) {
+        return this.findTreeNode.call(this.children[i], path, depth + 1);
+      }
+    }
+
+    return;
+  }
+
+}
+function create({
+  imageFilelist,
+  exerciseRoomFilelist,
+  openedDirectoryList,
+  hiddenFilelist = [],
+  readOnlyFilelist = [],
+  newInput,
+  renameInputPath,
+  initialOpenFilelist
+}) {
+  const tree = new FileTreeRoot({
+    imageFilelist,
+    hiddenFilelist,
+    openedDirectoryList,
+    readOnlyFilelist,
+    renameInputPath,
+    initialOpenFilelist
+  });
+  const allPathes = removeDuplicatedString([...exerciseRoomFilelist, ...imageFilelist]);
+  allPathes.forEach(path => tree.insert(path));
+
+  if (newInput) {
+    tree.insertInputNode(newInput.path, newInput.type);
+  }
+
+  tree._setDirectoriesRemovable(tree.root);
+
+  return tree.root;
+}
+
+function removeDuplicatedString(array) {
+  return [...new Set(array)];
+}
+
+function getParentPath(path) {
+  return path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '';
+}
+
+function arrangeFileAndDirectoryNameByPath(fileTreeNodeList) {
+  return [...fileTreeNodeList.filter(({
+    isDirectory
+  }) => isDirectory).sort((a, b) => {
+    if (a.path < b.path) {
+      return -1;
+    }
+
+    if (a.path > b.path) {
+      return 1;
+    }
+
+    return 0;
+  }), ...fileTreeNodeList.filter(({
+    isDirectory
+  }) => !isDirectory).sort((a, b) => {
+    if (a.path < b.path) {
+      return -1;
+    }
+
+    if (a.path > b.path) {
+      return 1;
+    }
+
+    return 0;
+  })];
+}
+
+exports.FileTreeNode = FileTreeNode;
+exports.FileTreeRoot = FileTreeRoot;
+exports.create = create;
+exports.getParentPath = getParentPath;

package/cjs/components/shared/file-tree/utils/fileTreeInput.d.ts

@@ -0,0 +1,4 @@
+import type { NewInput } from '../context';
+import type { FileTreeNode } from './fileTreeGenerator';
+export declare function getTargetDirectoryPath(fileTreeNode?: FileTreeNode): string;
+export declare function getInputNodeIndex(fileTree: FileTreeNode, newInput?: NewInput): number | undefined;

package/cjs/components/shared/file-tree/utils/fileTreeInput.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function getTargetDirectoryPath(fileTreeNode) {
+  if (!fileTreeNode) {
+    return '';
+  }
+
+  return fileTreeNode.isDirectory ? fileTreeNode.path : fileTreeNode.parentPath;
+}
+
+exports.getTargetDirectoryPath = getTargetDirectoryPath;

package/cjs/components/shared/file-tree/utils/fileTreeItem.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Get title of tree item from path.
+ * @param path  Path of tree item.
+ */
+export declare function getTitle(path: string): string;

package/cjs/components/shared/file-tree/utils/fileTreeItem.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get title of tree item from path.
+ * @param path  Path of tree item.
+ */
+function getTitle(path) {
+  const splitTitleArr = path.split('/');
+  return splitTitleArr[splitTitleArr.length - 1];
+}
+
+exports.getTitle = getTitle;